dtsroll 1.8.0 → 1.8.1

package/README.md

@@ -177,11 +177,20 @@ export default defineConfig({
 ```ts
 import { dtsroll } from 'dtsroll'
 
-await dtsroll({
+const result = await dtsroll({
     cwd: process.cwd(),
     dryRun: false,
     sourcemap: true // generates .d.ts.map files
 })
+
+if ('error' in result) {
+    console.error(result.error)
+} else {
+    // Warnings about non-portable shared chunk types (TS2742)
+    for (const warning of result.warnings) {
+        console.warn(warning)
+    }
+}
 ```
 
 ## Related

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 } from './index-BsSgZDr9.mjs';
+import { b as bgYellow, a as black, d as dtsroll, l as logOutput } from './index-DPxVFBNC.mjs';
 import { patchErrorWithTrace } from 'rollup-plugin-import-trace';
 import 'node:path';
 import 'node:fs/promises';
@@ -14,7 +14,7 @@ import 'resolve-pkg-maps';
 import 'byte-size';
 
 var name = "dtsroll";
-var version = "1.8.0";
+var version = "1.8.1";
 var description = "Bundle dts files";
 
 const argv = cli({

package/dist/{index-BsSgZDr9.mjs → index-DPxVFBNC.mjs}

@@ -75,10 +75,10 @@ const bgYellow = kolorist(43, 49);
 const cwd = process.cwd();
 
 const isPath = (filePath) => filePath[0] === "." || path__default.isAbsolute(filePath);
-const normalizePath$1 = (filepath) => filepath.replaceAll("\\", "/");
+const normalizePath$2 = (filepath) => filepath.replaceAll("\\", "/");
 const getDisplayPath = (fullPath) => {
   const relativePath = path__default.relative(cwd, fullPath);
-  return normalizePath$1(
+  return normalizePath$2(
     relativePath.length < fullPath.length ? relativePath : fullPath
   );
 };
@@ -276,9 +276,9 @@ const getAllFiles = async (directoryPath, dontShortenPath) => {
       const filePath = path__default.join(directoryPath, entry.name);
       if (entry.isDirectory()) {
         const files = await getAllFiles(filePath, true);
-        return dontShortenPath ? files : files.map((file) => `./${normalizePath$1(path__default.relative(directoryPath, file))}`);
+        return dontShortenPath ? files : files.map((file) => `./${normalizePath$2(path__default.relative(directoryPath, file))}`);
       }
-      return dontShortenPath ? filePath : `./${normalizePath$1(path__default.relative(directoryPath, filePath))}`;
+      return dontShortenPath ? filePath : `./${normalizePath$2(path__default.relative(directoryPath, filePath))}`;
     })
   );
   return fileTree.flat();
@@ -652,14 +652,14 @@ function stripPathFilename(path) {
   return path.slice(0, index + 1);
 }
 function mergePaths(url, base) {
-  normalizePath(base, base.type);
+  normalizePath$1(base, base.type);
   if (url.path === "/") {
     url.path = base.path;
   } else {
     url.path = stripPathFilename(base.path) + url.path;
   }
 }
-function normalizePath(url, type) {
+function normalizePath$1(url, type) {
   const rel = type <= 4;
   const pieces = url.path.split("/");
   let pointer = 1;
@@ -726,7 +726,7 @@ function resolve(input, base) {
     if (baseType > inputType)
       inputType = baseType;
   }
-  normalizePath(url, inputType);
+  normalizePath$1(url, inputType);
   const queryHash = url.query + url.hash;
   switch (inputType) {
     // This is impossible, because of the empty checks at the start of the function.
@@ -2750,7 +2750,6 @@ class LanguageService {
 }
 class TypeOnlyFixer {
   constructor(fileName, rawCode) {
-    this.DEBUG = !!process.env.DTS_EXPORTS_FIXER_DEBUG;
     this.types = /* @__PURE__ */ new Set();
     this.values = /* @__PURE__ */ new Set();
     this.typeHints = /* @__PURE__ */ new Map();
@@ -2872,7 +2871,6 @@ ${getNodeIndent(node)}`));
   }
   analyze(nodes) {
     for (const node of nodes) {
-      this.DEBUG && console.log(node.getText(), node.kind);
       if (ts.isImportDeclaration(node) && node.importClause) {
         this.importNodes.push(node);
         continue;
@@ -2882,13 +2880,11 @@ ${getNodeIndent(node)}`));
         continue;
       }
       if (ts.isInterfaceDeclaration(node)) {
-        this.DEBUG && console.log(`${node.name.getFullText()} is a type`);
         this.types.add(node.name.text);
         continue;
       }
       if (ts.isTypeAliasDeclaration(node)) {
         const alias = node.name.text;
-        this.DEBUG && console.log(`${node.name.getFullText()} is a type`);
         this.types.add(alias);
         continue;
       }
@@ -2896,13 +2892,11 @@ ${getNodeIndent(node)}`));
         if (ts.isVariableStatement(node)) {
           for (const declaration of node.declarationList.declarations) {
             if (ts.isIdentifier(declaration.name)) {
-              this.DEBUG && console.log(`${declaration.name.getFullText()} is a value (from var statement)`);
               this.values.add(declaration.name.text);
             }
           }
         } else {
           if (node.name) {
-            this.DEBUG && console.log(`${node.name.getFullText()} is a value (from declaration)`);
             this.values.add(node.name.text);
           }
         }
@@ -2914,13 +2908,11 @@ ${getNodeIndent(node)}`));
       }
       if (ts.isModuleDeclaration(node)) {
         if (node.name && ts.isIdentifier(node.name)) {
-          this.DEBUG && console.log(`${node.name.getFullText()} is a value (from module declaration)`);
           this.values.add(node.name.text);
         }
         this.analyze(node.getChildren());
         continue;
       }
-      this.DEBUG && console.log("unhandled statement", node.getFullText(), node.kind);
     }
   }
   // The type-hint statements may lead to redundant import statements.
@@ -2944,6 +2936,85 @@ function getNodeIndent(node) {
   const match = node.getFullText().match(/^(?:\n*)([ ]*)/);
   return " ".repeat(match?.[1]?.length || 0);
 }
+const RESOLVED_MODULE_PREFIX = "dts-resolved:";
+const RESOLVED_MODULE_COMMENT = new RegExp(`\\/\\*${RESOLVED_MODULE_PREFIX}(.+?)\\*\\/`);
+function encodeResolvedModule(absolutePath) {
+  return `/*${RESOLVED_MODULE_PREFIX}${absolutePath}*/`;
+}
+function decodeResolvedModule(text) {
+  return text.match(RESOLVED_MODULE_COMMENT)?.[1] ?? null;
+}
+function stripResolvedModuleComment(text) {
+  return text.replace(RESOLVED_MODULE_COMMENT, "");
+}
+function normalizePath(p) {
+  return p.split("\\").join("/");
+}
+class ModuleDeclarationFixer {
+  constructor(chunk, code, sourcemap, moduleToChunk, warn) {
+    this.code = code;
+    this.sourcemap = sourcemap;
+    this.source = parse(chunk.fileName, code.toString());
+    this.chunkFileName = chunk.fileName;
+    this.moduleToChunk = moduleToChunk;
+    this.warn = warn;
+  }
+  fix() {
+    let modified = false;
+    for (const node of this.source.statements) {
+      if (!ts.isModuleDeclaration(node) || !node.body || !ts.isModuleBlock(node.body)) {
+        continue;
+      }
+      const sourceText = this.source.getFullText();
+      const textBetween = sourceText.slice(node.name.getEnd(), node.body.getStart());
+      const absolutePath = decodeResolvedModule(textBetween);
+      if (!absolutePath) {
+        continue;
+      }
+      const targetChunkName = this.getTargetChunkName(absolutePath);
+      const quote = node.name.kind === ts.SyntaxKind.StringLiteral && "singleQuote" in node.name && node.name.singleQuote ? "'" : '"';
+      const cleanedBetween = stripResolvedModuleComment(textBetween);
+      this.code.overwrite(node.name.getStart(), node.body.getStart(), `${quote}${targetChunkName}${quote}${cleanedBetween}`);
+      modified = true;
+    }
+    return {
+      code: this.code.toString(),
+      map: modified && this.sourcemap ? this.code.generateMap() : null
+    };
+  }
+  /**
+   * Get the output chunk name for an absolute module path.
+   */
+  getTargetChunkName(absolutePath) {
+    const jsExtMatch = absolutePath.match(/\.[cm]?js$/);
+    const basePath = jsExtMatch ? absolutePath.slice(0, -jsExtMatch[0].length) : absolutePath;
+    const extensions = ["", ".d.ts", ".d.mts", ".d.cts", ".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+    const possiblePaths = extensions.map((ext) => basePath + ext);
+    for (const possiblePath of possiblePaths) {
+      const chunkFileName = this.moduleToChunk.get(normalizePath(possiblePath));
+      if (chunkFileName) {
+        return this.formatChunkReference(chunkFileName, jsExtMatch?.[0]);
+      }
+    }
+    this.warn(`declare module "${absolutePath}" could not be resolved to any output chunk, falling back to current chunk "${this.chunkFileName}"`);
+    return this.formatChunkReference(this.chunkFileName, jsExtMatch?.[0]);
+  }
+  /**
+   * Format a chunk filename as a relative path from the current chunk.
+   */
+  formatChunkReference(chunkFileName, jsExt) {
+    const chunkDir = path.dirname(this.chunkFileName);
+    let relativePath = normalizePath(path.relative(chunkDir, chunkFileName));
+    relativePath = relativePath.replace(/\.d\.[cm]?tsx?$/, "");
+    if (jsExt) {
+      relativePath += jsExt;
+    }
+    if (!relativePath.startsWith(".")) {
+      relativePath = "./" + relativePath;
+    }
+    return relativePath;
+  }
+}
 function preProcessNamespaceBody(body, code, sourceFile) {
   if (ts.isModuleDeclaration(body)) {
     if (body.body && (ts.isModuleBlock(body.body) || ts.isModuleDeclaration(body.body))) {
@@ -3146,6 +3217,13 @@ declare const ${defaultExport}: {`,
     }
     code.remove(start, end);
   }
+  const sourceDir = path.dirname(sourceFile.fileName);
+  for (const node of sourceFile.statements) {
+    if (ts.isModuleDeclaration(node) && node.body && ts.isModuleBlock(node.body) && ts.isStringLiteral(node.name) && /^\.\.?\//.test(node.name.text)) {
+      const resolvedPath = path.resolve(sourceDir, node.name.text);
+      code.appendRight(node.name.getEnd(), encodeResolvedModule(resolvedPath));
+    }
+  }
   const fullText = sourceFile.getFullText();
   const eofTrivia = ts.getLeadingCommentRanges(fullText, sourceFile.endOfFileToken.getFullStart());
   const lastStatement = sourceFile.statements[sourceFile.statements.length - 1];
@@ -3154,7 +3232,7 @@ declare const ${defaultExport}: {`,
     if (comment.kind !== ts.SyntaxKind.SingleLineCommentTrivia)
       continue;
     const text = fullText.slice(comment.pos, comment.end);
-    if (!/\/\/[#@]\s*sourceMappingURL=/.test(text))
+    if (!/^\/\/[#@]\s*sourceMappingURL=/.test(text))
       continue;
     let start = comment.pos;
     if (start > 0 && fullText[start - 1] === "\n") {
@@ -3928,40 +4006,6 @@ class Transformer {
     };
   }
 }
-class RelativeModuleDeclarationFixer {
-  constructor(fileName, code, sourcemap, name) {
-    this.sourcemap = sourcemap;
-    this.DEBUG = !!process.env.DTS_EXPORTS_FIXER_DEBUG;
-    this.relativeModuleDeclarations = [];
-    this.source = parse(fileName, code.toString());
-    this.code = code;
-    this.name = name || "./index";
-  }
-  fix() {
-    this.analyze(this.source.statements);
-    for (const node of this.relativeModuleDeclarations) {
-      const start = node.getStart();
-      const end = node.getEnd();
-      const quote = node.name.kind === ts.SyntaxKind.StringLiteral && "singleQuote" in node.name && node.name.singleQuote ? "'" : '"';
-      const code = `declare module ${quote}${this.name}${quote} ${node.body.getText()}`;
-      this.code.overwrite(start, end, code);
-    }
-    return {
-      code: this.code.toString(),
-      map: this.relativeModuleDeclarations.length && this.sourcemap ? this.code.generateMap() : null
-    };
-  }
-  analyze(nodes) {
-    for (const node of nodes) {
-      if (ts.isModuleDeclaration(node) && node.body && ts.isModuleBlock(node.body) && /^\.\.?\//.test(node.name.text)) {
-        if (this.DEBUG) {
-          console.log(`Found relative module declaration: ${node.name.text} in ${this.source.fileName}`);
-        }
-        this.relativeModuleDeclarations.push(node);
-      }
-    }
-  }
-}
 function hydrateSourcemap(sparseMappings, inputMap, outputCode) {
   const sparseDecoded = decode(sparseMappings);
   const inputDecoded = decode(inputMap.mappings);
@@ -4042,6 +4086,281 @@ async function loadInputSourcemap(info) {
     return null;
   }
 }
+function rewritePortableSharedChunkImportsInBundle(bundle, warn) {
+  const chunks = Object.values(bundle).filter(isOutputChunk);
+  const sharedChunks = chunks.filter((chunk) => !chunk.isEntry);
+  if (sharedChunks.length === 0)
+    return;
+  const entryChunks = chunks.filter((chunk) => chunk.isEntry);
+  const chunkGraph = new Map(chunks.map((chunk) => [
+    chunk.fileName,
+    {
+      exports: chunk.exports,
+      isEntry: chunk.isEntry
+    }
+  ]));
+  const analyses = new Map(chunks.map((chunk) => [chunk.fileName, analyzeChunk(chunk, chunkGraph)]));
+  for (const chunk of entryChunks) {
+    const analysis = analyses.get(chunk.fileName);
+    const magicCode = new MagicString(chunk.code);
+    let hasChanges = false;
+    const unresolvedSymbols = /* @__PURE__ */ new Set();
+    for (const statement of analysis.importStatements) {
+      const sharedChunk = sharedChunks.find((candidate) => getChunkImportSpecifier(chunk.fileName, candidate.fileName) === statement.moduleSpecifier);
+      if (!sharedChunk) {
+        continue;
+      }
+      const keptSpecifiers = [];
+      const rewrittenSpecifiers = /* @__PURE__ */ new Map();
+      for (const specifier of statement.specifiers) {
+        if (hasPublicHostRoute(analysis, statement.moduleSpecifier, specifier.importedName)) {
+          keptSpecifiers.push(specifier);
+          continue;
+        }
+        const hostCandidate = pickHostCandidate(entryChunks, analyses, chunk.fileName, sharedChunk.fileName, specifier);
+        if (!hostCandidate) {
+          keptSpecifiers.push(specifier);
+          unresolvedSymbols.add(specifier.localName);
+          continue;
+        }
+        const hostSpecifier = getChunkImportSpecifier(chunk.fileName, hostCandidate.chunk.fileName);
+        const hostImportSpecifiers = rewrittenSpecifiers.get(hostSpecifier) || [];
+        hostImportSpecifiers.push({
+          importedName: hostCandidate.exportedName,
+          isTypeOnly: specifier.isTypeOnly || hostCandidate.isTypeOnly,
+          localName: specifier.localName
+        });
+        rewrittenSpecifiers.set(hostSpecifier, hostImportSpecifiers);
+      }
+      if (!rewrittenSpecifiers.size) {
+        continue;
+      }
+      const replacementStatements = [];
+      if (keptSpecifiers.length) {
+        replacementStatements.push(buildImportStatement(statement, keptSpecifiers, statement.moduleSpecifier, statement.quote));
+      }
+      const hostSpecifiers = Array.from(rewrittenSpecifiers.keys()).sort(compareStrings);
+      for (const hostSpecifier of hostSpecifiers) {
+        replacementStatements.push(buildImportStatement(statement, rewrittenSpecifiers.get(hostSpecifier), hostSpecifier, statement.quote));
+      }
+      magicCode.overwrite(statement.statement.getStart(), statement.statement.getEnd(), replacementStatements.join("\n"));
+      hasChanges = true;
+    }
+    if (hasChanges) {
+      applyChunkEdits(chunk, magicCode);
+    }
+    if (unresolvedSymbols.size) {
+      warn(formatUnresolvedSharedTypeWarning(chunk.fileName, unresolvedSymbols));
+    }
+  }
+}
+function analyzeChunk(chunk, chunkGraph) {
+  const source = parse(chunk.fileName, chunk.code);
+  const importStatements = [];
+  const importedBindings = /* @__PURE__ */ new Map();
+  const hostRoutesByModule = /* @__PURE__ */ new Map();
+  const starExports = [];
+  for (const statement of source.statements) {
+    if (ts.isImportDeclaration(statement) && !statement.importClause?.name && ts.isStringLiteral(statement.moduleSpecifier) && statement.importClause?.namedBindings && ts.isNamedImports(statement.importClause.namedBindings)) {
+      const moduleSpecifier = statement.moduleSpecifier.text;
+      const quote = statement.moduleSpecifier.getText(source).startsWith('"') ? '"' : "'";
+      const specifiers = statement.importClause.namedBindings.elements.map((element) => {
+        const specifier = {
+          importedName: element.propertyName?.text || element.name.text,
+          isTypeOnly: element.isTypeOnly || statement.importClause?.isTypeOnly || false,
+          localName: element.name.text
+        };
+        importedBindings.set(specifier.localName, {
+          importedName: specifier.importedName,
+          isTypeOnly: specifier.isTypeOnly,
+          moduleSpecifier
+        });
+        return specifier;
+      });
+      importStatements.push({
+        isTypeOnly: statement.importClause.isTypeOnly,
+        moduleSpecifier,
+        quote,
+        specifiers,
+        statement
+      });
+      continue;
+    }
+    if (!ts.isExportDeclaration(statement) || !statement.moduleSpecifier || !ts.isStringLiteral(statement.moduleSpecifier)) {
+      continue;
+    }
+    if (!statement.exportClause) {
+      starExports.push(statement.moduleSpecifier.text);
+      continue;
+    }
+    if (!ts.isNamedExports(statement.exportClause)) {
+      continue;
+    }
+    for (const element of statement.exportClause.elements) {
+      addHostExportRoute(hostRoutesByModule, statement.moduleSpecifier.text, element.propertyName?.text || element.name.text, {
+        exportedName: element.name.text,
+        isTypeOnly: statement.isTypeOnly || element.isTypeOnly
+      });
+    }
+  }
+  for (const statement of source.statements) {
+    if (!ts.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+      continue;
+    }
+    for (const element of statement.exportClause.elements) {
+      const localName = element.propertyName?.text || element.name.text;
+      const binding = importedBindings.get(localName);
+      if (!binding) {
+        continue;
+      }
+      addHostExportRoute(hostRoutesByModule, binding.moduleSpecifier, binding.importedName, {
+        exportedName: element.name.text,
+        isTypeOnly: binding.isTypeOnly || statement.isTypeOnly || element.isTypeOnly
+      });
+    }
+  }
+  for (const moduleSpecifier of starExports) {
+    const sharedChunk = Array.from(chunkGraph.entries()).find(([candidateFileName, candidate]) => !candidate.isEntry && getChunkImportSpecifier(chunk.fileName, candidateFileName) === moduleSpecifier);
+    if (!sharedChunk) {
+      continue;
+    }
+    for (const exportedName of sharedChunk[1].exports) {
+      if (exportedName === "default") {
+        continue;
+      }
+      addHostExportRoute(hostRoutesByModule, moduleSpecifier, exportedName, {
+        exportedName,
+        isTypeOnly: false
+      });
+    }
+  }
+  return {
+    hostRoutesByModule,
+    importStatements
+  };
+}
+const isOutputChunk = (chunk) => chunk.type === "chunk";
+function pickHostCandidate(entryChunks, analyses, currentChunkFileName, sharedChunkFileName, specifier) {
+  const candidates = [];
+  for (const hostChunk of entryChunks) {
+    if (hostChunk.fileName === currentChunkFileName) {
+      continue;
+    }
+    const hostAnalysis = analyses.get(hostChunk.fileName);
+    const sharedSpecifier = getChunkImportSpecifier(hostChunk.fileName, sharedChunkFileName);
+    const routes = getHostExportRoutes(hostAnalysis, sharedSpecifier, specifier.importedName);
+    for (const route of routes) {
+      candidates.push({
+        ...route,
+        chunk: hostChunk
+      });
+    }
+  }
+  candidates.sort((left, right) => {
+    const leftMatchesLocal = left.exportedName === specifier.localName ? 0 : 1;
+    const rightMatchesLocal = right.exportedName === specifier.localName ? 0 : 1;
+    if (leftMatchesLocal !== rightMatchesLocal) {
+      return leftMatchesLocal - rightMatchesLocal;
+    }
+    const fileNameOrder = compareStrings(left.chunk.fileName, right.chunk.fileName);
+    if (fileNameOrder !== 0) {
+      return fileNameOrder;
+    }
+    return compareStrings(left.exportedName, right.exportedName);
+  });
+  return candidates[0];
+}
+const getHostExportRoutes = (analysis, moduleSpecifier, importedName) => analysis.hostRoutesByModule.get(moduleSpecifier)?.get(importedName) || [];
+const hasPublicHostRoute = (analysis, moduleSpecifier, importedName) => getHostExportRoutes(analysis, moduleSpecifier, importedName).length > 0;
+const compareStrings = (left, right) => {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+};
+function addHostExportRoute(hostRoutesByModule, moduleSpecifier, importedName, route) {
+  const routesByImportedName = hostRoutesByModule.get(moduleSpecifier) || /* @__PURE__ */ new Map();
+  const routes = routesByImportedName.get(importedName) || [];
+  if (!routes.some((existing) => existing.exportedName === route.exportedName && existing.isTypeOnly === route.isTypeOnly)) {
+    routes.push(route);
+  }
+  routesByImportedName.set(importedName, routes);
+  hostRoutesByModule.set(moduleSpecifier, routesByImportedName);
+}
+function buildImportStatement(statement, specifiers, moduleSpecifier, quote) {
+  const useTypeOnlyImport = statement.isTypeOnly || specifiers.every((specifier) => specifier.isTypeOnly);
+  const importKeyword = useTypeOnlyImport ? "import type" : "import";
+  const namedImports = specifiers.map((specifier) => {
+    const prefix = !useTypeOnlyImport && specifier.isTypeOnly ? "type " : "";
+    if (specifier.importedName === specifier.localName) {
+      return `${prefix}${specifier.importedName}`;
+    }
+    return `${prefix}${specifier.importedName} as ${specifier.localName}`;
+  }).join(", ");
+  return `${importKeyword} { ${namedImports} } from ${quote}${moduleSpecifier}${quote};`;
+}
+function applyChunkEdits(chunk, code) {
+  const nextCode = code.toString();
+  if (nextCode === chunk.code) {
+    return;
+  }
+  if (chunk.map) {
+    const chunkFileName = normalizeChunkPath(chunk.fileName);
+    const rewriteMap = code.generateMap({
+      file: chunkFileName,
+      hires: true,
+      includeContent: true,
+      source: chunkFileName
+    });
+    const remapped = remapping(rewriteMap, (file) => {
+      if (normalizeChunkPath(file) === chunkFileName) {
+        return chunk.map;
+      }
+      return null;
+    });
+    chunk.map = {
+      ...chunk.map,
+      mappings: typeof remapped.mappings === "string" ? remapped.mappings : "",
+      names: remapped.names || [],
+      sources: remapped.sources
+    };
+    delete chunk.map.sourcesContent;
+  }
+  chunk.code = nextCode;
+}
+const formatUnresolvedSharedTypeWarning = (chunkFileName, symbols) => {
+  const symbolList = Array.from(symbols).sort().join(", ");
+  return [
+    `Entry "${chunkFileName}" still references private shared type exports with no public re-export: ${symbolList}.`,
+    "rollup-plugin-dts will not invent new public exports for these types.",
+    "Re-export them from a public entry to avoid downstream TS2742 errors."
+  ].join(" ");
+};
+const getChunkImportSpecifier = (fromChunkFileName, toChunkFileName) => {
+  const fromDir = path.posix.dirname(normalizeChunkPath(fromChunkFileName));
+  const toRuntimeFileName = getChunkRuntimeFileName(normalizeChunkPath(toChunkFileName));
+  let relativePath = path.posix.relative(fromDir, toRuntimeFileName);
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+};
+const getChunkRuntimeFileName = (fileName) => {
+  if (fileName.endsWith(".d.mts")) {
+    return `${fileName.slice(0, -6)}.mjs`;
+  }
+  if (fileName.endsWith(".d.cts")) {
+    return `${fileName.slice(0, -6)}.cjs`;
+  }
+  if (fileName.endsWith(".d.ts")) {
+    return `${fileName.slice(0, -5)}.js`;
+  }
+  return `${fileName}.js`;
+};
+const normalizeChunkPath = (fileName) => fileName.replaceAll("\\", "/");
 const transform = (enableSourcemap) => {
   const allTypeReferences = /* @__PURE__ */ new Map();
   const allFileReferences = /* @__PURE__ */ new Map();
@@ -4087,12 +4406,13 @@ const transform = (enableSourcemap) => {
         strict: false
       };
     },
-    transform(code, fileName, inputMapText) {
+    transform(code, fileName, inputMapTextOrOptions) {
       const name = trimExtension(fileName);
       const moduleIds = this.getModuleIds();
       const moduleId = Array.from(moduleIds).find((id) => trimExtension(id) === name);
       const isEntry = Boolean(moduleId && this.getModuleInfo(moduleId)?.isEntry);
       const isJSON = Boolean(moduleId && JSON_EXTENSIONS.test(moduleId));
+      const inputMapText = typeof inputMapTextOrOptions === "string" ? inputMapTextOrOptions : void 0;
       const rawCode = code;
       let sourceFile = parse(fileName, code);
       const preprocessed = preProcess({ sourceFile, isEntry, isJSON });
@@ -4107,7 +4427,7 @@ const transform = (enableSourcemap) => {
         console.log(JSON.stringify(converted.ast.body, void 0, 2));
       }
       if (!enableSourcemap) {
-        return { code, ast: converted.ast };
+        return { code, ast: converted.ast, map: null };
       }
       const map = preprocessed.code.generateMap({ hires: true, source: fileName });
       if (DTS_EXTENSIONS.test(fileName)) {
@@ -4119,7 +4439,7 @@ const transform = (enableSourcemap) => {
       }
       return { code, ast: converted.ast, map };
     },
-    renderChunk(inputCode, chunk, options) {
+    renderChunk(inputCode, chunk, options, meta) {
       const source = parse(chunk.fileName, inputCode);
       const fixer = new NamespaceFixer(source);
       const typeReferences = /* @__PURE__ */ new Set();
@@ -4150,10 +4470,17 @@ const transform = (enableSourcemap) => {
       }
       const typeOnlyFixer = new TypeOnlyFixer(chunk.fileName, code);
       const typesFixed = typeOnlyFixer.fix();
-      const relativeModuleDeclarationFixed = new RelativeModuleDeclarationFixer(chunk.fileName, "magicCode" in typesFixed && typesFixed.magicCode ? typesFixed.magicCode : new MagicString(code), !!options.sourcemap, "./" + path.basename(chunk.fileName, ".d.ts"));
-      return relativeModuleDeclarationFixed.fix();
+      const moduleToChunk = /* @__PURE__ */ new Map();
+      for (const [chunkFileName, chunkInfo] of Object.entries(meta.chunks)) {
+        for (const moduleId of Object.keys(chunkInfo.modules)) {
+          moduleToChunk.set(moduleId.split("\\").join("/"), chunkFileName);
+        }
+      }
+      const moduleDeclarationFixer = new ModuleDeclarationFixer(chunk, "magicCode" in typesFixed && typesFixed.magicCode ? typesFixed.magicCode : new MagicString(code), !!options.sourcemap, moduleToChunk, (message) => this.warn(message));
+      return moduleDeclarationFixer.fix();
     },
     async generateBundle(options, bundle) {
+      rewritePortableSharedChunkImportsInBundle(bundle, (message) => this.warn(message));
       if (!options.sourcemap)
         return;
       const inputSourcemaps = /* @__PURE__ */ new Map();
@@ -4454,6 +4781,9 @@ const plugin = (options = {}) => {
         resolvedCompilerOptions = getCompilerOptions(resolvedSource, ctx.resolvedOptions.compilerOptions, ctx.resolvedOptions.tsconfig, ctx.resolvedOptions.sourcemap).compilerOptions;
       }
       const { resolvedModule } = ts.resolveModuleName(source, importer, {
+        // Default moduleResolution to node10 if not explicitly set. TS6 changed
+        // the default from node10 to bundler, and bundler resolution picks .js
+        // files over directories with .d.ts index files, breaking .d.ts bundling.
         moduleResolution: ts.ModuleResolutionKind.Node10,
         ...resolvedCompilerOptions
       }, ts.sys);
@@ -4635,6 +4965,7 @@ const build = async (input, outputDirectory, externals, mode, conditions, source
     getPackageEntryPoint
   } = createExternalizePlugin(externals);
   const sizeRef = {};
+  const warnings = [];
   const rollupConfig = {
     input: createInputMap(input, outputDirectory),
     output: {
@@ -4643,6 +4974,9 @@ const build = async (input, outputDirectory, externals, mode, conditions, source
       entryFileNames: "[name]",
       chunkFileNames: "_dtsroll-chunks/[hash]-[name].ts"
     },
+    onwarn(warning) {
+      warnings.push(String(warning.message || warning));
+    },
     plugins: [
       importTrace(),
       externalizePlugin,
@@ -4665,7 +4999,8 @@ const build = async (input, outputDirectory, externals, mode, conditions, source
     built,
     externalized,
     getPackageEntryPoint,
-    sourceSize: sizeRef.value ?? 0
+    sourceSize: sizeRef.value ?? 0,
+    warnings
   };
 };
 
@@ -4704,7 +5039,8 @@ const dtsroll = async ({
     built,
     externalized,
     getPackageEntryPoint,
-    sourceSize
+    sourceSize,
+    warnings
   } = await build(
     inputFiles,
     outputDirectory,
@@ -4759,7 +5095,8 @@ const dtsroll = async ({
       input: sourceSize,
       output: outputSize
     },
-    externals: externalPackages
+    externals: externalPackages,
+    warnings
   };
 };
 

package/dist/index.d.ts

@@ -46,6 +46,8 @@ type DtsrollOutput = {
         output: number;
     };
     externals: Externals;
+    /** Warnings emitted during the build (e.g. non-portable shared chunk types). */
+    warnings: string[];
 };
 
 /**

package/dist/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import 'node:path';
-export { d as dtsroll } from './index-BsSgZDr9.mjs';
+export { d as dtsroll } from './index-DPxVFBNC.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-BsSgZDr9.mjs';
+import { d as dtsroll, l as logOutput } from './index-DPxVFBNC.mjs';
 import 'node:path';
 import 'node:fs/promises';
 import 'rollup';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dtsroll",
-  "version": "1.8.0",
+  "version": "1.8.1",
   "description": "Bundle dts files",
   "keywords": [
     "bundle",
@@ -31,8 +31,6 @@
     }
   },
   "imports": {
-    "#dtsroll": "./src/index.ts",
-    "#dtsroll/vite": "./src/vite.ts",
     "typescript": {
       "typescript4": "typescript4",
       "typescript5": "typescript5",
@@ -46,11 +44,11 @@
   "dependencies": {
     "@rollup/plugin-node-resolve": "^16.0.3",
     "byte-size": "^9.0.1",
-    "cleye": "^2.2.1",
+    "cleye": "^2.3.0",
     "convert-source-map": "^2.0.0",
     "empathic": "^2.0.0",
     "resolve-pkg-maps": "^1.0.0",
-    "rollup": "^4.55.3",
+    "rollup": "^4.60.1",
     "rollup-plugin-import-trace": "^1.0.1"
   },
   "peerDependencies": {