@rangojs/router 0.0.0-experimental.e9c0b2f2 → 0.0.0-experimental.ea9f40f2

package/dist/bin/rango.js

@@ -1,8 +1,13 @@
 #!/usr/bin/env node
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -284,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",
@@ -309,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({
@@ -418,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;
@@ -491,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();
@@ -1240,9 +1437,14 @@ initializeApp().catch(console.error);
 `.trim();
     VIRTUAL_ENTRY_SSR = `
 import { createFromReadableStream } from "@rangojs/router/internal/deps/ssr";
-import { renderToReadableStream } from "react-dom/server.edge";
+import { renderToReadableStream, resume } from "react-dom/server.edge";
+import { prerender } from "react-dom/static.edge";
 import { injectRSCPayload } from "@rangojs/router/internal/deps/html-stream-server";
-import { createSSRHandler } from "@rangojs/router/ssr";
+import {
+  createSSRHandler,
+  createShellCaptureHandler,
+  createShellResumeHandler,
+} from "@rangojs/router/ssr";
 
 export const renderHTML = createSSRHandler({
   createFromReadableStream,
@@ -1251,6 +1453,26 @@ export const renderHTML = createSSRHandler({
   loadBootstrapScriptContent: () =>
     import.meta.viteRsc.loadBootstrapScriptContent("index"),
 });
+
+export const captureShellHTML = createShellCaptureHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+});
+
+export const resumeShellHTML = createShellResumeHandler({
+  createFromReadableStream,
+  renderToReadableStream,
+  injectRSCPayload,
+  prerender,
+  resume,
+  loadBootstrapScriptContent: () =>
+    import.meta.viteRsc.loadBootstrapScriptContent("index"),
+});
 `.trim();
     VIRTUAL_IDS = {
       browser: "virtual:rsc-router/entry.browser.js",
@@ -1607,7 +1829,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 = {};