@bunup/dts 0.14.43 → 0.14.45

package/dist/index.js

@@ -18,7 +18,7 @@ var IMPORT_EXPORT_WITH_DEFAULT_RE = /(import|export)(\s+[^{,]+,)?\s*{([^}]*)}/g;
 var TYPE_WORD_RE = /\btype\s+/g;
 var EXPORT_DEFAULT_RE = /\bexport\s+default\s+/g;
 var EXPORT_RE = /\bexport\s+/g;
-var TOKENIZE_RE = /(\s+|\/\/.*?(?:\n|$)|\/\*[\s\S]*?\*\/|[a-zA-Z_$][a-zA-Z0-9_$]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|[(){}[\],.;:]|=>|&&|\|\||[=!<>]=?|\+\+|--|[-+*/%&|^!~?]|\.{3}|::|\.)/g;
+var TOKENIZE_RE = /(\s+|\/\/.*?(?:\n|$)|\/\*[\s\S]*?\*\/|import\s*\((?:[^()]*|\([^()]*\))*\)(?:\.[a-zA-Z_$][a-zA-Z0-9_$]*|\[(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*')\])*|[a-zA-Z_$][a-zA-Z0-9_$]*|"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|`(?:\\.|[^`\\])*`|\d+(?:\.\d*)?(?:[eE][+-]?\d+)?|[(){}[\],.;:]|=>|&&|\|\||[=!<>]=?|\+\+|--|[-+*/%&|^!~?]|\.{3}|::|\.)/g;
 var CAPITAL_LETTER_RE = /[A-Z]/;
 var JS_RE = /\.[cm]?jsx?$/;
 var TS_RE = /\.[cm]?tsx?$|\.d\.[cm]?ts$/;
@@ -318,7 +318,10 @@ async function dtsToFakeJs(dtsContent) {
     if (isExported) {
       statementTextWithCommentsAttached = removeExportSyntaxes(statementTextWithCommentsAttached);
     }
-    const tokens = tokenizeText(statementTextWithCommentsAttached, referencedNames);
+    const { tokens, extras } = tokenizeText(statementTextWithCommentsAttached, referencedNames);
+    for (const extra of extras) {
+      result.push(extra);
+    }
     result.push(`var ${jsVarName} = [${tokens.join(", ")}];`);
     if (isExported && !isDefaultExport && !exportedNames.has(jsVarName)) {
       if (isDefaultExport) {
@@ -342,6 +345,7 @@ function jsifyImportExport(text) {
 }
 function tokenizeText(text, referencedNames) {
   const tokens = [];
+  const extras = [];
   let match;
   TOKENIZE_RE.lastIndex = 0;
   while (true) {
@@ -349,13 +353,102 @@ function tokenizeText(text, referencedNames) {
     if (match === null)
       break;
     const token = match[0];
-    if (isLikelyVariableOrTypeName(token) || referencedNames.has(token)) {
+    if (token.startsWith("import(")) {
+      const staticImport = convertDynamicImportToStatic(token);
+      extras.push(staticImport.declarations);
+      tokens.push(staticImport.variableName);
+    } else if (isLikelyVariableOrTypeName(token) || referencedNames.has(token)) {
       tokens.push(token);
     } else {
       tokens.push(JSON.stringify(escapeNewlinesAndTabs(token)));
     }
   }
-  return tokens;
+  return { tokens, extras };
+}
+function convertDynamicImportToStatic(dynamicImport) {
+  const importMatch = dynamicImport.match(/^import\s*\(\s*(['"`])(.+?)\1\s*\)((?:\.[a-zA-Z_$][a-zA-Z0-9_$]*|\[(['"`]).+?\4\])*)$/);
+  if (!importMatch) {
+    throw new Error("Invalid dynamic import format");
+  }
+  const modulePath = importMatch[2];
+  const propertyAccess = importMatch[3] || "";
+  if (!propertyAccess) {
+    const importIdentifier = `import_${generateRandomString()}`;
+    return {
+      declarations: `import * as ${importIdentifier} from '${modulePath}';`,
+      variableName: importIdentifier
+    };
+  }
+  const firstProperty = extractFirstProperty(propertyAccess);
+  const remainingAccess = propertyAccess.slice(firstProperty.accessLength);
+  if (firstProperty.isValidIdentifier) {
+    const uniqueName = `${createValidIdentifier(firstProperty.name)}_${generateRandomString()}`;
+    let declarations = `import { ${firstProperty.name} as ${uniqueName} } from '${modulePath}';`;
+    let finalVariable = uniqueName;
+    if (remainingAccess) {
+      const lastProperty = extractLastProperty(remainingAccess);
+      const varName = `${createValidIdentifier(lastProperty)}_${generateRandomString()}`;
+      declarations += `
+var ${varName} = ${uniqueName}${remainingAccess};`;
+      finalVariable = varName;
+    }
+    return {
+      declarations,
+      variableName: finalVariable
+    };
+  } else {
+    const importIdentifier = `import_${generateRandomString()}`;
+    const lastProperty = extractLastProperty(propertyAccess);
+    const varName = `${createValidIdentifier(lastProperty)}_${generateRandomString()}`;
+    const declarations = `import * as ${importIdentifier} from '${modulePath}';
+var ${varName} = ${importIdentifier}${propertyAccess};`;
+    return {
+      declarations,
+      variableName: varName
+    };
+  }
+}
+function extractFirstProperty(propertyAccess) {
+  const dotMatch = propertyAccess.match(/^\.([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+  if (dotMatch) {
+    return {
+      name: dotMatch[1],
+      accessLength: dotMatch[0].length,
+      isValidIdentifier: true
+    };
+  }
+  const bracketMatch = propertyAccess.match(/^\[(['"`])(.+?)\1\]/);
+  if (bracketMatch) {
+    const propName = bracketMatch[2];
+    const isValid = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(propName);
+    return {
+      name: propName,
+      accessLength: bracketMatch[0].length,
+      isValidIdentifier: isValid
+    };
+  }
+  throw new Error("Invalid property access");
+}
+function extractLastProperty(propertyAccess) {
+  const bracketMatch = propertyAccess.match(/\[(['"`])(.+?)\1\]$/);
+  if (bracketMatch) {
+    return bracketMatch[2];
+  }
+  const dotMatch = propertyAccess.match(/\.([a-zA-Z_$][a-zA-Z0-9_$]*)$/);
+  if (dotMatch) {
+    return dotMatch[1];
+  }
+  return "value";
+}
+function createValidIdentifier(name) {
+  let identifier = name.replace(/[^a-zA-Z0-9_$]/g, "_");
+  if (/^\d/.test(identifier)) {
+    identifier = `_${identifier}`;
+  }
+  if (!identifier) {
+    identifier = "_value";
+  }
+  return identifier;
 }
 // src/fake/fake-js-to-dts.ts
 import { parse as parse2 } from "@babel/parser";
@@ -388,6 +481,18 @@ async function fakeJsToDts(fakeJsContent) {
     }
     if (statement.type === "VariableDeclaration") {
       for (const declaration of statement.declarations) {
+        if (declaration.id.type === "Identifier") {
+          const init = declaration.init;
+          if (init?.type === "Identifier") {
+            resultParts.push(`type ${declaration.id.name} = ${init.name};`);
+          } else if (init?.type === "MemberExpression") {
+            const memberExpr = convertMemberExpressionToComputed(init);
+            resultParts.push(`type ${declaration.id.name} = ${memberExpr};`);
+          } else if (init?.type === "CallExpression") {
+            const callExpr = convertCallExpressionToString(init);
+            resultParts.push(`type ${declaration.id.name} = ${callExpr};`);
+          }
+        }
         if (declaration.init?.type === "ArrayExpression") {
           const dtsContent = processTokenArray(declaration.init);
           if (dtsContent) {
@@ -400,6 +505,44 @@ async function fakeJsToDts(fakeJsContent) {
   return resultParts.join(`
 `);
 }
+function convertMemberExpressionToComputed(node) {
+  let object = "";
+  if (node.object.type === "Identifier") {
+    object = node.object.name;
+  } else if (node.object.type === "MemberExpression") {
+    object = convertMemberExpressionToComputed(node.object);
+  }
+  let property = "";
+  if (node.property.type === "Identifier") {
+    property = `'${node.property.name}'`;
+  } else if (node.property.type === "StringLiteral") {
+    property = `'${node.property.value}'`;
+  } else if (node.property.type === "NumericLiteral") {
+    property = String(node.property.value);
+  }
+  return `${object}[${property}]`;
+}
+function convertCallExpressionToString(node) {
+  let callee = "";
+  if (node.callee.type === "Identifier") {
+    callee = node.callee.name;
+  } else if (node.callee.type === "MemberExpression") {
+    callee = convertMemberExpressionToComputed(node.callee);
+  }
+  const args = node.arguments.map((arg) => {
+    if (arg.type === "Identifier") {
+      return arg.name;
+    } else if (arg.type === "StringLiteral") {
+      return `'${arg.value}'`;
+    } else if (arg.type === "NumericLiteral") {
+      return String(arg.value);
+    } else if (arg.type === "MemberExpression") {
+      return convertMemberExpressionToComputed(arg);
+    }
+    return "";
+  }).filter(Boolean).join(", ");
+  return `${callee}(${args})`;
+}
 function processTokenArray(arrayLiteral) {
   if (arrayLiteral.type !== "ArrayExpression") {
     return null;
@@ -568,6 +711,10 @@ async function generateDts(entrypoints, options = {}) {
   if (!filterTypescriptFiles([...resolvedEntrypoints, ...absoluteEntrypoints]).length) {
     throw new Error("One or more of the entrypoints you provided do not exist. Please check that each entrypoint points to a valid file.");
   }
+  const finalEntryPoints = [
+    ...filterTypescriptFiles(resolvedEntrypoints).map((entry) => path2.resolve(path2.join(cwd, entry))),
+    ...filterTypescriptFiles(absoluteEntrypoints)
+  ];
   const collectedErrors = [];
   const resolver = createResolver({
     cwd,
@@ -645,10 +792,7 @@ async function generateDts(entrypoints, options = {}) {
       }
     };
     const result = await Bun.build({
-      entrypoints: [
-        ...filterTypescriptFiles(resolvedEntrypoints).map((entry) => path2.resolve(path2.join(cwd, entry))),
-        ...filterTypescriptFiles(absoluteEntrypoints)
-      ],
+      entrypoints: finalEntryPoints,
       format: "esm",
       target: "node",
       naming,
@@ -661,7 +805,39 @@ async function generateDts(entrypoints, options = {}) {
       tsconfig: options.preferredTsconfig ? path2.resolve(cwd, options.preferredTsconfig) : undefined
     });
     if (!result.success) {
-      throw new Error(`DTS bundling failed: ${result.logs}`);
+      const logsStr = `${result.logs}`;
+      if (logsStr.includes("ENOENT: no such file or directory, open") && logsStr.endsWith(".d.ts'")) {
+        let errorMsg = `One or more of your entrypoints are not included in your TypeScript configuration.
+
+`;
+        if (tsconfig.filepath) {
+          errorMsg += `Using: ${path2.relative(cwd, tsconfig.filepath)}
+
+`;
+        }
+        const currentInclude = tsconfig.config?.include;
+        if (currentInclude && Array.isArray(currentInclude) && currentInclude.length > 0) {
+          errorMsg += `Current "include" patterns:
+`;
+          for (const pattern of currentInclude) {
+            errorMsg += `  - "${pattern}"
+`;
+          }
+          errorMsg += `
+Ensure all your entrypoints match these patterns, or add them explicitly.
+`;
+        } else {
+          errorMsg += `Add an "include" field to your tsconfig.json:
+` + `  {
+` + `    "include": ["src/**/*"]
+` + `  }
+
+` + `Make sure the pattern matches all your entrypoint files.
+`;
+        }
+        throw new Error(errorMsg);
+      }
+      throw new Error(logsStr);
     }
     const outputs = result.outputs.filter((output) => output.kind === "chunk" || output.kind === "entry-point");
     const bundledFiles = [];
@@ -675,11 +851,6 @@ async function generateDts(entrypoints, options = {}) {
       if (!treeshakedDts.code.length && !treeshakedDts.errors.length) {
         continue;
       }
-      if (treeshakedDts.errors.length && !treeshakedDts.code) {
-        throw new Error(`DTS treeshaking failed for ${entrypoint || outputPath}
-
-${JSON.stringify(treeshakedDts.errors, null, 2)}`);
-      }
       bundledFiles.push({
         kind: output.kind === "entry-point" ? "entry-point" : "chunk",
         entrypoint,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@bunup/dts",
-	"version": "0.14.43",
+	"version": "0.14.45",
 	"description": "An extremely fast TypeScript declaration bundler built on Bun's native bundler.",
 	"homepage": "https://github.com/bunup/dts#readme",
 	"bugs": {
@@ -31,7 +31,6 @@
 		"lint": "biome check .",
 		"lint:fix": "biome check --write .",
 		"release": "bumpp --commit --push --tag",
-		"play": "bun run playground/play.ts",
 		"test": "bun test",
 		"test:coverage": "bun test --coverage",
 		"test:watch": "bun test --watch",