@bunup/dts 0.14.51 → 0.14.53

package/dist/index.js

@@ -1,15 +1,10 @@
 // src/generate.ts
 import { rm } from "node:fs/promises";
 import path3 from "node:path";
+import { parse as parse3 } from "@babel/parser";
 import { isolatedDeclaration } from "oxc-transform";
 import { resolveTsImportPath } from "ts-import-resolver";
 
-// src/constants.ts
-var EMPTY_EXPORT = "export {};";
-
-// src/fake/dts-to-fake-js.ts
-import { parse } from "@babel/parser";
-
 // src/re.ts
 var IMPORT_TYPE_RE = /import\s+type\s+/g;
 var EXPORT_TYPE_RE = /export\s+type\s+/g;
@@ -148,6 +143,31 @@ function getAllImportNames(body) {
   }
   return importNames;
 }
+function getNamespaceImports(body) {
+  const result = [];
+  for (const statement of body) {
+    if (isImportDeclaration(statement)) {
+      const importDecl = statement;
+      if (importDecl.specifiers) {
+        for (const specifier of importDecl.specifiers) {
+          if (specifier.type === "ImportNamespaceSpecifier") {
+            result.push({
+              alias: specifier.local.name,
+              specifier: importDecl.source.value
+            });
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// src/constants.ts
+var EMPTY_EXPORT = "export {};";
+
+// src/fake/dts-to-fake-js.ts
+import { parse } from "@babel/parser";
 
 // src/utils.ts
 import { existsSync } from "node:fs";
@@ -377,7 +397,14 @@ async function dtsToFakeJs(dtsContent) {
   const referencedNames = new Set;
   const exportedNames = new Set;
   const staticImportedVars = new Set;
+  const namespaceMembers = new Map;
   const result = [];
+  const exportAssignmentNames = new Set;
+  for (const stmt of parsed.program.body) {
+    if (stmt.type === "TSExportAssignment" && stmt.expression.type === "Identifier") {
+      exportAssignmentNames.add(stmt.expression.name);
+    }
+  }
   for (const name of getAllImportNames(parsed.program.body)) {
     referencedNames.add(name);
   }
@@ -413,11 +440,54 @@ async function dtsToFakeJs(dtsContent) {
     if (statement.type === "TSExportAssignment") {
       if (statement.expression.type === "Identifier") {
         result.push(`export { ${statement.expression.name} as default }`);
+        const members = namespaceMembers.get(statement.expression.name);
+        if (members) {
+          for (const member of members) {
+            if (!exportedNames.has(member)) {
+              result.push(`export { ${member} };`);
+              exportedNames.add(member);
+            }
+          }
+        }
       } else if (statement.expression.start && statement.expression.end) {
         result.push(`export default ${dtsContent.substring(statement.expression.start, statement.expression.end)}`);
       }
       continue;
     }
+    if (statement.type === "TSModuleDeclaration" && statement.body?.type === "TSModuleBlock" && statement.id?.type === "Identifier") {
+      const memberNames = [];
+      const shouldExportMembers = hasExportModifier(statement, statementText) || exportAssignmentNames.has(name ?? "");
+      for (const member of statement.body.body) {
+        if (isNullOrUndefined(member.start) || isNullOrUndefined(member.end)) {
+          continue;
+        }
+        const memberText = dtsContent.substring(member.start, member.end);
+        const memberName = getName(member, dtsContent);
+        if (!memberName)
+          continue;
+        memberNames.push(memberName);
+        referencedNames.add(memberName);
+        const leadingComment2 = getCommentText(member.leadingComments);
+        let memberTextWithComments = `${leadingComment2 ? `${leadingComment2}
+` : ""}${memberText}`;
+        if (hasExportModifier(member, memberText)) {
+          memberTextWithComments = removeExportSyntaxes(memberTextWithComments);
+        }
+        const { tokens: tokens2, extras: extras2 } = tokenizeText(memberTextWithComments, referencedNames, staticImportedVars);
+        for (const extra of extras2) {
+          result.push(extra);
+        }
+        result.push(`var ${memberName} = [${tokens2.join(", ")}];`);
+        if (shouldExportMembers && !exportedNames.has(memberName)) {
+          result.push(`export { ${memberName} };`);
+          exportedNames.add(memberName);
+        }
+      }
+      if (name) {
+        namespaceMembers.set(name, memberNames);
+      }
+      continue;
+    }
     let leadingComment = null;
     leadingComment = getCommentText(statement.leadingComments);
     let statementTextWithCommentsAttached = `${leadingComment ? `${leadingComment}
@@ -478,7 +548,7 @@ function tokenizeText(text, referencedNames, staticImportedVars) {
 }
 // src/fake/fake-js-to-dts.ts
 import { parse as parse2 } from "@babel/parser";
-async function fakeJsToDts(fakeJsContent) {
+async function fakeJsToDts(fakeJsContent, namespaceAliasMap) {
   const parseResult = parse2(fakeJsContent, {
     sourceType: "module",
     attachComment: false
@@ -491,15 +561,18 @@ async function fakeJsToDts(fakeJsContent) {
     }
     const statementText = fakeJsContent.substring(statement.start, statement.end);
     if (isImportDeclaration(statement) || isExportAllDeclaration(statement) || isReExportStatement(statement)) {
-      if (isImportDeclaration(statement)) {
-        resultParts.push(statementText.replace(/\.(mjs|cjs|js)\b/g, ""));
-        continue;
+      if (namespaceAliasMap?.size && isReExportStatement(statement)) {
+        const fixedText = fixExportSpecifiers(statement, namespaceAliasMap);
+        if (fixedText) {
+          resultParts.push(fixedText);
+          continue;
+        }
       }
       resultParts.push(statementText);
       continue;
     }
     if (statement.type === "ExpressionStatement") {
-      const namespaceDecl = handleNamespace(statement);
+      const namespaceDecl = handleNamespace(statement, namespaceAliasMap);
       if (namespaceDecl) {
         resultParts.push(namespaceDecl);
         continue;
@@ -520,7 +593,7 @@ async function fakeJsToDts(fakeJsContent) {
           }
         }
         if (declaration.init?.type === "ArrayExpression") {
-          const dtsContent = processTokenArray(declaration.init);
+          const dtsContent = processTokenArray(declaration.init, namespaceAliasMap);
           if (dtsContent) {
             resultParts.push(dtsContent);
           }
@@ -569,7 +642,7 @@ function convertCallExpressionToString(node) {
   }).filter(Boolean).join(", ");
   return `${callee}(${args})`;
 }
-function processTokenArray(arrayLiteral) {
+function processTokenArray(arrayLiteral, namespaceAliasMap) {
   if (arrayLiteral.type !== "ArrayExpression") {
     return null;
   }
@@ -577,19 +650,19 @@ function processTokenArray(arrayLiteral) {
   for (const element of arrayLiteral.elements) {
     if (!element)
       continue;
-    const processed = processTokenElement(element);
+    const processed = processTokenElement(element, namespaceAliasMap);
     if (processed !== null) {
       tokens.push(processed);
     }
   }
   return tokens.join("");
 }
-function processTokenElement(element) {
+function processTokenElement(element, namespaceAliasMap) {
   if (element.type === "StringLiteral" && typeof element.value === "string") {
     return unescapeNewlinesAndTabs(element.value);
   }
   if (element.type === "Identifier") {
-    return element.name;
+    return namespaceAliasMap?.get(element.name) ?? element.name;
   }
   if (element.type === "TemplateLiteral") {
     const parts = [];
@@ -597,7 +670,7 @@ function processTokenElement(element) {
     for (let i = 0;i < element.expressions.length; i++) {
       const expr = element.expressions[i];
       if (expr?.type === "Identifier") {
-        parts.push(expr.name);
+        parts.push(namespaceAliasMap?.get(expr.name) ?? expr.name);
       }
       parts.push(unescapeNewlinesAndTabs(element.quasis[i + 1]?.value?.raw || ""));
     }
@@ -605,12 +678,13 @@ function processTokenElement(element) {
   }
   return null;
 }
-function handleNamespace(stmt) {
+function handleNamespace(stmt, namespaceAliasMap) {
   const expr = stmt.expression;
   if (!expr || expr.type !== "CallExpression" || expr.callee?.type !== "Identifier" || expr.arguments?.length !== 2 || expr.arguments[0]?.type !== "Identifier" || expr.arguments[1]?.type !== "ObjectExpression") {
     return null;
   }
-  const namespaceName = expr.arguments[0].name;
+  const rawName = expr.arguments[0].name;
+  const namespaceName = namespaceAliasMap?.get(rawName) ?? rawName;
   const properties = expr.arguments[1].properties.filter((prop) => prop.type === "ObjectProperty").map((prop) => {
     if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.value.type === "ArrowFunctionExpression" && prop.value.body.type === "Identifier") {
       const keyName = prop.key.name;
@@ -626,6 +700,35 @@ function handleNamespace(stmt) {
   export { ${properties.join(", ")} };
 }`;
 }
+function fixExportSpecifiers(statement, namespaceAliasMap) {
+  if (statement.type !== "ExportNamedDeclaration") {
+    return null;
+  }
+  const specifiers = statement.specifiers;
+  if (!specifiers?.length) {
+    return null;
+  }
+  let hasChange = false;
+  const fixedParts = [];
+  for (const spec of specifiers) {
+    if (spec.type !== "ExportSpecifier") {
+      return null;
+    }
+    const localName = spec.local.name;
+    const exportedName = spec.exported.type === "Identifier" ? spec.exported.name : spec.exported.value;
+    const alias = namespaceAliasMap.get(localName);
+    if (alias) {
+      hasChange = true;
+      fixedParts.push(alias === exportedName ? exportedName : `${alias} as ${exportedName}`);
+    } else {
+      fixedParts.push(localName === exportedName ? localName : `${localName} as ${exportedName}`);
+    }
+  }
+  if (!hasChange) {
+    return null;
+  }
+  return `export { ${fixedParts.join(", ")} };`;
+}
 // src/resolver.ts
 import { dirname } from "node:path";
 import process2 from "node:process";
@@ -750,6 +853,7 @@ async function generateDts(entrypoints, options = {}) {
     tsconfig: tsconfig.filepath
   });
   let tsCompiledDist;
+  const namespaceAliasMap = new Map;
   try {
     const fakeJsPlugin = {
       name: "fake-js",
@@ -808,6 +912,28 @@ async function generateDts(entrypoints, options = {}) {
             }
           }
           if (declaration) {
+            if (!NODE_MODULES_RE.test(args.path)) {
+              try {
+                const parsed = parse3(declaration, {
+                  sourceType: "module",
+                  plugins: ["typescript"]
+                });
+                const nsImports = getNamespaceImports(parsed.program.body);
+                for (const nsImport of nsImports) {
+                  const resolved = resolveTsImportPath({
+                    importer: args.path,
+                    path: nsImport.specifier,
+                    cwd,
+                    tsconfig: tsconfig.config
+                  });
+                  if (resolved) {
+                    const stem = path3.basename(resolved).replace(/\.[^.]+$/, "");
+                    const mangledName = `exports_${stem}`;
+                    namespaceAliasMap.set(mangledName, nsImport.alias);
+                  }
+                }
+              } catch {}
+            }
             fakeJsContent = await dtsToFakeJs(declaration);
           } else {
             fakeJsContent = EMPTY_EXPORT;
@@ -872,7 +998,7 @@ Ensure all your entrypoints match these patterns, or add them explicitly.
     const bundledFiles = [];
     for (const output of outputs) {
       const bundledFakeJsContent = await output.text();
-      const dtsContent = await fakeJsToDts(bundledFakeJsContent);
+      const dtsContent = await fakeJsToDts(bundledFakeJsContent, namespaceAliasMap);
       const entrypoint = output.kind === "entry-point" ? cleanPath(getOriginalEntrypointFromOutputPath(result.metafile, output.path, cwd)) : undefined;
       const chunkFileName = output.kind === "chunk" ? replaceExtension(path3.basename(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))) : undefined;
       const outputPath = cleanPath(replaceExtension(cleanPath(output.path), getDeclarationExtensionFromJsExtension(getExtension(output.path))));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bunup/dts",
-	"version": "0.14.51",
+	"version": "0.14.53",
 	"description": "An extremely fast TypeScript declaration bundler built on Bun's native bundler.",
 	"homepage": "https://github.com/bunup/dts#readme",
 	"bugs": {