dtsroll 1.6.0 → 1.7.1

package/README.md

@@ -134,9 +134,24 @@ If no entry files are provided, _dtsroll_ reads `package.json` to determine them
 | Flag           | Alias | Description                                       |
 | -------------- | ----- | ------------------------------------------------- |
 | `--dry-run`    | `-d`  | Show what would be bundled without writing files  |
+| `--sourcemap`  | `-s`  | Generate source maps (`.d.ts.map` files)          |
 | `--conditions` | `-C`  | Resolution conditions for [subpath exports](https://nodejs.org/api/packages.html#subpath-exports) (e.g. `production`)         |
 | `--external`   | `-e`  | *(Only when no `package.json`)* Packages to externalize |
 
+#### Why use `--sourcemap`?
+
+Without source maps, "Go to Definition" in VS Code lands you in bundled `.d.ts` files—often a flattened wall of generated types that's hard to navigate.
+
+With `--sourcemap`, _dtsroll_ generates `.d.ts.map` files that map positions in the bundled output back to your original source files. This lets VS Code jump directly to the actual TypeScript implementation instead of the generated declarations.
+
+This is especially useful for:
+- **Monorepos** — Navigate seamlessly across packages to real source
+- **Library authors** — Give consumers a better DX when exploring your types
+- **Anyone debugging types** — Understand types at their origin, not the emitted output
+
+> [!NOTE]
+> For source navigation to work, the original `.ts` source files must be available (either shipped with your package or present locally). If they're not, VS Code falls back to the `.d.ts` file.
+
 ### Vite plugin
 
 If you use `vite-plugin-dts`, _dtsroll_ will automatically bundle the emitted types immediately after generation:
@@ -161,7 +176,8 @@ import { dtsroll } from 'dtsroll'
 
 await dtsroll({
     cwd: process.cwd(),
-    dryRun: false
+    dryRun: false,
+    sourcemap: true // generates .d.ts.map files
 })
 ```
 

package/dist/cli.mjs

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import { cli } from 'cleye';
-import { b as bgYellow, a as black, d as dtsroll, l as logOutput, D as DtsrollBuildError } from './index-Du7Kzot4.mjs';
+import { b as bgYellow, a as black, d as dtsroll, l as logOutput, D as DtsrollBuildError } from './index-D25w_e6R.mjs';
 import 'node:path';
 import 'node:fs/promises';
 import 'rollup';
 import 'rollup-plugin-dts';
 import '@rollup/plugin-node-resolve';
+import 'node:fs';
+import 'convert-source-map';
 import 'empathic/find';
 import 'resolve-pkg-maps';
 import 'byte-size';
 
 var name = "dtsroll";
-var version = "1.6.0";
+var version = "1.7.1";
 var description = "Bundle dts files";
 
 const argv = cli({

package/dist/{index-Du7Kzot4.mjs → index-D25w_e6R.mjs}

@@ -3,6 +3,8 @@ import fs from 'node:fs/promises';
 import { rollup } from 'rollup';
 import { dts } from 'rollup-plugin-dts';
 import nodeResolve from '@rollup/plugin-node-resolve';
+import fs$1 from 'node:fs';
+import convert from 'convert-source-map';
 import { up } from 'empathic/find';
 import { resolveImports } from 'resolve-pkg-maps';
 import byteSize from 'byte-size';
@@ -71,10 +73,10 @@ const bgYellow = kolorist(43, 49);
 const cwd = process.cwd();
 
 const isPath = (filePath) => filePath[0] === "." || path.isAbsolute(filePath);
-const normalizePath$1 = (filepath) => filepath.replaceAll("\\", "/");
+const normalizePath = (filepath) => filepath.replaceAll("\\", "/");
 const getDisplayPath = (fullPath) => {
   const relativePath = path.relative(cwd, fullPath);
-  return normalizePath$1(
+  return normalizePath(
     relativePath.length < fullPath.length ? relativePath : fullPath
   );
 };
@@ -276,7 +278,6 @@ const getPackageName = (id) => {
   return id.slice(0, indexOfSlash);
 };
 
-const normalizePath = (filePath) => filePath.replaceAll("\\", "/");
 const getAllFiles = async (directoryPath, dontShortenPath) => {
   const directoryFiles = await fs.readdir(directoryPath, { withFileTypes: true });
   const fileTree = await Promise.all(
@@ -514,6 +515,139 @@ const createImportChainPlugin = () => {
   };
 };
 
+const tryReadFile = async (filePath) => {
+  try {
+    return await fs$1.promises.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+};
+const loadSourceMap = async (codePath, code) => {
+  const adjacentMapPath = `${codePath}.map`;
+  const adjacentMapContent = await tryReadFile(adjacentMapPath);
+  if (adjacentMapContent) {
+    try {
+      const converter = convert.fromJSON(adjacentMapContent);
+      return {
+        map: converter.toObject(),
+        mapPath: adjacentMapPath
+      };
+    } catch {
+    }
+  }
+  try {
+    const inlineConverter = convert.fromSource(code);
+    if (inlineConverter) {
+      return {
+        map: inlineConverter.toObject(),
+        mapPath: codePath
+      };
+    }
+  } catch {
+  }
+  try {
+    const regex = new RegExp(convert.mapFileCommentRegex.source);
+    const commentMatch = regex.exec(code);
+    const referencedPath = commentMatch?.[1] ?? commentMatch?.[2];
+    if (!referencedPath) {
+      return;
+    }
+    const mapFilePath = path.join(path.dirname(codePath), referencedPath);
+    const mapContent = await tryReadFile(mapFilePath);
+    if (!mapContent) {
+      return;
+    }
+    const converter = convert.fromJSON(mapContent);
+    return {
+      map: converter.toObject(),
+      mapPath: mapFilePath
+    };
+  } catch {
+  }
+};
+const loadInputSourcemapsPlugin = () => {
+  const inputSourcemaps = /* @__PURE__ */ new Map();
+  return {
+    name: "load-input-sourcemaps",
+    async load(id) {
+      const isDts = dtsExtensions.some((extension) => id.endsWith(extension));
+      if (!isDts) {
+        return null;
+      }
+      const code = await tryReadFile(id);
+      if (!code) {
+        return null;
+      }
+      const result = await loadSourceMap(id, code);
+      if (!result) {
+        return { code };
+      }
+      const { map: inputMap, mapPath } = result;
+      const sourceRoot = path.resolve(path.dirname(mapPath), inputMap.sourceRoot ?? ".");
+      const sources = inputMap.sources.map(
+        (source) => path.isAbsolute(source) ? source : path.resolve(sourceRoot, source)
+      );
+      const sourcesContentRaw = await Promise.all(
+        sources.map(
+          async (source, index) => inputMap.sourcesContent?.[index] ?? tryReadFile(source)
+        )
+      );
+      const sourcesContent = sourcesContentRaw.filter(
+        (content) => content !== null
+      );
+      inputSourcemaps.set(id, {
+        sources,
+        sourcesContent
+      });
+      return {
+        code,
+        map: {
+          version: inputMap.version,
+          names: inputMap.names,
+          sources,
+          mappings: inputMap.mappings,
+          ...sourcesContent.length > 0 ? { sourcesContent } : {},
+          ...inputMap.file ? { file: inputMap.file } : {}
+        }
+      };
+    },
+    async writeBundle(options, bundle) {
+      const outputDir = options.dir ?? path.dirname(options.file ?? "");
+      if (!outputDir) {
+        return;
+      }
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type !== "chunk" || !chunk.map) {
+          continue;
+        }
+        if (chunk.map.sources.length > 0) {
+          continue;
+        }
+        const entryModule = chunk.facadeModuleId;
+        if (!entryModule) {
+          continue;
+        }
+        const inputSourcemap = inputSourcemaps.get(entryModule);
+        if (!inputSourcemap || inputSourcemap.sources.length === 0) {
+          continue;
+        }
+        const mapFileName = `${fileName}.map`;
+        const mapPath = path.join(outputDir, mapFileName);
+        const outputFileDir = path.dirname(path.join(outputDir, fileName));
+        const relativeSources = inputSourcemap.sources.map(
+          (source) => normalizePath(path.relative(outputFileDir, source))
+        );
+        const fixedMap = {
+          ...chunk.map,
+          sources: relativeSources,
+          sourcesContent: inputSourcemap.sourcesContent.length > 0 ? inputSourcemap.sourcesContent : void 0
+        };
+        await fs$1.promises.writeFile(mapPath, JSON.stringify(fixedMap));
+      }
+    }
+  };
+};
+
 const nodeModules = `${path.sep}node_modules${path.sep}`;
 const removeBundledModulesPlugin = (outputDirectory, sizeRef) => {
   let deleteFiles = [];
@@ -545,7 +679,11 @@ const removeBundledModulesPlugin = (outputDirectory, sizeRef) => {
     },
     writeBundle: async () => {
       await Promise.all(
-        deleteFiles.map((moduleId) => fs.rm(moduleId))
+        deleteFiles.flatMap((moduleId) => [
+          fs.rm(moduleId),
+          // Also delete orphaned sourcemap files
+          fs.rm(`${moduleId}.map`, { force: true })
+        ])
       );
     }
   };
@@ -630,6 +768,8 @@ const build = async (input, outputDirectory, externals, mode, conditions, source
       externalizePlugin,
       removeBundledModulesPlugin(outputDirectory, sizeRef),
       resolveSubpathImportsPlugin(),
+      // Load existing .d.ts.map files to chain sourcemaps back to original .ts sources
+      sourcemap && loadInputSourcemapsPlugin(),
       nodeResolve({
         extensions: [".ts", ...dtsExtensions],
         exportConditions: conditions

package/dist/index.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
 import 'node:path';
-export { d as dtsroll } from './index-Du7Kzot4.mjs';
+export { d as dtsroll } from './index-D25w_e6R.mjs';
 import 'node:fs/promises';
 import 'rollup';
 import 'rollup-plugin-dts';
 import '@rollup/plugin-node-resolve';
+import 'node:fs';
+import 'convert-source-map';
 import 'empathic/find';
 import 'resolve-pkg-maps';
 import 'byte-size';

package/dist/vite.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
-import { d as dtsroll, l as logOutput } from './index-Du7Kzot4.mjs';
+import { d as dtsroll, l as logOutput } from './index-D25w_e6R.mjs';
 import 'node:path';
 import 'node:fs/promises';
 import 'rollup';
 import 'rollup-plugin-dts';
 import '@rollup/plugin-node-resolve';
+import 'node:fs';
+import 'convert-source-map';
 import 'empathic/find';
 import 'resolve-pkg-maps';
 import 'byte-size';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtsroll",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "Bundle dts files",
   "keywords": [
     "bundle",
@@ -40,6 +40,7 @@
     "@rollup/plugin-node-resolve": "^16.0.3",
     "byte-size": "^9.0.1",
     "cleye": "^2.2.1",
+    "convert-source-map": "^2.0.0",
     "empathic": "^2.0.0",
     "resolve-pkg-maps": "^1.0.0",
     "rollup": "^4.55.1",