@open-mercato/cli 0.5.1-develop.2699.f8b50c8046 → 0.5.1-develop.2709.b6bdd776ac

package/dist/lib/generators/module-registry.js

@@ -238,6 +238,47 @@ function collectLocalDeclarations(parsed) {
   }
   return locals;
 }
+function resolveImportedModuleFile(sourceFile, moduleSpecifier) {
+  if (!moduleSpecifier.startsWith(".")) return null;
+  return findExistingModuleFileByBaseNames(path.dirname(sourceFile), [
+    moduleSpecifier,
+    path.join(moduleSpecifier, "index")
+  ]);
+}
+function collectImportedBindings(parsed, sourceFile) {
+  const bindings = /* @__PURE__ */ new Map();
+  for (const statement of parsed.statements) {
+    if (!ts.isImportDeclaration(statement)) continue;
+    if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const resolvedSourceFile = resolveImportedModuleFile(sourceFile, statement.moduleSpecifier.text);
+    if (!resolvedSourceFile) continue;
+    const importClause = statement.importClause;
+    if (!importClause) continue;
+    if (importClause.name) {
+      bindings.set(importClause.name.text, {
+        kind: "default",
+        sourceFile: resolvedSourceFile
+      });
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) continue;
+    if (ts.isNamespaceImport(namedBindings)) {
+      bindings.set(namedBindings.name.text, {
+        kind: "namespace",
+        sourceFile: resolvedSourceFile
+      });
+      continue;
+    }
+    for (const element of namedBindings.elements) {
+      bindings.set(element.name.text, {
+        kind: "named",
+        sourceFile: resolvedSourceFile,
+        exportName: element.propertyName?.text ?? element.name.text
+      });
+    }
+  }
+  return bindings;
+}
 function collectReexportedNames(parsed) {
   const exportedNames = /* @__PURE__ */ new Set();
   for (const statement of parsed.statements) {
@@ -284,7 +325,94 @@ function findExportedInitializer(parsed, exportName, exportedNames) {
   }
   return null;
 }
-function resolveExpressionValue(expression, locals, visited) {
+function findDefaultExportInitializer(parsed) {
+  for (const statement of parsed.statements) {
+    if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+      return statement.expression;
+    }
+    if (!ts.isVariableStatement(statement)) continue;
+    const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : void 0;
+    const isDefaultExport = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+    if (!isDefaultExport) continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (declaration.initializer) return declaration.initializer;
+    }
+  }
+  return null;
+}
+function loadParsedModuleResolutionContext(sourceFile, cache) {
+  if (cache.has(sourceFile)) {
+    return cache.get(sourceFile) ?? null;
+  }
+  let source = "";
+  try {
+    source = fs.readFileSync(sourceFile, "utf8");
+  } catch {
+    cache.set(sourceFile, null);
+    return null;
+  }
+  const parsed = ts.createSourceFile(
+    sourceFile,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    inferScriptKind(sourceFile)
+  );
+  const context = {
+    sourceFile,
+    parsed,
+    locals: collectLocalDeclarations(parsed),
+    exportedNames: collectReexportedNames(parsed),
+    imports: collectImportedBindings(parsed, sourceFile)
+  };
+  cache.set(sourceFile, context);
+  return context;
+}
+function resolveImportedBindingValue(binding, pathSegments, visited, cache) {
+  const importedContext = loadParsedModuleResolutionContext(binding.sourceFile, cache);
+  if (!importedContext) return void 0;
+  if (binding.kind === "namespace") {
+    if (pathSegments.length === 0) return void 0;
+    const [exportName, ...restPath] = pathSegments;
+    const importKey2 = `${binding.sourceFile}::${exportName}`;
+    if (visited.has(importKey2)) return void 0;
+    let initializer2 = findExportedInitializer(importedContext.parsed, exportName, importedContext.exportedNames);
+    if (!initializer2 && importedContext.exportedNames.has(exportName)) {
+      initializer2 = importedContext.locals.get(exportName) ?? null;
+    }
+    if (!initializer2) return void 0;
+    const nextVisited2 = new Set(visited);
+    nextVisited2.add(importKey2);
+    let value2 = resolveExpressionValue(initializer2, importedContext, nextVisited2, cache);
+    for (const segment of restPath) {
+      if (value2 && typeof value2 === "object" && !Array.isArray(value2) && segment in value2) {
+        value2 = value2[segment];
+      } else {
+        return void 0;
+      }
+    }
+    return value2;
+  }
+  const importKey = binding.kind === "default" ? `${binding.sourceFile}::default` : `${binding.sourceFile}::${binding.exportName}`;
+  if (visited.has(importKey)) return void 0;
+  let initializer = binding.kind === "default" ? findDefaultExportInitializer(importedContext.parsed) : findExportedInitializer(importedContext.parsed, binding.exportName, importedContext.exportedNames);
+  if (!initializer && binding.kind === "named" && importedContext.exportedNames.has(binding.exportName)) {
+    initializer = importedContext.locals.get(binding.exportName) ?? null;
+  }
+  if (!initializer) return void 0;
+  const nextVisited = new Set(visited);
+  nextVisited.add(importKey);
+  let value = resolveExpressionValue(initializer, importedContext, nextVisited, cache);
+  for (const segment of pathSegments) {
+    if (value && typeof value === "object" && !Array.isArray(value) && segment in value) {
+      value = value[segment];
+    } else {
+      return void 0;
+    }
+  }
+  return value;
+}
+function resolveExpressionValue(expression, context, visited, cache) {
   const expr = unwrapExpression(expression);
   if (ts.isStringLiteral(expr) || ts.isNoSubstitutionTemplateLiteral(expr)) return expr.text;
   if (ts.isNumericLiteral(expr)) return Number(expr.text);
@@ -300,19 +428,19 @@ function resolveExpressionValue(expression, locals, visited) {
       if (ts.isPropertyAssignment(property)) {
         const key = ts.isIdentifier(property.name) ? property.name.text : ts.isStringLiteral(property.name) ? property.name.text : null;
         if (!key) continue;
-        const value = resolveExpressionValue(property.initializer, locals, visited);
+        const value = resolveExpressionValue(property.initializer, context, visited, cache);
         if (value !== void 0) result[key] = value;
       } else if (ts.isShorthandPropertyAssignment(property)) {
         const key = property.name.text;
-        const initializer = locals.get(key);
+        const initializer = context.locals.get(key);
         if (initializer && !visited.has(key)) {
           const nextVisited = new Set(visited);
           nextVisited.add(key);
-          const value = resolveExpressionValue(initializer, locals, nextVisited);
+          const value = resolveExpressionValue(initializer, context, nextVisited, cache);
           if (value !== void 0) result[key] = value;
         }
       } else if (ts.isSpreadAssignment(property)) {
-        const spread = resolveExpressionValue(property.expression, locals, visited);
+        const spread = resolveExpressionValue(property.expression, context, visited, cache);
         if (spread && typeof spread === "object" && !Array.isArray(spread)) {
           Object.assign(result, spread);
         }
@@ -324,22 +452,26 @@ function resolveExpressionValue(expression, locals, visited) {
     const result = [];
     for (const element of expr.elements) {
       if (ts.isSpreadElement(element)) {
-        const spread = resolveExpressionValue(element.expression, locals, visited);
+        const spread = resolveExpressionValue(element.expression, context, visited, cache);
         if (Array.isArray(spread)) result.push(...spread);
         continue;
       }
-      const value = resolveExpressionValue(element, locals, visited);
+      const value = resolveExpressionValue(element, context, visited, cache);
       if (value !== void 0) result.push(value);
     }
     return result;
   }
   if (ts.isIdentifier(expr)) {
     if (visited.has(expr.text)) return void 0;
-    const initializer = locals.get(expr.text);
-    if (!initializer) return void 0;
-    const nextVisited = new Set(visited);
-    nextVisited.add(expr.text);
-    return resolveExpressionValue(initializer, locals, nextVisited);
+    const initializer = context.locals.get(expr.text);
+    if (initializer) {
+      const nextVisited = new Set(visited);
+      nextVisited.add(expr.text);
+      return resolveExpressionValue(initializer, context, nextVisited, cache);
+    }
+    const importBinding = context.imports.get(expr.text);
+    if (!importBinding) return void 0;
+    return resolveImportedBindingValue(importBinding, [], visited, cache);
   }
   if (ts.isPropertyAccessExpression(expr)) {
     const pathSegments = [];
@@ -351,39 +483,44 @@ function resolveExpressionValue(expression, locals, visited) {
     }
     if (!ts.isIdentifier(cursor)) return void 0;
     const rootName = cursor.text;
-    if (visited.has(rootName)) return void 0;
-    const rootInit = locals.get(rootName);
-    if (!rootInit) return void 0;
-    const unwrappedRoot = unwrapExpression(rootInit);
-    const nextVisited = new Set(visited);
-    nextVisited.add(rootName);
-    if (ts.isCallExpression(unwrappedRoot) && unwrappedRoot.arguments.length > 0) {
-      const firstArg = unwrapExpression(unwrappedRoot.arguments[0]);
-      if (ts.isObjectLiteralExpression(firstArg)) {
-        const argObject = resolveExpressionValue(firstArg, locals, nextVisited);
-        if (argObject && typeof argObject === "object" && !Array.isArray(argObject)) {
-          let current = argObject;
-          for (const segment of pathSegments) {
-            if (current && typeof current === "object" && !Array.isArray(current) && segment in current) {
-              current = current[segment];
-            } else {
-              current = void 0;
-              break;
+    if (!visited.has(rootName)) {
+      const rootInit = context.locals.get(rootName);
+      if (rootInit) {
+        const unwrappedRoot = unwrapExpression(rootInit);
+        const nextVisited = new Set(visited);
+        nextVisited.add(rootName);
+        if (ts.isCallExpression(unwrappedRoot) && unwrappedRoot.arguments.length > 0) {
+          const firstArg = unwrapExpression(unwrappedRoot.arguments[0]);
+          if (ts.isObjectLiteralExpression(firstArg)) {
+            const argObject = resolveExpressionValue(firstArg, context, nextVisited, cache);
+            if (argObject && typeof argObject === "object" && !Array.isArray(argObject)) {
+              let current = argObject;
+              for (const segment of pathSegments) {
+                if (current && typeof current === "object" && !Array.isArray(current) && segment in current) {
+                  current = current[segment];
+                } else {
+                  current = void 0;
+                  break;
+                }
+              }
+              if (current !== void 0) return current;
             }
           }
-          if (current !== void 0) return current;
         }
+        let value = resolveExpressionValue(rootInit, context, nextVisited, cache);
+        for (const segment of pathSegments) {
+          if (value && typeof value === "object" && !Array.isArray(value) && segment in value) {
+            value = value[segment];
+          } else {
+            return void 0;
+          }
+        }
+        return value;
       }
     }
-    let value = resolveExpressionValue(rootInit, locals, nextVisited);
-    for (const segment of pathSegments) {
-      if (value && typeof value === "object" && !Array.isArray(value) && segment in value) {
-        value = value[segment];
-      } else {
-        return void 0;
-      }
-    }
-    return value;
+    const importBinding = context.imports.get(rootName);
+    if (!importBinding) return void 0;
+    return resolveImportedBindingValue(importBinding, pathSegments, visited, cache);
   }
   return void 0;
 }
@@ -427,27 +564,15 @@ function hasNamedExport(sourceFile, exportName) {
   return false;
 }
 function resolveNamedObjectExport(sourceFile, exportName) {
-  let source = "";
-  try {
-    source = fs.readFileSync(sourceFile, "utf8");
-  } catch {
-    return null;
-  }
-  const parsed = ts.createSourceFile(
-    sourceFile,
-    source,
-    ts.ScriptTarget.Latest,
-    true,
-    inferScriptKind(sourceFile)
-  );
-  const locals = collectLocalDeclarations(parsed);
-  const exportedNames = collectReexportedNames(parsed);
-  let initializer = findExportedInitializer(parsed, exportName, exportedNames);
-  if (!initializer && exportedNames.has(exportName)) {
-    initializer = locals.get(exportName) ?? null;
+  const cache = /* @__PURE__ */ new Map();
+  const context = loadParsedModuleResolutionContext(sourceFile, cache);
+  if (!context) return null;
+  let initializer = findExportedInitializer(context.parsed, exportName, context.exportedNames);
+  if (!initializer && context.exportedNames.has(exportName)) {
+    initializer = context.locals.get(exportName) ?? null;
   }
   if (!initializer) return null;
-  const value = resolveExpressionValue(initializer, locals, /* @__PURE__ */ new Set());
+  const value = resolveExpressionValue(initializer, context, /* @__PURE__ */ new Set(), cache);
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const record = value;
   return Object.keys(record).length > 0 ? record : null;