@absolutejs/absolute 0.19.0-beta.1004 → 0.19.0-beta.1006

package/dist/src/build/compileVue.d.ts

@@ -1,4 +1,5 @@
 import type { SFCDescriptor } from '@vue/compiler-sfc';
+import { type ParsedVueSpaRoute } from './parseVueSpaRoutes';
 import type { StylePreprocessorConfig } from '../../types/build';
 export type VueChangeType = 'style-only' | 'template-only' | 'script' | 'full';
 export declare const vueHmrMetadata: Map<string, {
@@ -17,4 +18,5 @@ export declare const compileVue: (entryPoints: string[], vueRootDir: string, isD
     vueCssPaths: string[];
     vueIndexPaths: string[];
     vueServerPaths: string[];
+    vueSpaRoutesBySource: Map<string, ParsedVueSpaRoute[]>;
 }>;

package/dist/src/build/parseVueSpaRoutes.d.ts

@@ -0,0 +1,20 @@
+/** Extract SPA child routes from a Vue page's source.
+ *
+ *  Looks for `export const routes = defineRoutes([ ... ])` and parses
+ *  each entry's `{ path, component: () => import('./X.vue') }` shape
+ *  into a `{ path, importPath }` pair. The result drives the per-route
+ *  CSS side-manifest emitted in `core/build.ts` so the SSR handler can
+ *  inline the matched child route's compiled CSS (see
+ *  `utils/spaRouteCss.ts` for the runtime side).
+ *
+ *  Regex-based on purpose: the supported shape is single-statement
+ *  array-of-object-literals, which is the only form `defineRoutes` is
+ *  documented to take. AST parsing would catch a few exotic edge cases
+ *  but adds a dependency on every page compile; the failure mode of a
+ *  miss is "child route CSS isn't inlined for that route", same as
+ *  pre-feature behaviour, so a loose regex is the right trade-off. */
+export type ParsedVueSpaRoute = {
+    path: string;
+    importPath: string;
+};
+export declare const parseVueSpaRoutes: (source: string) => ParsedVueSpaRoute[];

package/dist/src/utils/spaRouteCss.d.ts

@@ -0,0 +1,4 @@
+/** Resolve the matched SPA child route's compiled CSS for a request.
+ *  Returns the CSS text (possibly empty) so the page handler can
+ *  inline it alongside the parent page's own sibling CSS. */
+export declare const resolveSpaChildCss: (siblingJsPath: string | undefined, requestUrl: string | undefined) => Promise<string>;

package/dist/vue/index.js

@@ -2084,7 +2084,7 @@ __export(exports_stylePreprocessor, {
 });
 import { createHash } from "crypto";
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import { createRequire } from "module";
 import {
   dirname as dirname3,
@@ -2353,7 +2353,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
       }
       deps?.add(resolved);
       return {
-        contents: preprocessLoadedStyle(await readFile(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
+        contents: preprocessLoadedStyle(await readFile2(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
         filename: resolved
       };
     };
@@ -2425,7 +2425,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   styleOutputHashes.delete(key);
 }, compileStyleSource = async (filePath, source, languageHint, config) => {
   const language = getStyleLanguage(languageHint ?? filePath);
-  const rawContents = source ?? await readFile(filePath, "utf-8");
+  const rawContents = source ?? await readFile2(filePath, "utf-8");
   const deps = new Set;
   if (language === "scss" || language === "sass") {
     const options = getSassOptions(config, language);
@@ -2583,7 +2583,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
     }
     const nextVisited = new Set(visited);
     nextVisited.add(fullPath);
-    const imported = await readFile(fullPath, "utf-8");
+    const imported = await readFile2(fullPath, "utf-8");
     parts.push(await resolveCssImportsAsync(imported, dirname3(fullPath), nextVisited));
     cursor = end;
   }
@@ -2591,7 +2591,7 @@ ${contents}` : contents, normalizePostcssModule = (mod) => {
   return parts.join("");
 }, compileStyleFileIfNeeded = async (filePath, config) => {
   if (!isPreprocessableStylePath(filePath)) {
-    const raw = await readFile(filePath, "utf-8");
+    const raw = await readFile2(filePath, "utf-8");
     const processed = await runPostcss(raw, filePath, config);
     return resolveCssImportsAsync(processed, dirname3(filePath), new Set([filePath]));
   }
@@ -3649,6 +3649,82 @@ var injectInlineCss = (headTag, css) => {
   return headTag.replace("</head>", `${styleBlock}</head>`);
 };
 
+// src/utils/spaRouteCss.ts
+import { readFile } from "fs/promises";
+var sideManifestCache = new Map;
+var readSideManifest = async (sideManifestPath) => {
+  const cached = sideManifestCache.get(sideManifestPath);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const raw = await readFile(sideManifestPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    const routes = Array.isArray(parsed) ? parsed : [];
+    sideManifestCache.set(sideManifestPath, routes);
+    return routes;
+  } catch {
+    sideManifestCache.set(sideManifestPath, []);
+    return [];
+  }
+};
+var compilePathToRegExp = (pattern) => {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  const withParams = escaped.replace(/:([a-zA-Z_$][a-zA-Z0-9_$]*)/g, "[^/]+").replace(/\\\*/g, ".*");
+  return new RegExp(`^${withParams}$`);
+};
+var routeMatchers = new Map;
+var matcherFor = (pattern) => {
+  const cached = routeMatchers.get(pattern);
+  if (cached !== undefined)
+    return cached;
+  const compiled = compilePathToRegExp(pattern);
+  routeMatchers.set(pattern, compiled);
+  return compiled;
+};
+var findMatchingRoute = (routes, pathname) => {
+  for (const route of routes) {
+    if (matcherFor(route.path).test(pathname))
+      return route;
+  }
+  return null;
+};
+var childCssCache = new Map;
+var readChildCss = async (cssPath) => {
+  if (!cssPath)
+    return "";
+  const cached = childCssCache.get(cssPath);
+  if (cached !== undefined)
+    return cached;
+  try {
+    const css = await readFile(cssPath, "utf-8");
+    childCssCache.set(cssPath, css);
+    return css;
+  } catch {
+    childCssCache.set(cssPath, "");
+    return "";
+  }
+};
+var resolveSpaChildCss = async (siblingJsPath, requestUrl) => {
+  if (!siblingJsPath || !requestUrl)
+    return "";
+  const sideManifestPath = siblingJsPath.replace(/\.js$/, ".spa.json");
+  if (sideManifestPath === siblingJsPath)
+    return "";
+  const routes = await readSideManifest(sideManifestPath);
+  if (routes.length === 0)
+    return "";
+  let pathname;
+  try {
+    pathname = new URL(requestUrl).pathname;
+  } catch {
+    pathname = requestUrl.split("?")[0] ?? requestUrl;
+  }
+  const matched = findMatchingRoute(routes, pathname);
+  if (!matched)
+    return "";
+  return readChildCss(matched.cssPath);
+};
+
 // src/core/islandPageContext.ts
 init_constants();
 var BOOTSTRAP_MANIFEST_KEY = "BootstrapClient";
@@ -4329,8 +4405,11 @@ var handleVuePageRequest = async (input) => {
   const userHeadTag = input.headTag ?? "<head></head>";
   const resolvedOptions = input;
   const resolvedPagePath = input.pagePath;
-  const siblingCss = await readSiblingCss(resolvedPagePath);
-  const resolvedHeadTag = injectInlineCss(userHeadTag, siblingCss);
+  const [siblingCss, spaChildCss] = await Promise.all([
+    readSiblingCss(resolvedPagePath),
+    resolveSpaChildCss(resolvedPagePath, input.request?.url)
+  ]);
+  const resolvedHeadTag = injectInlineCss(injectInlineCss(userHeadTag, siblingCss), spaChildCss);
   const maybeProps = input.props;
   const clientMode = input.client ?? "auto";
   const resolvedIndexPath = input.indexPath;
@@ -4824,5 +4903,5 @@ export {
   Image
 };
 
-//# debugId=11F1676B8E6878B264756E2164756E21
+//# debugId=18CB27AA3E1D0B6F64756E2164756E21
 //# sourceMappingURL=index.js.map