@absolutejs/absolute 0.20.0-beta.180 → 0.20.0-beta.181

package/dist/build.js

@@ -7385,6 +7385,8 @@ var init_devRouteRegistrationCallsite = __esm(() => {
 // src/angular/staticAnalyzeSpaRoutes.ts
 var exports_staticAnalyzeSpaRoutes = {};
 __export(exports_staticAnalyzeSpaRoutes, {
+  analyzeAngularColocatedRouteFile: () => analyzeAngularColocatedRouteFile,
+  analyzeAngularColocatedRoutes: () => analyzeAngularColocatedRoutes,
   analyzeAngularSpaRouteFile: () => analyzeAngularSpaRouteFile,
   analyzeAngularSpaRoutes: () => analyzeAngularSpaRoutes
 });
@@ -7572,6 +7574,47 @@ var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((se
     routes,
     sourceFile: filePath
   };
+}, unwrapExpression = (expression) => {
+  if (lazyTypescript.isAsExpression(expression) || lazyTypescript.isSatisfiesExpression(expression) || lazyTypescript.isParenthesizedExpression(expression))
+    return unwrapExpression(expression.expression);
+  return expression;
+}, findColocatedRoutesArray = (sourceFile) => {
+  for (const statement of sourceFile.statements) {
+    if (!lazyTypescript.isVariableStatement(statement))
+      continue;
+    const exported = statement.modifiers?.some((modifier) => modifier.kind === lazyTypescript.SyntaxKind.ExportKeyword);
+    if (!exported)
+      continue;
+    for (const declaration of statement.declarationList.declarations) {
+      if (!lazyTypescript.isIdentifier(declaration.name))
+        continue;
+      if (declaration.name.text !== "routes")
+        continue;
+      if (!declaration.initializer)
+        continue;
+      const initializer = unwrapExpression(declaration.initializer);
+      if (lazyTypescript.isArrayLiteralExpression(initializer))
+        return initializer;
+    }
+  }
+  return null;
+}, COLOCATED_ROUTES_EXPORT, analyzeAngularColocatedRouteFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!COLOCATED_ROUTES_EXPORT.test(source))
+    return null;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TS);
+  const routesArray = findColocatedRoutesArray(sourceFile);
+  if (!routesArray)
+    return null;
+  const routes = [];
+  extractRoutePaths(routesArray, "", false, routes);
+  const host = { baseHref: "/", routes, sourceFile: filePath };
+  return host;
 }, walkTsFiles = async (dir, files) => {
   let items;
   try {
@@ -7593,6 +7636,22 @@ var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((se
     }
   }
   await Promise.all(directories.map((directory) => walkTsFiles(directory, files)));
+}, analyzeAngularColocatedRoutes = async (angularDirectory) => {
+  if (!existsSync16(angularDirectory))
+    return [];
+  const tsFiles = [];
+  await walkTsFiles(angularDirectory, tsFiles);
+  const pages = [];
+  await Promise.all(tsFiles.map(async (file) => {
+    try {
+      if (await analyzeAngularSpaRouteFile(file))
+        return;
+      const page = await analyzeAngularColocatedRouteFile(file);
+      if (page)
+        pages.push(page);
+    } catch {}
+  }));
+  return pages;
 }, analyzeAngularSpaRoutes = async (angularDirectory) => {
   if (!existsSync16(angularDirectory))
     return [];
@@ -7613,6 +7672,7 @@ var DYNAMIC_SEGMENT_PATTERN, pathHasDynamic = (path) => path.split("/").some((se
 var init_staticAnalyzeSpaRoutes = __esm(() => {
   init_lazyTypescript();
   DYNAMIC_SEGMENT_PATTERN = /^[:*]/;
+  COLOCATED_ROUTES_EXPORT = /\bexport\s+(?:const|let|var)\s+routes\b/;
 });
 
 // src/react/staticAnalyzeSpaRoutes.ts
@@ -15892,6 +15952,11 @@ var SPA_ROUTES_KEY = "__absoluteSpaRoutes", setSpaRouteManifest = (hosts) => {
 }, isRuntimeSpaHost = (value) => typeof value === "object" && value !== null && typeof Reflect.get(value, "framework") === "string", getSpaRouteManifest = () => {
   const value = Reflect.get(globalThis, SPA_ROUTES_KEY);
   return Array.isArray(value) ? value.filter(isRuntimeSpaHost) : [];
+}, OBSERVED_SPA_ROUTES_KEY = "__absoluteObservedSpaRoutes", getObservedSpaRoutes = () => {
+  const value = Reflect.get(globalThis, OBSERVED_SPA_ROUTES_KEY);
+  return Array.isArray(value) ? value.filter(isRuntimeSpaHost) : [];
+}, setObservedSpaRoutes = (hosts) => {
+  Reflect.set(globalThis, OBSERVED_SPA_ROUTES_KEY, hosts);
 }, normalizePath2 = (path) => {
   const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
   const trimmed = withLeadingSlash.replace(/\/+$/, "");
@@ -19899,13 +19964,13 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS3, getScriptKind3 = (filePath) => {
     return name.text;
   }
   return null;
-}, unwrapExpression = (node) => {
+}, unwrapExpression2 = (node) => {
   if (lazyTypescript.isAsExpression(node) || lazyTypescript.isSatisfiesExpression(node) || lazyTypescript.isParenthesizedExpression(node) || lazyTypescript.isTypeAssertionExpression(node)) {
-    return unwrapExpression(node.expression);
+    return unwrapExpression2(node.expression);
   }
   return node;
 }, readLiteral = (node) => {
-  const inner = unwrapExpression(node);
+  const inner = unwrapExpression2(node);
   if (lazyTypescript.isStringLiteral(inner) || lazyTypescript.isNoSubstitutionTemplateLiteral(inner)) {
     return inner.text;
   }
@@ -19924,7 +19989,7 @@ var SKIP_DIRS2, SOURCE_EXTENSIONS3, getScriptKind3 = (filePath) => {
   lazyTypescript.forEachChild(sourceFile, visit);
   return constants;
 }, readStringValue = (node, constants) => {
-  const inner = unwrapExpression(node);
+  const inner = unwrapExpression2(node);
   if (lazyTypescript.isIdentifier(inner))
     return constants.get(inner.text) ?? null;
   return readLiteral(inner);
@@ -27998,6 +28063,11 @@ ${offenders.map((o) => `  \u2022 ${o}`).join(`
     }))
   ];
   setSpaRouteManifest(spaRouteHosts);
+  const observedAngularHosts = isDev && angularDir ? await Promise.resolve().then(() => (init_staticAnalyzeSpaRoutes(), {})).then((module) => analyzeAngularColocatedRoutes(angularDir)) : [];
+  setObservedSpaRoutes(observedAngularHosts.map((host) => ({
+    ...host,
+    framework: "angular"
+  })));
   writeFileSync14(join57(buildPath, "spa-routes.json"), JSON.stringify(spaRouteHosts, null, "\t"));
   if (isIncremental) {
     writeBuildTrace(buildPath);
@@ -30245,10 +30315,15 @@ var normalizePath3 = (path) => resolve56(path).replace(/\\/g, "/"), owningFramew
     default:
       return null;
   }
+}, analyzeObservedFile = async (framework, file) => {
+  if (framework !== "angular")
+    return null;
+  return (await Promise.resolve().then(() => (init_staticAnalyzeSpaRoutes(), exports_staticAnalyzeSpaRoutes))).analyzeAngularColocatedRouteFile(file);
 }, readHost = async (framework, file) => {
   try {
     const host = await analyzeFile(framework, file);
-    return { host };
+    const observed = host ? null : await analyzeObservedFile(framework, file);
+    return { host, observed };
   } catch (error) {
     logWarn(`Could not re-read SPA routes from ${file}: ${error instanceof Error ? error.message : String(error)}`);
     return null;
@@ -30260,43 +30335,73 @@ var normalizePath3 = (path) => resolve56(path).replace(/\\/g, "/"), owningFramew
     added: [...afterPaths].filter((path) => !beforePaths.has(path)),
     removed: [...beforePaths].filter((path) => !afterPaths.has(path))
   };
-}, refreshSpaRoutesForFiles = async (files, paths) => {
+}, findHost = (hosts, framework, file) => hosts.find((host) => host.framework === framework && normalizePath3(host.sourceFile) === file), replaceHost = (hosts, change, next) => {
+  const previous = findHost(hosts, change.framework, change.file);
+  return [
+    ...hosts.filter((host) => host !== previous),
+    ...next ? [{ ...next, framework: change.framework }] : []
+  ];
+}, writeRouteTable = async (hosts, paths) => {
+  setSpaRouteManifest(hosts);
+  try {
+    await writeFile14(join63(paths.buildDir, "spa-routes.json"), JSON.stringify(hosts, null, "\t"));
+  } catch {}
+}, publishRouteChanges = async (pending, paths) => {
+  if (pending.length === 0)
+    return;
+  let hosts = getSpaRouteManifest();
+  let observed = getObservedSpaRoutes();
+  let enforcedChanged = false;
+  for (const change of pending) {
+    const previous = findHost(hosts, change.framework, change.file);
+    if (hostSignature(previous) !== hostSignature(change.next))
+      enforcedChanged = true;
+    hosts = replaceHost(hosts, change, change.next);
+    observed = replaceHost(observed, change, change.nextObserved);
+  }
+  setObservedSpaRoutes(observed);
+  if (enforcedChanged)
+    await writeRouteTable(hosts, paths);
+  for (const change of pending) {
+    logRoutesUpdate(change.file, change.framework, change.added, change.removed);
+  }
+}, readSpaRouteChanges = async (files, paths) => {
   const candidates = [...new Set(files.map(normalizePath3))].flatMap((file) => {
     const framework = owningFramework(file, paths);
     return framework ? [{ file, framework }] : [];
   });
-  if (candidates.length === 0)
-    return [];
-  let hosts = getSpaRouteManifest();
-  const changes = [];
+  const hosts = getSpaRouteManifest();
+  const observed = getObservedSpaRoutes();
+  const pending = [];
   await Promise.all(candidates.map(async ({ file, framework }) => {
     const read = await readHost(framework, file);
     if (!read)
       return;
-    const next = read.host;
-    const previous = hosts.find((host) => host.framework === framework && normalizePath3(host.sourceFile) === file);
-    if (hostSignature(previous) === hostSignature(next ?? undefined))
+    const previous = findHost(hosts, framework, file);
+    const previousObserved = findHost(observed, framework, file);
+    if (hostSignature(previous) === hostSignature(read.host) && hostSignature(previousObserved) === hostSignature(read.observed))
       return;
-    hosts = [
-      ...hosts.filter((host) => host !== previous),
-      ...next ? [{ ...next, framework }] : []
-    ];
-    changes.push({
+    pending.push({
       file,
       framework,
-      ...diffRoutes(previous, next ?? undefined)
+      next: read.host,
+      nextObserved: read.observed,
+      ...diffRoutes(previous ?? previousObserved, read.host ?? read.observed)
     });
   }));
-  if (changes.length === 0)
-    return changes;
-  setSpaRouteManifest(hosts);
-  try {
-    await writeFile14(join63(paths.buildDir, "spa-routes.json"), JSON.stringify(hosts, null, "\t"));
-  } catch {}
-  for (const change of changes) {
-    logRoutesUpdate(change.file, change.framework, change.added, change.removed);
-  }
-  return changes;
+  const changes = pending.map(({ added, file, framework, removed }) => ({
+    added,
+    file,
+    framework,
+    removed
+  }));
+  const publish = async (frameworks) => {
+    const batch = pending.filter((change) => !frameworks || frameworks.includes(change.framework));
+    for (const change of batch)
+      pending.splice(pending.indexOf(change), 1);
+    await publishRouteChanges(batch, paths);
+  };
+  return { changes, publish };
 };
 var init_spaRouteRefresh = __esm(() => {
   init_logger();
@@ -40286,16 +40391,21 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     ctx.inFlight = drive();
     ctx.inFlight.then(resolveFn, resolveFn);
   };
-  return () => {
+  return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
       ctx.debouncedPromise = new Promise((resolve) => {
         ctx.debouncedResolve = resolve;
       });
     }
+    const scheduled = ctx.debouncedPromise;
     if (ctx.debounceTimer)
       clearTimeout(ctx.debounceTimer);
-    ctx.debounceTimer = setTimeout(fire, SVELTE_BUNDLE_DEBOUNCE_MS);
-    return ctx.debouncedPromise;
+    ctx.debounceTimer = null;
+    if (immediate)
+      fire();
+    else
+      ctx.debounceTimer = setTimeout(fire, SVELTE_BUNDLE_DEBOUNCE_MS);
+    return scheduled;
   };
 }, handleSvelteFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const svelteDir = config.svelteDirectory ?? "";
@@ -40570,16 +40680,21 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     ctx.inFlight = drive();
     ctx.inFlight.then(resolveFn, resolveFn);
   };
-  return () => {
+  return ({ immediate = false } = {}) => {
     if (!ctx.debouncedPromise) {
       ctx.debouncedPromise = new Promise((resolve) => {
         ctx.debouncedResolve = resolve;
       });
     }
+    const scheduled = ctx.debouncedPromise;
     if (ctx.debounceTimer)
       clearTimeout(ctx.debounceTimer);
-    ctx.debounceTimer = setTimeout(fire, VUE_BUNDLE_DEBOUNCE_MS);
-    return ctx.debouncedPromise;
+    ctx.debounceTimer = null;
+    if (immediate)
+      fire();
+    else
+      ctx.debounceTimer = setTimeout(fire, VUE_BUNDLE_DEBOUNCE_MS);
+    return scheduled;
   };
 }, handleVueFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const vueFiles = filesToRebuild.filter((file) => file.endsWith(".vue") && detectFramework(file, state.resolvedPaths) === "vue");
@@ -41309,9 +41424,29 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
   await processMarkupFiles(markupFiles);
 }, runHtmlFastPath = async (state, config, filesToRebuild, startTime) => runMarkupFastPath(state, config, filesToRebuild, startTime, "html"), runHtmxFastPath = async (state, config, filesToRebuild, startTime) => runMarkupFastPath(state, config, filesToRebuild, startTime, "htmx"), markHandledFiles = (files, framework, resolvedPaths, handled) => {
   files.filter((f) => detectFramework(f, resolvedPaths) === framework).forEach((f) => handled.add(f));
+}, rebuildSsrForRouteChanges = async (state, config, changes) => {
+  const changedFiles = (framework) => changes.filter((change) => change.framework === framework).map((change) => change.file);
+  const vueFiles = changedFiles("vue");
+  const svelteFiles = changedFiles("svelte");
+  await Promise.all([
+    vueFiles.length > 0 && config.vueDirectory ? scheduleVueBundleRebuild(state, vueFiles, config)({ immediate: true }) : undefined,
+    svelteFiles.length > 0 && config.svelteDirectory ? scheduleSvelteBundleRebuild(state, svelteFiles, config)({ immediate: true }) : undefined
+  ]);
+}, flushAngularBundleRebuild = async (state) => {
+  const ctx = angularBundleState.get(state);
+  if (!ctx)
+    return;
+  if (ctx.debounceTimer) {
+    await scheduleAngularBundleRebuild(state, ctx.pageEntries, ctx.angularDir)({ immediate: true });
+    return;
+  }
+  if (ctx.inFlight)
+    await ctx.inFlight;
 }, runFrameworkFastPaths = async (state, config, affectedFrameworks, files, startTime, onRebuildComplete) => {
   const handled = new Set;
-  await refreshSpaRoutesForFiles(files, state.resolvedPaths);
+  const routeChanges = await readSpaRouteChanges(files, state.resolvedPaths);
+  await rebuildSsrForRouteChanges(state, config, routeChanges.changes);
+  await routeChanges.publish(["react", "svelte", "vue"]);
   const fastPaths = [
     {
       directory: config.angularDirectory,
@@ -41345,6 +41480,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, clearDevSs
     await fastPath.handler(state, config, files, startTime, onRebuildComplete);
     markHandledFiles(files, fastPath.framework, state.resolvedPaths, handled);
   });
+  if (routeChanges.changes.some((change) => change.framework === "angular"))
+    await flushAngularBundleRebuild(state);
+  await routeChanges.publish();
   for (const file of files) {
     if (!handled.has(file) && detectFramework(file, state.resolvedPaths) === "unknown" && !state.lastUserEditedFiles?.has(resolvePath4(file)))
       handled.add(file);
@@ -42649,5 +42787,5 @@ export {
   devBuild
 };
 
-//# debugId=49F451E82229DDB964756E2164756E21
+//# debugId=09C80D2AE135A40164756E2164756E21
 //# sourceMappingURL=build.js.map