@rangojs/router 0.0.0-experimental.137 → 0.0.0-experimental.139

package/dist/bin/rango.js

@@ -289,6 +289,96 @@ function extractNamePrefixFromInclude(node) {
   }
   return null;
 }
+function thenSelectsNonDefaultMember(expr) {
+  const findThenCall = (e) => {
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression) && e.expression.name.text === "then") {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findThenCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findThenCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findThenCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findThenCall(e.expression);
+    return null;
+  };
+  const thenCall = findThenCall(expr);
+  if (!thenCall || thenCall.arguments.length === 0) return false;
+  const cb = thenCall.arguments[0];
+  if (!ts3.isArrowFunction(cb) && !ts3.isFunctionExpression(cb)) return false;
+  let ret;
+  if (ts3.isBlock(cb.body)) {
+    for (const stmt of cb.body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        ret = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    ret = cb.body;
+  }
+  if (!ret) return false;
+  if (ts3.isPropertyAccessExpression(ret)) {
+    return ret.name.text !== "default";
+  }
+  return false;
+}
+function extractDynamicImportSpecifier(node) {
+  let body;
+  if (ts3.isArrowFunction(node) || ts3.isFunctionExpression(node)) {
+    body = node.body;
+  }
+  if (!body) return null;
+  let expr;
+  if (ts3.isBlock(body)) {
+    for (const stmt of body.statements) {
+      if (ts3.isReturnStatement(stmt) && stmt.expression) {
+        expr = stmt.expression;
+        break;
+      }
+    }
+  } else {
+    expr = body;
+  }
+  if (!expr) return null;
+  const findImportCall = (e) => {
+    if (ts3.isCallExpression(e) && e.expression.kind === ts3.SyntaxKind.ImportKeyword) {
+      return e;
+    }
+    if (ts3.isCallExpression(e) && ts3.isPropertyAccessExpression(e.expression)) {
+      return findImportCall(e.expression.expression);
+    }
+    if (ts3.isPropertyAccessExpression(e)) return findImportCall(e.expression);
+    if (ts3.isParenthesizedExpression(e)) return findImportCall(e.expression);
+    if (ts3.isAwaitExpression(e)) return findImportCall(e.expression);
+    return null;
+  };
+  const importCall = findImportCall(expr);
+  if (!importCall || importCall.arguments.length === 0) return null;
+  if (thenSelectsNonDefaultMember(expr)) return null;
+  return getStringValue(importCall.arguments[0]);
+}
+function resolveDefaultExportTarget(code, sourceFile) {
+  let result = null;
+  function visit(node) {
+    if (result) return;
+    if (ts3.isExportAssignment(node) && !node.isExportEquals) {
+      const expr = node.expression;
+      if (ts3.isIdentifier(expr)) {
+        result = { variableName: expr.text };
+      } else if (ts3.isCallExpression(expr)) {
+        const callee = expr.expression;
+        if (ts3.isIdentifier(callee) && callee.text === "urls") {
+          result = { inlineBlock: expr.getText(sourceFile) };
+        }
+      }
+      return;
+    }
+    ts3.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return result;
+}
 function extractIncludesWithDiagnostics(code, sourceFileArg) {
   const sourceFile = sourceFileArg ?? ts3.createSourceFile(
     "input.tsx",
@@ -314,12 +404,19 @@ function extractIncludesWithDiagnostics(code, sourceFileArg) {
         }
         const secondArg = node.arguments[1];
         const namePrefix = extractNamePrefixFromInclude(node);
+        const dynamicImportSpec = extractDynamicImportSpecifier(secondArg);
         if (ts3.isIdentifier(secondArg)) {
           resolved.push({
             pathPrefix,
             variableName: secondArg.text,
             namePrefix
           });
+        } else if (dynamicImportSpec !== null) {
+          resolved.push({
+            pathPrefix,
+            moduleSpecifier: dynamicImportSpec,
+            namePrefix
+          });
         } else if (ts3.isCallExpression(secondArg)) {
           const callText = secondArg.expression.getText(sourceFile);
           unresolvable.push({
@@ -423,57 +520,94 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
       diagnosticsOut.push({ ...entry, sourceFile: filePath });
     }
   }
-  for (const { pathPrefix, variableName, namePrefix } of includes) {
+  for (const inc of includes) {
+    const { pathPrefix, namePrefix } = inc;
     let childResult;
-    const imported = resolveImportedVariable(fullSource, variableName);
-    if (imported) {
-      const targetFile = resolveImportPath(imported.specifier, filePath);
+    if (inc.moduleSpecifier) {
+      const targetFile = resolveImportPath(inc.moduleSpecifier, filePath);
       if (!targetFile) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "file-not-found",
-            sourceFile: filePath,
-            detail: `import "${imported.specifier}" resolved to no file`
-          });
-        }
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to no file`
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        targetFile,
-        imported.exportedName,
-        visited,
-        diagnosticsOut,
-        void 0,
-        memo
-      );
-    } else {
-      const sameFileBlock = extractUrlsBlockForVariable(
-        fullSource,
-        variableName,
-        parseBlock(memo, fullSource)
+      let targetSource;
+      try {
+        targetSource = readSourceMemoized(memo, resolve(targetFile));
+      } catch (err) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "file-not-found",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") resolved to "${targetFile}" but reading it failed: ${err?.message ?? String(err)}`
+        });
+        continue;
+      }
+      const def = resolveDefaultExportTarget(
+        targetSource,
+        parseBlock(memo, targetSource)
       );
-      if (!sameFileBlock) {
-        if (diagnosticsOut) {
-          diagnosticsOut.push({
-            pathPrefix,
-            namePrefix,
-            reason: "unresolvable-import",
-            sourceFile: filePath,
-            detail: `variable "${variableName}" not found in imports or same-file scope`
-          });
-        }
+      if (!def) {
+        diagnosticsOut?.push({
+          pathPrefix,
+          namePrefix,
+          reason: "unresolvable-import",
+          sourceFile: filePath,
+          detail: `import("${inc.moduleSpecifier}") has no resolvable \`export default urls(...)\``
+        });
         continue;
       }
-      childResult = buildCombinedRouteMapWithSearch(
-        filePath,
+      if (def.inlineBlock) {
+        childResult = buildCombinedRouteMapWithSearch(
+          targetFile,
+          void 0,
+          visited,
+          diagnosticsOut,
+          def.inlineBlock,
+          memo
+        );
+      } else {
+        const variableName = def.variableName;
+        const resolved = resolveIncludedVariable({
+          variableName,
+          resolutionFile: targetFile,
+          resolutionSource: targetSource,
+          reportFile: filePath,
+          memo,
+          visited,
+          diagnosticsOut,
+          pathPrefix,
+          namePrefix,
+          fileNotFoundDetail: (specifier) => `import("${inc.moduleSpecifier}") default re-exports "${variableName}" from "${specifier}", which resolved to no file`,
+          notFoundDetail: () => `import("${inc.moduleSpecifier}") default "${variableName}" not found in its imports or same-file scope`
+        });
+        if (!resolved) continue;
+        childResult = resolved;
+      }
+    } else if (inc.variableName) {
+      const variableName = inc.variableName;
+      const resolved = resolveIncludedVariable({
         variableName,
+        resolutionFile: filePath,
+        resolutionSource: fullSource,
+        reportFile: filePath,
+        memo,
         visited,
         diagnosticsOut,
-        void 0,
-        memo
-      );
+        pathPrefix,
+        namePrefix,
+        fileNotFoundDetail: (specifier) => `import "${specifier}" resolved to no file`,
+        notFoundDetail: () => `variable "${variableName}" not found in imports or same-file scope`
+      });
+      if (!resolved) continue;
+      childResult = resolved;
+    } else {
+      continue;
     }
     if (namePrefix === null) {
       continue;
@@ -496,6 +630,64 @@ function buildRouteMapFromBlock(block, fullSource, filePath, visited, searchSche
   }
   return routeMap;
 }
+function resolveIncludedVariable(opts) {
+  const {
+    variableName,
+    resolutionFile,
+    resolutionSource,
+    reportFile,
+    memo,
+    visited,
+    diagnosticsOut,
+    pathPrefix,
+    namePrefix
+  } = opts;
+  const imported = resolveImportedVariable(resolutionSource, variableName);
+  if (imported) {
+    const targetFile = resolveImportPath(imported.specifier, resolutionFile);
+    if (!targetFile) {
+      diagnosticsOut?.push({
+        pathPrefix,
+        namePrefix,
+        reason: "file-not-found",
+        sourceFile: reportFile,
+        detail: opts.fileNotFoundDetail(imported.specifier)
+      });
+      return null;
+    }
+    return buildCombinedRouteMapWithSearch(
+      targetFile,
+      imported.exportedName,
+      visited,
+      diagnosticsOut,
+      void 0,
+      memo
+    );
+  }
+  const sameFileBlock = extractUrlsBlockForVariable(
+    resolutionSource,
+    variableName,
+    parseBlock(memo, resolutionSource)
+  );
+  if (!sameFileBlock) {
+    diagnosticsOut?.push({
+      pathPrefix,
+      namePrefix,
+      reason: "unresolvable-import",
+      sourceFile: reportFile,
+      detail: opts.notFoundDetail()
+    });
+    return null;
+  }
+  return buildCombinedRouteMapWithSearch(
+    resolutionFile,
+    variableName,
+    visited,
+    diagnosticsOut,
+    void 0,
+    memo
+  );
+}
 function buildCombinedRouteMapWithSearch(filePath, variableName, visited, diagnosticsOut, inlineBlock, memo) {
   visited = visited ?? /* @__PURE__ */ new Set();
   memo = memo ?? createScanMemo();
@@ -790,7 +982,10 @@ function countPublicRouteEntries(source) {
 function isRoutableSourceFile(name) {
   return (name.endsWith(".ts") || name.endsWith(".tsx") || name.endsWith(".js") || name.endsWith(".jsx")) && !name.includes(".gen.") && !name.includes(".test.") && !name.includes(".spec.");
 }
-function findRouterFilesRecursive(dir, filter, results) {
+function isExcludedScanDir(name) {
+  return name === "node_modules" || name === "dist" || name === "coverage" || name === "__tests__" || name === "__mocks__" || name.startsWith(".");
+}
+function findCallSiteFilesRecursive(dir, pattern, patternG, stopAtMatchDir, filter, results) {
   let entries;
   try {
     entries = readdirSync2(dir, { withFileTypes: true });
@@ -801,32 +996,36 @@ function findRouterFilesRecursive(dir, filter, results) {
     return;
   }
   const childDirs = [];
-  const routerFilesInDir = [];
+  const matchesInDir = [];
   for (const entry of entries) {
     const fullPath = join2(dir, entry.name);
     if (entry.isDirectory()) {
-      if (entry.name === "node_modules" || entry.name === "dist" || entry.name === "coverage" || entry.name === "__tests__" || entry.name === "__mocks__" || entry.name.startsWith("."))
-        continue;
-      childDirs.push(fullPath);
+      if (!isExcludedScanDir(entry.name)) childDirs.push(fullPath);
       continue;
     }
     if (!isRoutableSourceFile(entry.name)) continue;
     if (filter && !filter(fullPath)) continue;
     try {
       const source = readFileSync3(fullPath, "utf-8");
-      if (ROUTER_CALL_PATTERN.test(source) && firstCodeMatchIndex(source, ROUTER_CALL_PATTERN_G) >= 0) {
-        routerFilesInDir.push(fullPath);
+      if (pattern.test(source) && firstCodeMatchIndex(source, patternG) >= 0) {
+        matchesInDir.push(fullPath);
       }
     } catch {
       continue;
     }
   }
-  if (routerFilesInDir.length > 0) {
-    results.push(...routerFilesInDir);
-    return;
-  }
-  for (const childDir of childDirs) {
-    findRouterFilesRecursive(childDir, filter, results);
+  results.push(...matchesInDir);
+  if (!stopAtMatchDir || matchesInDir.length === 0) {
+    for (const childDir of childDirs) {
+      findCallSiteFilesRecursive(
+        childDir,
+        pattern,
+        patternG,
+        stopAtMatchDir,
+        filter,
+        results
+      );
+    }
   }
 }
 function findNestedRouterConflict(routerFiles) {
@@ -1091,7 +1290,14 @@ function detectUnresolvableIncludesForUrlsFile(filePath) {
 }
 function findRouterFiles(root, filter) {
   const result = [];
-  findRouterFilesRecursive(root, filter, result);
+  findCallSiteFilesRecursive(
+    root,
+    ROUTER_CALL_PATTERN,
+    ROUTER_CALL_PATTERN_G,
+    true,
+    filter,
+    result
+  );
   return result;
 }
 function writeCombinedRouteTypes(root, knownRouterFiles, opts) {
@@ -1598,7 +1804,10 @@ async function discoverAndWriteRouteTypes(opts) {
     let routerMountIndex = 0;
     for (const [id, router] of registry) {
       if (!router.urlpatterns) continue;
-      const manifest = generateManifest(router.urlpatterns, routerMountIndex);
+      const manifest = await generateManifest(
+        router.urlpatterns,
+        routerMountIndex
+      );
       routerMountIndex++;
       const rawManifest = manifest.routeManifest;
       const routeManifest = {};