@c4a/extract-ts 0.5.38 → 0.5.39-beta.1

package/index.js

@@ -13497,8 +13497,21 @@ var TEXT_EXTENSIONS = collectExtensions((definition) => definition.cas.encoding
 var UPLOAD_MAX_FILE_SIZE = 5 * 1024 * 1024;
 // src/pathUtils.ts
 import { posix } from "node:path";
-var SOURCE_EXTENSIONS = [".ts", ".tsx"];
+var SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
 var BUILD_EXTENSIONS = [".js", ".jsx", ".mjs", ".cjs"];
+var DECLARATION_EXTENSIONS = [".d.ts", ".d.mts", ".d.cts"];
+var KNOWN_CODE_SUFFIXES = [
+  ...DECLARATION_EXTENSIONS,
+  ".esm.js",
+  ".cjs.js",
+  ".umd.js",
+  ".amd.js",
+  ".iife.js",
+  ".system.js",
+  ".min.js",
+  ...SOURCE_EXTENSIONS,
+  ...BUILD_EXTENSIONS
+];
 var BUILD_OUTPUT_ROOTS = new Set(["dist", "lib", "build", "output", "out"]);
 var BUILD_FORMAT_DIRS = new Set([
   "es",
@@ -13522,8 +13535,15 @@ var normalizeRelativePath = (value) => {
   const normalized = posix.normalize(value.replace(/\\/g, "/"));
   return normalized.replace(/^\.\//, "");
 };
+var stripResourceQuery = (value) => value.split(/[?#]/u)[0] ?? value;
+var hasUnsupportedExplicitExtension = (value) => {
+  const basename = posix.basename(value);
+  if (!basename.includes("."))
+    return false;
+  return !KNOWN_CODE_SUFFIXES.some((extension) => value.endsWith(extension));
+};
 var removeKnownExtension = (value) => {
-  for (const extension of [...SOURCE_EXTENSIONS, ...BUILD_EXTENSIONS]) {
+  for (const extension of KNOWN_CODE_SUFFIXES) {
     if (value.endsWith(extension)) {
       return value.slice(0, -extension.length);
     }
@@ -13547,14 +13567,14 @@ var buildToSourcePaths = (withoutExtension) => {
   results.push(`src/${fullRest}`);
   return unique(results);
 };
-var createCandidatePaths = (value) => {
-  const normalized = normalizeRelativePath(value);
+var createCandidatePaths = (value, options = {}) => {
+  const normalized = normalizeRelativePath(stripResourceQuery(value));
+  if (hasUnsupportedExplicitExtension(normalized))
+    return [];
   const withoutExtension = removeKnownExtension(normalized);
-  const bases = unique([
-    normalized,
-    withoutExtension,
-    ...buildToSourcePaths(withoutExtension)
-  ]);
+  const mappedSourcePaths = buildToSourcePaths(withoutExtension);
+  const directFirst = SOURCE_EXTENSIONS.some((extension) => normalized.endsWith(extension));
+  const bases = directFirst ? unique([normalized, withoutExtension, ...mappedSourcePaths]) : unique([...mappedSourcePaths, normalized, withoutExtension]);
   const candidates = new Set;
   for (const base of bases) {
     if (SOURCE_EXTENSIONS.some((ext) => base.endsWith(ext))) {
@@ -13564,19 +13584,22 @@ var createCandidatePaths = (value) => {
       candidates.add(`${base}${extension}`);
       candidates.add(posix.join(base, `index${extension}`));
     }
-    if (normalized.endsWith(".js")) {
-      candidates.add(normalized.slice(0, -3) + ".ts");
-      candidates.add(normalized.slice(0, -3) + ".tsx");
+    if (BUILD_EXTENSIONS.some((extension) => normalized.endsWith(extension))) {
+      for (const extension of SOURCE_EXTENSIONS) {
+        candidates.add(removeKnownExtension(normalized) + extension);
+      }
     }
   }
-  for (const extension of SOURCE_EXTENSIONS) {
-    candidates.add(`src/index${extension}`);
+  if (options.allowIndexFallback ?? true) {
+    for (const extension of SOURCE_EXTENSIONS) {
+      candidates.add(`src/index${extension}`);
+    }
   }
   return [...candidates].map(normalizeRelativePath);
 };
 var isRelativeModuleSpecifier = (value) => value.startsWith("./") || value.startsWith("../");
-var resolveEntrySourcePath = async (packageDir, targetPath, fs2) => {
-  for (const candidate of createCandidatePaths(targetPath)) {
+var resolveEntrySourcePath = async (packageDir, targetPath, fs2, options = {}) => {
+  for (const candidate of createCandidatePaths(targetPath, options)) {
     const fullPath = packageDir ? posix.join(packageDir, candidate) : candidate;
     if (await fs2.exists(fullPath)) {
       return fullPath;
@@ -13598,40 +13621,58 @@ var resolveImportSourcePath = async (fromFile, specifier, fs2) => {
 };
 
 // src/entryDetector.ts
+var CONDITION_PRIORITY = [
+  "types",
+  "typings",
+  "import",
+  "require",
+  "module",
+  "browser",
+  "node",
+  "default",
+  "main"
+];
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
 var asStringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 var readString = (value) => typeof value === "string" && value.trim() ? value : null;
-var resolveConditionalTarget = (value, mainFallback) => {
+var unique2 = (items) => [...new Set(items)];
+var resolveConditionalTargets = (value, mainFallback) => {
   const direct = readString(value);
   if (direct)
-    return direct;
+    return [direct];
+  if (Array.isArray(value)) {
+    return unique2(value.flatMap((item) => resolveConditionalTargets(item, null)));
+  }
   const record = asRecord(value);
-  for (const key of ["import", "default", "main"]) {
-    const candidate = readString(record[key]);
-    if (candidate)
-      return candidate;
+  const targets = [];
+  for (const key of CONDITION_PRIORITY) {
+    if (!(key in record))
+      continue;
+    targets.push(...resolveConditionalTargets(record[key], null));
   }
-  return mainFallback;
+  if (mainFallback)
+    targets.push(mainFallback);
+  return unique2(targets);
 };
 var collectExportTargets = (pkg) => {
   const exportsField = pkg.exports;
   const mainFallback = readString(pkg.main);
   if (!exportsField) {
-    return mainFallback ? [{ subpath: ".", targetPath: mainFallback, type: "library" }] : [];
+    return mainFallback ? [{ subpath: ".", targetPaths: [mainFallback], type: "library" }] : [];
   }
   const exportsRecord = asRecord(exportsField);
   const exportKeys = Object.keys(exportsRecord);
   const hasSubpathMap = exportKeys.some((key) => key.startsWith("."));
-  const direct = !hasSubpathMap ? resolveConditionalTarget(exportsField, mainFallback) : null;
-  if (direct) {
-    return [{ subpath: ".", targetPath: direct, type: "library" }];
+  const direct = !hasSubpathMap ? resolveConditionalTargets(exportsField, mainFallback) : [];
+  if (direct.length > 0) {
+    return [{ subpath: ".", targetPaths: direct, type: "library" }];
   }
   const targets = [];
   for (const [subpath, rawValue] of Object.entries(exportsRecord)) {
-    const targetPath = resolveConditionalTarget(rawValue, mainFallback);
-    if (!targetPath)
+    const targetPaths = resolveConditionalTargets(rawValue, null);
+    if (targetPaths.length === 0)
       continue;
-    targets.push({ subpath, targetPath, type: "library" });
+    targets.push({ subpath, targetPaths, type: "library" });
   }
   return targets;
 };
@@ -13639,11 +13680,11 @@ var collectBinTargets = (pkg) => {
   const binField = pkg.bin;
   const direct = readString(binField);
   if (direct) {
-    return [{ subpath: "./bin", targetPath: direct, type: "cli" }];
+    return [{ subpath: "./bin", targetPaths: [direct], type: "cli" }];
   }
   return Object.entries(asRecord(binField)).flatMap(([name, value]) => {
     const targetPath = readString(value);
-    return targetPath ? [{ subpath: `./bin/${name}`, targetPath, type: "cli" }] : [];
+    return targetPath ? [{ subpath: `./bin/${name}`, targetPaths: [targetPath], type: "cli" }] : [];
   });
 };
 var detectPackageKind = (pkg) => {
@@ -13667,7 +13708,11 @@ var expandWorkspacePattern = async (rootDir, pattern, fs2) => {
   return [`${rootDir}/${pattern}`.replace(/^\.\//, "")];
 };
 var detectSubPackages = async (rootDir, pkg, fs2) => {
-  const workspaces = asStringArray(pkg.workspaces);
+  const workspaceConfig = asRecord(pkg.workspaces);
+  const workspaces = [
+    ...asStringArray(pkg.workspaces),
+    ...asStringArray(workspaceConfig.packages)
+  ];
   if (workspaces.length === 0)
     return;
   const subPackages = [];
@@ -13697,14 +13742,18 @@ var detectEntries = async (manifest, fs2) => {
   const entryTargets = [...collectExportTargets(pkg), ...collectBinTargets(pkg)];
   const entries = [];
   for (const entryTarget of entryTargets) {
-    const resolvedPath = await resolveEntrySourcePath(packageDir, entryTarget.targetPath, fs2);
-    if (!resolvedPath)
-      continue;
-    entries.push({
-      path: resolvedPath,
-      subpath: entryTarget.subpath,
-      type: entryTarget.type
-    });
+    const allowIndexFallback = entryTarget.subpath === ".";
+    for (const targetPath of entryTarget.targetPaths) {
+      const resolvedPath = await resolveEntrySourcePath(packageDir, targetPath, fs2, { allowIndexFallback });
+      if (!resolvedPath)
+        continue;
+      entries.push({
+        path: resolvedPath,
+        subpath: entryTarget.subpath,
+        type: entryTarget.type
+      });
+      break;
+    }
   }
   const subPackages = await detectSubPackages(packageDir || ".", pkg, fs2);
   return {
@@ -14080,6 +14129,43 @@ var parseExportSpecifier = (node2) => {
   const exportedName = identifiers[1] ?? localName;
   return { localName, exportedName };
 };
+var parseImportSpecifier = (node2) => {
+  const identifiers = node2.namedChildren.filter((child) => child.type === "identifier" || child.type === "type_identifier").map((child) => child.text);
+  if (identifiers.length === 0)
+    return null;
+  const importedName = identifiers[0];
+  const localName = identifiers[1] ?? importedName;
+  return { importedName, localName };
+};
+var collectImportBindings = (root) => {
+  const bindings = new Map;
+  for (const node2 of root.namedChildren) {
+    if (node2.type !== "import_statement")
+      continue;
+    const stringNode = node2.namedChildren.find((child) => child.type === "string");
+    if (!stringNode)
+      continue;
+    const source2 = stripQuotes(stringNode.text);
+    if (!isRelativeModuleSpecifier(source2))
+      continue;
+    const clause = node2.namedChildren.find((child) => child.type === "import_clause");
+    for (const part of clause?.namedChildren ?? []) {
+      if (part.type === "identifier") {
+        bindings.set(part.text, { source: source2, importedName: "default" });
+        continue;
+      }
+      if (part.type !== "named_imports")
+        continue;
+      for (const specifier of part.namedChildren.filter((child) => child.type === "import_specifier")) {
+        const parsed = parseImportSpecifier(specifier);
+        if (parsed) {
+          bindings.set(parsed.localName, { source: source2, importedName: parsed.importedName });
+        }
+      }
+    }
+  }
+  return bindings;
+};
 var uniqueExports = (exportsList) => {
   const seen = new Set;
   return exportsList.filter((item) => {
@@ -14090,6 +14176,20 @@ var uniqueExports = (exportsList) => {
     return true;
   });
 };
+var traceImportedBinding = async (filePath, binding, exportedName, fs2, state) => {
+  const targetPath = await resolveImportSourcePath(filePath, binding.source, fs2);
+  if (!targetPath)
+    return [];
+  const traced = await traceFile(targetPath, fs2, state);
+  const match = traced.find((item) => item.exportedName === binding.importedName || binding.importedName === "default" && item.exportedName === item.localName);
+  if (!match)
+    return [];
+  return [{
+    exportedName,
+    localName: match.localName,
+    declarationFile: match.declarationFile
+  }];
+};
 var traceFile = async (filePath, fs2, state) => {
   const cached = state.cache.get(filePath);
   if (cached)
@@ -14105,6 +14205,7 @@ var traceFile = async (filePath, fs2, state) => {
       return [];
     const root = tree.rootNode;
     const localDeclarations = collectLocalDeclarations(root);
+    const importBindings = collectImportBindings(root);
     const exportsList = [];
     for (const node2 of root.namedChildren) {
       if (node2.type !== "export_statement")
@@ -14141,13 +14242,20 @@ var traceFile = async (filePath, fs2, state) => {
       if (!stringNode) {
         for (const specifier of exportClause.namedChildren.filter((child) => child.type === "export_specifier")) {
           const parsed = parseExportSpecifier(specifier);
-          if (!parsed || !localDeclarations.has(parsed.localName))
+          if (!parsed)
             continue;
-          exportsList.push({
-            exportedName: parsed.exportedName,
-            localName: parsed.localName,
-            declarationFile: filePath
-          });
+          if (localDeclarations.has(parsed.localName)) {
+            exportsList.push({
+              exportedName: parsed.exportedName,
+              localName: parsed.localName,
+              declarationFile: filePath
+            });
+            continue;
+          }
+          const importBinding = importBindings.get(parsed.localName);
+          if (importBinding) {
+            exportsList.push(...await traceImportedBinding(filePath, importBinding, parsed.exportedName, fs2, state));
+          }
         }
         continue;
       }
@@ -14539,7 +14647,7 @@ var analyzeDeclaration = (node2, filePath, declarations, importBindings, relatio
     });
   }
 };
-var collectImportBindings = (root, relations) => {
+var collectImportBindings2 = (root, relations) => {
   const bindings = new Map;
   for (const node2 of root.namedChildren.filter((child) => child.type === "import_statement")) {
     const specifierNode = node2.namedChildren.find((child) => child.type === "string");
@@ -14598,7 +14706,7 @@ var analyzeFile = async (filePath, fs2) => {
   }
   const root = tree.rootNode;
   const relations = [];
-  const importBindings = collectImportBindings(root, relations);
+  const importBindings = collectImportBindings2(root, relations);
   const declarations = new Map;
   for (const relation of relations) {
     if (relation.from === "") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@c4a/extract-ts",
-  "version": "0.5.38",
+  "version": "0.5.39-beta.1",
   "type": "module",
   "dependencies": {
     "web-tree-sitter": "^0.20.8"