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

package/dist/cli/index-xf9sfr8a.js

@@ -0,0 +1,243 @@
+// @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
+
+// src/angular/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 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 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 findRoutesArrayDeclaration = (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 extractSitemapData = (dataLiteral) => {
+  for (const prop of dataLiteral.properties) {
+    const key = readPropertyKey(prop);
+    if (key !== "sitemap")
+      continue;
+    if (!lazyTypescript.isPropertyAssignment(prop))
+      continue;
+    const value = readStringLiteral(prop.initializer);
+    if (value === "exclude")
+      return true;
+  }
+  return false;
+};
+var joinSegments = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+};
+var extractRoutePaths = (routeArray, parentPath, parentExcluded, routes) => {
+  for (const element of routeArray.elements) {
+    if (!lazyTypescript.isObjectLiteralExpression(element))
+      continue;
+    let pathSegment = null;
+    let redirected = false;
+    let sitemapExcluded = parentExcluded;
+    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 === "redirectTo") {
+        redirected = true;
+      } else if (key === "data" && lazyTypescript.isObjectLiteralExpression(property.initializer)) {
+        if (extractSitemapData(property.initializer))
+          sitemapExcluded = true;
+      } else if (key === "children" && lazyTypescript.isArrayLiteralExpression(property.initializer)) {
+        childrenLiteral = property.initializer;
+      }
+    }
+    if (pathSegment === null)
+      continue;
+    const joined = joinSegments(parentPath, pathSegment);
+    if (childrenLiteral) {
+      extractRoutePaths(childrenLiteral, joined, sitemapExcluded, routes);
+      continue;
+    }
+    if (joined === "")
+      continue;
+    routes.push({
+      dynamic: pathHasDynamic(joined),
+      path: joined,
+      redirected,
+      sitemapExcluded
+    });
+  }
+};
+var findProvideRouterFirstArg = (sourceFile) => {
+  const result = { found: null };
+  const visit = (node) => {
+    if (result.found)
+      return;
+    if (lazyTypescript.isCallExpression(node) && lazyTypescript.isIdentifier(node.expression) && node.expression.text === "provideRouter") {
+      result.found = node.arguments[0] ?? null;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return result.found;
+};
+var findAppBaseHrefValue = (sourceFile) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    if (lazyTypescript.isObjectLiteralExpression(node)) {
+      let isAppBaseHref = false;
+      let value = null;
+      for (const property of node.properties) {
+        const key = readPropertyKey(property);
+        if (!key)
+          continue;
+        if (!lazyTypescript.isPropertyAssignment(property))
+          continue;
+        if (key === "provide" && lazyTypescript.isIdentifier(property.initializer) && property.initializer.text === "APP_BASE_HREF") {
+          isAppBaseHref = true;
+        } else if (key === "useValue") {
+          value = readStringLiteral(property.initializer);
+        }
+      }
+      if (isAppBaseHref && value !== null) {
+        found = value;
+        return;
+      }
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  lazyTypescript.forEachChild(sourceFile, visit);
+  return found;
+};
+var analyzeAngularSpaRouteFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("APP_BASE_HREF") || !source.includes("provideRouter")) {
+    return null;
+  }
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, lazyTypescript.ScriptKind.TS);
+  if (!importsSymbolFrom(sourceFile, "APP_BASE_HREF", "@angular/common"))
+    return null;
+  if (!importsSymbolFrom(sourceFile, "provideRouter", "@angular/router"))
+    return null;
+  const baseHref = findAppBaseHrefValue(sourceFile);
+  if (!baseHref)
+    return null;
+  const firstArg = findProvideRouterFirstArg(sourceFile);
+  if (!firstArg)
+    return null;
+  let routesArray = null;
+  if (lazyTypescript.isIdentifier(firstArg)) {
+    routesArray = findRoutesArrayDeclaration(sourceFile, firstArg.text);
+  } else if (lazyTypescript.isArrayLiteralExpression(firstArg)) {
+    routesArray = firstArg;
+  }
+  if (!routesArray)
+    return null;
+  const routes = [];
+  extractRoutePaths(routesArray, "", false, routes);
+  return {
+    baseHref,
+    routes,
+    sourceFile: filePath
+  };
+};
+var walkTsFiles = 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")
+      continue;
+    if (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(".d.ts")) {
+      files.push(full);
+    }
+  }
+  await Promise.all(directories.map((directory) => walkTsFiles(directory, files)));
+};
+var analyzeAngularSpaRoutes2 = async (angularDirectory) => {
+  if (!existsSync(angularDirectory))
+    return [];
+  const tsFiles = [];
+  await walkTsFiles(angularDirectory, tsFiles);
+  const pages = [];
+  await Promise.all(tsFiles.map(async (file) => {
+    try {
+      const page = await analyzeAngularSpaRouteFile(file);
+      if (page)
+        pages.push(page);
+    } catch (err) {
+      console.warn(`[sitemap] Angular SPA analysis failed for ${file}:`, err);
+    }
+  }));
+  return pages;
+};
+
+export { analyzeAngularSpaRoutes2 };