dtsroll 1.7.2 → 1.7.4

package/dist/cli.mjs

@@ -1,6 +1,6 @@
 #!/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-DaiC_aHH.mjs';
+import { b as bgYellow, a as black, d as dtsroll, l as logOutput, D as DtsrollBuildError } from './index-DJ_g9wqZ.mjs';
 import 'node:path';
 import 'node:fs/promises';
 import 'rollup';
@@ -13,7 +13,7 @@ import 'resolve-pkg-maps';
 import 'byte-size';
 
 var name = "dtsroll";
-var version = "1.7.2";
+var version = "1.7.4";
 var description = "Bundle dts files";
 
 const argv = cli({

package/dist/{index-DaiC_aHH.mjs → index-DJ_g9wqZ.mjs}

@@ -2217,7 +2217,8 @@ function resolveDefaultOptions(options) {
     ...options,
     compilerOptions: options.compilerOptions ?? {},
     respectExternal: options.respectExternal ?? false,
-    includeExternal: options.includeExternal ?? []
+    includeExternal: options.includeExternal ?? [],
+    sourcemap: options.sourcemap ?? false
   };
 }
 const DTS_EXTENSIONS = /\.d\.(c|m)?tsx?$/;
@@ -2270,8 +2271,15 @@ function cacheConfig([fromPath, toPath], config) {
     configByPath.set(fromPath, config);
   }
 }
-function getCompilerOptions(input, overrideOptions, overrideConfigPath) {
-  const compilerOptions = { ...DEFAULT_OPTIONS, ...overrideOptions };
+function getCompilerOptions(input, overrideOptions, overrideConfigPath, enableDeclarationMap) {
+  const compilerOptions = {
+    ...DEFAULT_OPTIONS,
+    ...overrideOptions,
+    // When plugin's sourcemap option is explicitly true, force declarationMap
+    // regardless of user's compilerOptions setting.
+    // When sourcemap is false/undefined, respect user's compilerOptions.declarationMap.
+    ...enableDeclarationMap === true && { declarationMap: true }
+  };
   let dirName = path.dirname(input);
   let dtsFiles = [];
   const cacheKey = overrideConfigPath || dirName;
@@ -2313,11 +2321,11 @@ function getCompilerOptions(input, overrideOptions, overrideConfigPath) {
     }
   };
 }
-function createProgram$1(fileName, overrideOptions, tsconfig) {
-  const { dtsFiles, compilerOptions } = getCompilerOptions(fileName, overrideOptions, tsconfig);
+function createProgram$1(fileName, overrideOptions, tsconfig, enableDeclarationMap) {
+  const { dtsFiles, compilerOptions } = getCompilerOptions(fileName, overrideOptions, tsconfig, enableDeclarationMap);
   return ts.createProgram([fileName].concat(Array.from(dtsFiles)), compilerOptions, ts.createCompilerHost(compilerOptions, true));
 }
-function createPrograms(input, overrideOptions, tsconfig) {
+function createPrograms(input, overrideOptions, tsconfig, enableDeclarationMap) {
   const programs = [];
   const dtsFiles = /* @__PURE__ */ new Set();
   let inputs = [];
@@ -2328,7 +2336,7 @@ function createPrograms(input, overrideOptions, tsconfig) {
       continue;
     }
     main = path.resolve(main);
-    const options = getCompilerOptions(main, overrideOptions, tsconfig);
+    const options = getCompilerOptions(main, overrideOptions, tsconfig, enableDeclarationMap);
     options.dtsFiles.forEach(dtsFiles.add, dtsFiles);
     if (!inputs.length) {
       inputs.push(main);
@@ -3937,8 +3945,8 @@ function hydrateSourcemap(sparseMappings, inputMap, outputCode) {
       hydratedMappings.push([]);
       continue;
     }
-    const anchor = sparseSegments[0];
-    if (!anchor || anchor.length < 4) {
+    const anchor = sparseSegments.find((segment) => segment.length >= 4);
+    if (!anchor) {
       hydratedMappings.push(sparseSegments);
       continue;
     }
@@ -3975,7 +3983,14 @@ function hydrateSourcemap(sparseMappings, inputMap, outputCode) {
   return encode(hydratedMappings);
 }
 async function loadInputSourcemap(info) {
-  const { fileName, originalCode } = info;
+  const { fileName, originalCode, inputMapText } = info;
+  if (inputMapText) {
+    try {
+      return JSON.parse(inputMapText);
+    } catch {
+      return null;
+    }
+  }
   const inlineConverter = convert$1.fromSource(originalCode);
   if (inlineConverter) {
     return inlineConverter.toObject();
@@ -3999,7 +4014,7 @@ async function loadInputSourcemap(info) {
     return null;
   }
 }
-const transform = () => {
+const transform = (enableSourcemap) => {
   const allTypeReferences = /* @__PURE__ */ new Map();
   const allFileReferences = /* @__PURE__ */ new Map();
   const pendingSourcemaps = /* @__PURE__ */ new Map();
@@ -4044,7 +4059,7 @@ const transform = () => {
         strict: false
       };
     },
-    transform(code, fileName) {
+    transform(code, fileName, inputMapText) {
       const name = trimExtension(fileName);
       const moduleIds = this.getModuleIds();
       const moduleId = Array.from(moduleIds).find((id) => trimExtension(id) === name);
@@ -4063,10 +4078,11 @@ const transform = () => {
         console.log(JSON.stringify(converted.ast.body, void 0, 2));
       }
       const map = preprocessed.code.generateMap({ hires: true, source: fileName });
-      if (DTS_EXTENSIONS.test(fileName)) {
+      if (enableSourcemap && DTS_EXTENSIONS.test(fileName)) {
         pendingSourcemaps.set(fileName, {
           fileName,
-          originalCode: code
+          originalCode: code,
+          inputMapText
         });
       }
       return { code, ast: converted.ast, map };
@@ -4114,13 +4130,34 @@ const transform = () => {
         fileName,
         inputMap: await loadInputSourcemap(info)
       })));
+      const isUrl = (p) => /^[a-z][a-z0-9+.-]*:\/\//i.test(p);
       for (const { fileName, inputMap } of loadedMaps) {
         if (inputMap && inputMap.sources) {
           const inputMapDir = path.dirname(fileName);
+          let sourceRoot;
+          if (inputMap.sourceRoot) {
+            sourceRoot = isUrl(inputMap.sourceRoot) ? inputMap.sourceRoot : path.resolve(inputMapDir, inputMap.sourceRoot);
+          } else {
+            sourceRoot = inputMapDir;
+          }
+          const sourceRootIsUrl = isUrl(sourceRoot);
           inputSourcemaps.set(fileName, {
             version: inputMap.version ?? 3,
-            sources: inputMap.sources.map((source) => path.isAbsolute(source) ? source : path.resolve(inputMapDir, source)),
-            sourcesContent: inputMap.sourcesContent,
+            sources: inputMap.sources.map((source) => {
+              if (source === null)
+                return null;
+              if (isUrl(source))
+                return source;
+              if (sourceRootIsUrl) {
+                const base = sourceRoot.endsWith("/") ? sourceRoot : sourceRoot + "/";
+                return new URL(source, base).toString();
+              }
+              return path.isAbsolute(source) ? source : path.resolve(sourceRoot, source);
+            }),
+            // Note: sourcesContent intentionally not copied.
+            // TypeScript's declaration maps never include sourcesContent, and tsserver's
+            // getDocumentPositionMapper() rejects maps that have it (returns identity mapper).
+            // https://github.com/microsoft/TypeScript/blob/b19a9da2a3b8f2a720d314d01258dd2bdc110fef/src/services/sourcemaps.ts#L226
             mappings: inputMap.mappings,
             names: inputMap.names
           });
@@ -4132,70 +4169,78 @@ const transform = () => {
           continue;
         const chunkDir = path.join(outputDir, path.dirname(chunk.fileName));
         const toRelativeSourcePath = (source) => {
+          if (isUrl(source))
+            return source;
           const relative = path.isAbsolute(source) ? path.relative(chunkDir, source) : source;
           return relative.replaceAll("\\", "/");
         };
+        const toRelativeSourcePathOrNull = (source) => source === null ? null : toRelativeSourcePath(source);
         const sourcesToRemap = /* @__PURE__ */ new Map();
         for (const source of chunk.map.sources) {
           if (!source)
             continue;
+          if (isUrl(source))
+            continue;
           const absoluteSource = path.resolve(chunkDir, source);
-          const inputMap = inputSourcemaps.get(absoluteSource);
+          let inputMap = inputSourcemaps.get(absoluteSource);
+          if (!inputMap && /\.[cm]?[tj]sx?$/.test(absoluteSource) && !absoluteSource.endsWith(".d.ts")) {
+            const dtsPath = absoluteSource.replace(/\.[cm]?[tj]sx?$/, ".d.ts");
+            inputMap = inputSourcemaps.get(dtsPath);
+          }
           if (inputMap) {
             sourcesToRemap.set(absoluteSource, inputMap);
           }
         }
         if (sourcesToRemap.size === 0) {
+          delete chunk.map.sourcesContent;
           if (chunk.map.sources.length === 0 && chunk.facadeModuleId) {
             const inputMap = inputSourcemaps.get(chunk.facadeModuleId);
             if (inputMap && inputMap.sources.length > 0) {
-              const newSources2 = inputMap.sources.map(toRelativeSourcePath);
-              const newSourcesContent2 = inputMap.sourcesContent || [];
+              const newSources2 = inputMap.sources.map(toRelativeSourcePathOrNull);
               chunk.map.sources = newSources2;
-              chunk.map.sourcesContent = newSourcesContent2;
-              updateSourcemapAsset(bundle, chunk.fileName, {
-                sources: newSources2,
-                sourcesContent: newSourcesContent2,
-                mappings: chunk.map.mappings,
-                names: chunk.map.names || []
-              });
             }
           }
+          updateSourcemapAsset(bundle, chunk.fileName, {
+            sources: chunk.map.sources.map(toRelativeSourcePathOrNull),
+            mappings: chunk.map.mappings,
+            names: chunk.map.names || []
+          });
           continue;
         }
         const isSingleSource = chunk.map.sources.length === 1 && sourcesToRemap.size === 1;
         const singleInputMap = isSingleSource ? Array.from(sourcesToRemap.values())[0] : null;
         const canSimplyReplace = singleInputMap && singleInputMap.sources.length === 1;
         let newSources;
-        let newSourcesContent;
         let newMappings;
         let newNames;
         if (canSimplyReplace && singleInputMap) {
-          newSources = singleInputMap.sources.map(toRelativeSourcePath);
-          newSourcesContent = singleInputMap.sourcesContent || [null];
+          newSources = singleInputMap.sources.map(toRelativeSourcePathOrNull);
           newMappings = hydrateSourcemap(chunk.map.mappings, singleInputMap, chunk.code);
           newNames = singleInputMap.names || [];
         } else {
+          const visitedFiles = /* @__PURE__ */ new Set();
           const remapped = remapping(chunk.map, (file) => {
             const absolutePath = path.resolve(chunkDir, file);
+            if (visitedFiles.has(absolutePath)) {
+              return null;
+            }
+            visitedFiles.add(absolutePath);
             const inputMap = sourcesToRemap.get(absolutePath);
             if (inputMap) {
               return inputMap;
             }
             return null;
           });
-          newSources = remapped.sources.filter((s) => s !== null).map(toRelativeSourcePath);
-          newSourcesContent = remapped.sourcesContent || [];
+          newSources = remapped.sources.map(toRelativeSourcePathOrNull);
           newMappings = typeof remapped.mappings === "string" ? remapped.mappings : "";
           newNames = remapped.names || [];
         }
         chunk.map.sources = newSources;
-        chunk.map.sourcesContent = newSourcesContent;
+        delete chunk.map.sourcesContent;
         chunk.map.mappings = newMappings;
         chunk.map.names = newNames;
         updateSourcemapAsset(bundle, chunk.fileName, {
           sources: newSources,
-          sourcesContent: newSourcesContent,
           mappings: newMappings,
           names: newNames
         });
@@ -4253,7 +4298,7 @@ function getModule({ entries, programs, resolvedOptions }, fileName, code) {
         return { code };
       }
     }
-    const newProgram = createProgram$1(fileName, compilerOptions, tsconfig);
+    const newProgram = createProgram$1(fileName, compilerOptions, tsconfig, resolvedOptions.sourcemap);
     programs.push(newProgram);
     const source = newProgram.getSourceFile(fileName);
     return {
@@ -4266,8 +4311,8 @@ function getModule({ entries, programs, resolvedOptions }, fileName, code) {
   }
 }
 const plugin = (options = {}) => {
-  const transformPlugin = transform();
   const ctx = { entries: [], programs: [], resolvedOptions: resolveDefaultOptions(options) };
+  const transformPlugin = transform(ctx.resolvedOptions.sourcemap);
   return {
     name: "dts",
     // pass outputOptions, renderChunk, and generateBundle hooks to the inner transform plugin
@@ -4290,7 +4335,7 @@ const plugin = (options = {}) => {
           options2.input[name] = filename;
         }
       }
-      ctx.programs = createPrograms(Object.values(input), ctx.resolvedOptions.compilerOptions, ctx.resolvedOptions.tsconfig);
+      ctx.programs = createPrograms(Object.values(input), ctx.resolvedOptions.compilerOptions, ctx.resolvedOptions.tsconfig, ctx.resolvedOptions.sourcemap);
       return transformPlugin.options.call(this, options2);
     },
     transform(code, id) {
@@ -4327,11 +4372,16 @@ const plugin = (options = {}) => {
           return null;
         watchFiles(module);
         const declarationId = getDeclarationId(id);
-        let generated;
+        let declarationText;
+        let declarationMapText;
         const { emitSkipped, diagnostics } = module.program.emit(
           module.source,
-          (_, declarationText) => {
-            generated = transformPlugin.transform.call(this, declarationText, declarationId);
+          (emitFileName, text) => {
+            if (emitFileName.endsWith(".map")) {
+              declarationMapText = text;
+            } else {
+              declarationText = text;
+            }
           },
           void 0,
           // cancellationToken
@@ -4349,7 +4399,10 @@ const plugin = (options = {}) => {
             this.error("Failed to compile. Check the logs above.");
           }
         }
-        return generated;
+        if (!declarationText)
+          return null;
+        const cleanDeclarationText = declarationText.replace(/\n?\/\/# sourceMappingURL=[^\n]+/, "");
+        return transformPlugin.transform.call(this, cleanDeclarationText, declarationId, declarationMapText);
       };
       if (DTS_EXTENSIONS.test(id))
         return handleDtsFile();
@@ -4366,7 +4419,7 @@ const plugin = (options = {}) => {
       let resolvedCompilerOptions = ctx.resolvedOptions.compilerOptions;
       if (ctx.resolvedOptions.tsconfig) {
         const resolvedSource = source.startsWith(".") ? path.resolve(path.dirname(importer), source) : source;
-        resolvedCompilerOptions = getCompilerOptions(resolvedSource, ctx.resolvedOptions.compilerOptions, ctx.resolvedOptions.tsconfig).compilerOptions;
+        resolvedCompilerOptions = getCompilerOptions(resolvedSource, ctx.resolvedOptions.compilerOptions, ctx.resolvedOptions.tsconfig, ctx.resolvedOptions.sourcemap).compilerOptions;
       }
       const { resolvedModule } = ts.resolveModuleName(source, importer, resolvedCompilerOptions, ts.sys);
       if (!resolvedModule) {
@@ -4599,7 +4652,8 @@ const build = async (input, outputDirectory, externals, mode, conditions, source
         exportConditions: conditions
       }),
       plugin({
-        respectExternal: true
+        respectExternal: true,
+        sourcemap
         /**
          * Setting a tsconfig or compilerOptions shouldn't be necessary since
          * we're dealing with pre-compiled d.ts files

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import 'node:path';
-export { d as dtsroll } from './index-DaiC_aHH.mjs';
+export { d as dtsroll } from './index-DJ_g9wqZ.mjs';
 import 'node:fs/promises';
 import 'rollup';
 import 'typescript';

package/dist/vite.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as dtsroll, l as logOutput } from './index-DaiC_aHH.mjs';
+import { d as dtsroll, l as logOutput } from './index-DJ_g9wqZ.mjs';
 import 'node:path';
 import 'node:fs/promises';
 import 'rollup';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtsroll",
-  "version": "1.7.2",
+  "version": "1.7.4",
   "description": "Bundle dts files",
   "keywords": [
     "bundle",