feat: extended the bundler to compiling TypeScript declaration files only, now you can compile and .d.ts, .d.cts and .d.mts file without a .ts file

Author: prisis

packages/packem/__tests__/intigration/__snapshots__/typescript.test.ts.snap

@@ -414,6 +414,41 @@ exports.deepKeysFromList = deeksExports.deepKeysFromList;
 "
 `;
 
+exports[`packem typescript > should compile a .d.ts file into .d.cts and .d.mts > .d.cts type code output 1`] = `
+"declare global {
+    interface String {
+
+    }
+}
+
+type NativeStringTypes = string;
+
+export type { NativeStringTypes };
+"
+`;
+
+exports[`packem typescript > should compile a .d.ts file into .d.cts and .d.mts > .d.mts type code output 1`] = `
+"declare global {
+    interface String {
+
+    }
+}
+
+type NativeStringTypes = string;
+
+export type { NativeStringTypes };
+"
+`;
+
+exports[`packem typescript > should compile only a type file > .d.ts type code output 1`] = `
+"declare global {
+    interface String {
+
+    }
+}
+"
+`;
+
 exports[`packem typescript > should support typescript decorator > cjs code output 1`] = `
 "'use strict';
 

packages/packem/__tests__/intigration/typescript.test.ts

@@ -2914,4 +2914,89 @@ export { type DeeksOptions as DeepKeysOptions, deepKeys, deepKeysFromList };
 
         expect(mtsContent).toMatchSnapshot("mjs content");
     });
+
+    it("should compile only a type file", async () => {
+        expect.assertions(3);
+
+        await writeFile(`${temporaryDirectoryPath}/src/native-string-types.d.ts`, `
+declare global {
+    interface String {
+
+    }
+}
+`);
+
+        await installPackage(temporaryDirectoryPath, "typescript");
+        await createTsConfig(temporaryDirectoryPath);
+        await createPackageJson(temporaryDirectoryPath, {
+            devDependencies: {
+                typescript: "*",
+            },
+            exports: {
+                "./native-string-types": {
+                    types: "./native-string-types.d.ts",
+                },
+            },
+        });
+        await createPackemConfig(temporaryDirectoryPath);
+
+        const binProcess = await execPackemSync("build", [], {
+            cwd: temporaryDirectoryPath,
+        });
+
+        expect(binProcess.stderr).toBe("");
+        expect(binProcess.exitCode).toBe(0);
+
+        const dTsContent = await readFile(`${temporaryDirectoryPath}/dist/native-string-types.d.ts`);
+
+        expect(dTsContent).toMatchSnapshot(".d.ts type code output");
+    });
+
+    it("should compile a .d.ts file into .d.cts and .d.mts", async () => {
+        expect.assertions(4);
+
+        await writeFile(`${temporaryDirectoryPath}/src/native-string-types.d.ts`, `
+declare global {
+    interface String {
+
+    }
+}
+
+export type NativeStringTypes = string;
+`);
+
+        await installPackage(temporaryDirectoryPath, "typescript");
+        await createTsConfig(temporaryDirectoryPath);
+        await createPackageJson(temporaryDirectoryPath, {
+            devDependencies: {
+                typescript: "*",
+            },
+            exports: {
+                "./native-string-types": {
+                    import: {
+                        types: "./native-string-types.d.mts",
+                    },
+                    require: {
+                        types: "./native-string-types.d.cts",
+                    },
+                },
+            },
+        });
+        await createPackemConfig(temporaryDirectoryPath);
+
+        const binProcess = await execPackemSync("build", [], {
+            cwd: temporaryDirectoryPath,
+        });
+console.log(binProcess.stdout);
+        expect(binProcess.stderr).toBe("");
+        expect(binProcess.exitCode).toBe(0);
+
+        const dCtsContent = await readFile(`${temporaryDirectoryPath}/dist/native-string-types.d.cts`);
+
+        expect(dCtsContent).toMatchSnapshot(".d.cts type code output");
+
+        const dMtsContent = await readFile(`${temporaryDirectoryPath}/dist/native-string-types.d.mts`);
+
+        expect(dMtsContent).toMatchSnapshot(".d.mts type code output");
+    });
 });

packages/packem/__tests__/unit/hooks/preset/utils/infer-entries.test.ts

@@ -363,6 +363,109 @@ describe("inferEntries", () => {
         } satisfies InferEntriesResult);
     });
 
+    it("should handle types only within exports`", () => {
+        expect.assertions(3);
+
+        createFiles(["src/test.d.ts"], temporaryDirectoryPath);
+
+        const result = inferEntries(
+            {
+                exports: {
+                    import: {
+                        types: "dist/test.d.mts",
+                    },
+                    require: {
+                        types: "dist/test.d.cts",
+                    },
+                },
+            },
+            ["src/", "src/test.d.ts"].map((file) => join(temporaryDirectoryPath, file)),
+            {
+                environment: defaultContext.environment,
+                options: { ...defaultContext.options, declaration: true },
+                pkg: defaultContext.pkg,
+            } as unknown as BuildContext,
+        );
+        expect(result).toStrictEqual({
+            entries: [
+                {
+                    cjs: true,
+                    declaration: true,
+                    environment: "development",
+                    esm: true,
+                    exportKey: new Set<string>(["import", "require"]),
+                    input: join(temporaryDirectoryPath, "src/test.d.ts"),
+                    runtime: "node",
+                },
+            ],
+            warnings: [],
+        } satisfies InferEntriesResult);
+
+        const result2 = inferEntries(
+            {
+                exports: {
+                    "./test": {
+                        import: {
+                            types: "dist/test.d.mts",
+                        },
+                        require: {
+                            types: "dist/test.d.cts",
+                        },
+                    },
+                },
+            },
+            ["src/", "src/test.d.ts"].map((file) => join(temporaryDirectoryPath, file)),
+            {
+                environment: defaultContext.environment,
+                options: { ...defaultContext.options, declaration: true },
+                pkg: defaultContext.pkg,
+            } as unknown as BuildContext,
+        );
+        expect(result2).toStrictEqual({
+            entries: [
+                {
+                    cjs: true,
+                    declaration: true,
+                    environment: "development",
+                    esm: true,
+                    exportKey: new Set<string>(["test"]),
+                    input: join(temporaryDirectoryPath, "src/test.d.ts"),
+                    runtime: "node",
+                },
+            ],
+            warnings: [],
+        } satisfies InferEntriesResult);
+
+        const result3 = inferEntries(
+            {
+                exports: {
+                    "./test": {
+                        types: "dist/test.d.ts",
+                    },
+                },
+            },
+            ["src/", "src/test.d.ts"].map((file) => join(temporaryDirectoryPath, file)),
+            {
+                environment: defaultContext.environment,
+                options: { ...defaultContext.options, declaration: true },
+                pkg: defaultContext.pkg,
+            } as unknown as BuildContext,
+        );
+        expect(result3).toStrictEqual({
+            entries: [
+                {
+                    cjs: true,
+                    declaration: true,
+                    environment: "development",
+                    exportKey: new Set<string>(["test"]),
+                    input: join(temporaryDirectoryPath, "src/test.d.ts"),
+                    runtime: "node",
+                },
+            ],
+            warnings: [],
+        } satisfies InferEntriesResult);
+    });
+
     it("should gracefully handles unknown entries", () => {
         expect.assertions(1);
 

packages/packem/src/config/preset/utils/infer-entries.ts

@@ -210,7 +210,7 @@ const inferEntries = (
         const sourceSlug = outputSlug.replace(new RegExp("(./)?" + context.options.outDir), context.options.sourceDir).replace("./", "");
 
         const beforeSourceRegex = "(?<=/|$)";
-        const fileExtensionRegex = isDirectory ? "" : "(\\.[cm]?[tj]sx?)$";
+        const fileExtensionRegex = isDirectory ? "" : "(\\.d\\.[cm]?ts|(\\.[cm]?[tj]sx?))$";
 
         // @see https://nodejs.org/docs/latest-v16.x/api/packages.html#subpath-patterns
         if (output.file.includes("/*") && output.key === "exports") {

packages/packem/src/packem/build.ts

@@ -330,9 +330,12 @@ const prepareRollupConfig = (
             const esmEntries: BuildEntry[] = [];
             const cjsEntries: BuildEntry[] = [];
             const dtsEntries: BuildEntry[] = [];
+            const dtsOnlyEntries: BuildEntry[] = [];
 
             for (const entry of entries) {
-                if (entry.cjs && entry.esm) {
+                if (/\.d\.[cm]?ts$/.test(entry.input)) {
+                    dtsOnlyEntries.push(entry);
+                } else if (entry.cjs && entry.esm) {
                     esmAndCjsEntries.push(entry);
                 } else if (entry.cjs) {
                     cjsEntries.push(entry);
@@ -512,6 +515,33 @@ const prepareRollupConfig = (
                     subDirectory,
                 });
             }
+
+            if (environmentRuntimeContext.options.declaration && dtsOnlyEntries.length > 0) {
+                typeBuilders.add({
+                    context: {
+                        ...environmentRuntimeContext,
+                        options: {
+                            ...environmentRuntimeContext.options,
+                            entries: dtsOnlyEntries,
+                            minify,
+                            rollup: {
+                                ...environmentRuntimeContext.options.rollup,
+                                replace: environmentRuntimeContext.options.rollup.replace
+                                    ? {
+                                          ...environmentRuntimeContext.options.rollup.replace,
+                                          values: {
+                                              ...environmentRuntimeContext.options.rollup.replace.values,
+                                              ...replaceValues,
+                                          },
+                                      }
+                                    : false,
+                            },
+                        },
+                    },
+                    fileCache,
+                    subDirectory,
+                });
+            }
         }
     }