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

package/dist/cli/{index-9dzdbbfc.js → index-kx2d067c.js}

@@ -10,14 +10,12 @@ import {
   resolveProjectName
 } from "./index-71gchbzt.js";
 import {
-  createIslandRegistryDefinitionPlugin,
-  createBunStringRawUnicodePlugin,
   finalizeAbsoluteMobileCompatibilityBuild,
   createAbsoluteMobileRouteMetadataPlugin,
   createElysiaOpenApiTypeboxPlugin,
   createOptionalPeerPlugin,
   resolveServerBundleExternals
-} from "./index-zyd80s3h.js";
+} from "./index-js2hksgv.js";
 import {
   normalizeAbsoluteMobileConfig2
 } from "./index-t7yf3vxs.js";
@@ -27,9 +25,13 @@ import {
 import {
   loadConfig
 } from "./index-wk0pyxrg.js";
+import {
+  createIslandRegistryDefinitionPlugin,
+  createBunStringRawUnicodePlugin
+} from "./index-42xjh6gg.js";
 import {
   loadIslandRegistryBuildInfo
-} from "./index-yd672jyq.js";
+} from "./index-w6xsk8cv.js";
 import {
   stripStringsAndComments
 } from "./index-prs14ys9.js";
@@ -184,7 +186,7 @@ var jsxDevRuntimeCompatPath = resolveJsxDevRuntimeCompatPath();
 var prerenderStaticPages = async (outputPath, prerenderPort, resolvedOutdir, staticConfig, absoluteVersion, configPath) => {
   const prerenderStart = performance.now();
   process.stdout.write(cliTag("\x1B[36m", "Pre-rendering static pages"));
-  const { prerenderWithServer } = await import("./prerender-010z771p.js");
+  const { prerenderWithServer } = await import("./prerender-w65xp6h8.js");
   try {
     killStaleProcesses(prerenderPort);
     const result = await prerenderWithServer(outputPath, prerenderPort, resolvedOutdir, staticConfig, {
@@ -495,7 +497,7 @@ var start2 = async (serverEntry, outdir, configPath, options = {}) => {
       angularServerVendorPaths[specifier] = relPath.startsWith(".") ? relPath : `./${relPath}`;
     }
     if (Object.keys(angularServerVendorPaths).length > 0) {
-      const { rewriteImports } = await import("./rewriteImports-z6629aww.js");
+      const { rewriteImports } = await import("./rewriteImports-np2d2kvc.js");
       await rewriteImports([outputPath], angularServerVendorPaths);
     }
   }

package/dist/cli/index-pb31zan6.js

@@ -0,0 +1,9 @@
+// @bun
+// src/utils/generatedDir.ts
+import { join } from "path";
+var GENERATED_DIR_NAME = "generated";
+var ABSOLUTE_CACHE_DIR_NAME = ".absolutejs";
+var getFrameworkGeneratedDir2 = (framework, projectRoot = process.cwd()) => join(getGeneratedRoot2(projectRoot), framework);
+var getGeneratedRoot2 = (projectRoot = process.cwd()) => join(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME);
+
+export { getFrameworkGeneratedDir2, getGeneratedRoot2 };

package/dist/cli/index-sq0478b0.js

@@ -0,0 +1,281 @@
+// @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
+
+// src/vue/staticAnalyzeSpaRoutes.ts
+import { existsSync, promises as fs } from "fs";
+import { join } from "path";
+var DYNAMIC_SEGMENT_PATTERN = /^[:*]/;
+var pathHasDynamic = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN.test(seg) || seg === "**");
+var readStringLiteral = (expression) => {
+  if (lazyTypescript.isStringLiteral(expression) || lazyTypescript.isNoSubstitutionTemplateLiteral(expression)) {
+    return expression.text;
+  }
+  return null;
+};
+var readPropertyKey = (property) => {
+  if (lazyTypescript.isPropertyAssignment(property)) {
+    const { name } = property;
+    if (lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name))
+      return name.text;
+  }
+  if (lazyTypescript.isShorthandPropertyAssignment(property)) {
+    return property.name.text;
+  }
+  return null;
+};
+var importsSymbolFrom = (sourceFile, localName, moduleSpecifier) => {
+  for (const statement of sourceFile.statements) {
+    if (!lazyTypescript.isImportDeclaration(statement))
+      continue;
+    if (!lazyTypescript.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (statement.moduleSpecifier.text !== moduleSpecifier)
+      continue;
+    const named = statement.importClause?.namedBindings;
+    if (!named || !lazyTypescript.isNamedImports(named))
+      continue;
+    for (const element of named.elements) {
+      if (element.name.text === localName)
+        return true;
+    }
+  }
+  return false;
+};
+var findVariableArrayDeclaration = (sourceFile, identifierName) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (lazyTypescript.isVariableDeclaration(node) && lazyTypescript.isIdentifier(node.name) && node.name.text === identifierName && node.initializer && lazyTypescript.isArrayLiteralExpression(node.initializer)) {
+      found = node.initializer;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return found;
+};
+var joinSegments = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+};
+var extractRouteEntries = (routeArray, parentPath, routes) => {
+  for (const element of routeArray.elements) {
+    if (!lazyTypescript.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = false;
+    let alias = null;
+    let childrenLiteral = null;
+    for (const property of element.properties) {
+      const key = readPropertyKey(property);
+      if (!key)
+        continue;
+      if (!lazyTypescript.isPropertyAssignment(property))
+        continue;
+      if (key === "path") {
+        pathSegment = readStringLiteral(property.initializer);
+      } else if (key === "alias") {
+        alias = readStringLiteral(property.initializer);
+      } else if (key === "redirect") {
+        redirected = true;
+      } else if (key === "children" && lazyTypescript.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      } else if (key === "meta" && lazyTypescript.isObjectLiteralExpression(property.initializer)) {
+        for (const metaProp of property.initializer.properties) {
+          const metaKey = readPropertyKey(metaProp);
+          if (metaKey !== "sitemap")
+            continue;
+          if (!lazyTypescript.isPropertyAssignment(metaProp))
+            continue;
+          const value = readStringLiteral(metaProp.initializer);
+          if (value === "exclude")
+            sitemapExcluded = true;
+        }
+      }
+    }
+    if (pathSegment === null)
+      continue;
+    const joined = joinSegments(parentPath, pathSegment);
+    if (childrenLiteral) {
+      extractRouteEntries(childrenLiteral, joined, routes);
+      continue;
+    }
+    if (joined === "")
+      continue;
+    routes.push({
+      dynamic: pathHasDynamic(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+    if (alias) {
+      routes.push({
+        dynamic: pathHasDynamic(alias),
+        path: alias,
+        redirected: false,
+        sitemapExcluded: true
+      });
+    }
+  }
+};
+var findDefineRoutesArray = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "defineRoutes") {
+      const [routesArgument] = node.arguments;
+      if (!routesArgument || !lazyTypescript.isArrayLiteralExpression(routesArgument))
+        return;
+      found = routesArgument;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return found;
+};
+var inferBaseHref = (routes) => {
+  const firstSegments = routes.map((route) => route.path.split("/").filter(Boolean)[0]).filter((segment) => Boolean(segment));
+  const [first] = firstSegments;
+  if (!first || firstSegments.some((segment) => segment !== first))
+    return "/";
+  return `/${first}/`;
+};
+var findCreateRouterCall = (sourceFile) => {
+  const result = { found: null };
+  const visit = (node) => {
+    if (result.found)
+      return;
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "createRouter") {
+      result.found = node;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return result.found;
+};
+var findCreateWebHistoryBase = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && (node.expression.text === "createWebHistory" || node.expression.text === "createWebHashHistory")) {
+      const [baseArg] = node.arguments;
+      if (baseArg) {
+        const text = readStringLiteral(baseArg);
+        if (text !== null) {
+          found = text;
+          return;
+        }
+      } else {
+        found = "/";
+        return;
+      }
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return found;
+};
+var readRoutesFromCreateRouterOptions = (sourceFile, optionsExpr) => {
+  if (!lazyTypescript.isObjectLiteralExpression(optionsExpr))
+    return null;
+  for (const property of optionsExpr.properties) {
+    const key = readPropertyKey(property);
+    if (key !== "routes")
+      continue;
+    if (lazyTypescript.isShorthandPropertyAssignment(property)) {
+      return findVariableArrayDeclaration(sourceFile, property.name.text);
+    }
+    if (!lazyTypescript.isPropertyAssignment(property))
+      continue;
+    if (lazyTypescript.isArrayLiteralExpression(property.initializer)) {
+      return property.initializer;
+    }
+    if (lazyTypescript.isIdentifier(property.initializer)) {
+      return findVariableArrayDeclaration(sourceFile, property.initializer.text);
+    }
+  }
+  return null;
+};
+var extractScriptBlocksFromVueSfc = (source) => [...source.matchAll(/<script\b[^>]*>([\s\S]*?)<\/script>/gi)].map((match) => match[1] ?? "");
+var analyzeVueScriptSource = (filePath, analysisSource) => {
+  if (!analysisSource.includes("createRouter") && !analysisSource.includes("defineRoutes"))
+    return null;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, analysisSource, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TS);
+  const defineRoutesArray = findDefineRoutesArray(sourceFile);
+  const call = importsSymbolFrom(sourceFile, "createRouter", "vue-router") ? findCreateRouterCall(sourceFile) : null;
+  const [optionsArg] = call?.arguments ?? [];
+  const routesArray = defineRoutesArray ?? (optionsArg ? readRoutesFromCreateRouterOptions(sourceFile, optionsArg) : null);
+  if (!routesArray)
+    return null;
+  const routes = [];
+  extractRouteEntries(routesArray, "", routes);
+  const base = findCreateWebHistoryBase(sourceFile) ?? inferBaseHref(routes);
+  const baseHref = base.endsWith("/") ? base : `${base}/`;
+  const host = { baseHref, routes, sourceFile: filePath };
+  return host;
+};
+var analyzeVueSpaRouteFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  const scripts = filePath.endsWith(".vue") ? extractScriptBlocksFromVueSfc(source) : [source];
+  for (const script of scripts) {
+    const host = analyzeVueScriptSource(filePath, script);
+    if (host)
+      return host;
+  }
+  return null;
+};
+var walkSourceFiles = async (dir, files) => {
+  let items;
+  try {
+    items = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const directories = [];
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join(dir, item.name);
+    if (item.isDirectory()) {
+      directories.push(full);
+    } else if (item.isFile() && (item.name.endsWith(".ts") || item.name.endsWith(".js") || item.name.endsWith(".vue")) && !item.name.endsWith(".d.ts")) {
+      files.push(full);
+    }
+  }
+  await Promise.all(directories.map((directory) => walkSourceFiles(directory, files)));
+};
+var analyzeVueSpaRoutes2 = async (vueDirectory) => {
+  if (!existsSync(vueDirectory))
+    return [];
+  const files = [];
+  await walkSourceFiles(vueDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file) => {
+    try {
+      const host = await analyzeVueSpaRouteFile(file);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] Vue SPA analysis failed for ${file}:`, err);
+    }
+  }));
+  return hosts;
+};
+
+export { analyzeVueSpaRoutes2 };

package/dist/cli/index-va274tsf.js

@@ -0,0 +1,7 @@
+// @bun
+// src/utils/startupTimings.ts
+var isTruthyFlag = (value) => value === "1" || value === "true";
+var devProfileEnabled = isTruthyFlag(process.env.ABSOLUTE_DEV_PROFILE);
+var startupTimingsEnabled = devProfileEnabled || isTruthyFlag(process.env.ABSOLUTE_STARTUP_TIMINGS);
+
+export { devProfileEnabled };

package/dist/cli/{index-yd672jyq.js → index-w6xsk8cv.js}

@@ -4,8 +4,11 @@ import {
 } from "./index-4j1twret.js";
 
 // src/core/islandManifest.ts
+var ISLAND_BOOTSTRAP_MANIFEST_KEY = "AbsoluteIslandBootstrap";
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1);
 var getIslandManifestKey = (framework, component) => `Island${toIslandFrameworkSegment(framework)}${component}`;
+var ISLAND_STYLE_PREFIX = "IslandStyle";
+var getIslandStyleManifestKey = (framework, component) => `${ISLAND_STYLE_PREFIX}${toIslandFrameworkSegment(framework)}${component}`;
 
 // src/build/islandEntries.ts
 import { mkdirSync, rmSync, statSync, writeFileSync } from "fs";
@@ -251,4 +254,4 @@ var loadIslandRegistryBuildInfo = async (registryPath) => {
   };
 };
 
-export { getIslandManifestKey, resolveIslandSourceFile, loadIslandRegistryBuildInfo };
+export { ISLAND_BOOTSTRAP_MANIFEST_KEY, getIslandManifestKey, getIslandStyleManifestKey, resolveIslandSourceFile, loadIslandRegistryBuildInfo };