@edgeone/nuxt-pages 1.0.0-beta.1

package/dist/esm-chunks/chunk-UFRAZNP3.js

@@ -0,0 +1,261 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getHandlersArrayWithAST,
+  getRouteRulesWithAST
+} from "./chunk-5JK44IEA.js";
+
+// src/build/routes.ts
+import * as fs from "fs";
+import * as path from "path";
+var CONFIG_VERSION = 3;
+var CONFIG_FILE_NAME = "config.json";
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeRoutePath(p) {
+  if (!p) return "/";
+  const clean = p.split("?")[0];
+  if (clean === "" || clean === "/") return "/";
+  return clean.startsWith("/") ? clean.replace(/\/+$/, "") : `/${clean.replace(/\/+$/, "")}`;
+}
+function ensureServerHandlerDir() {
+  const edgeOneDir = path.join(process.cwd(), ".edgeone");
+  const serverHandlerDir = path.join(edgeOneDir, "cloud-functions", "ssr-node");
+  if (!fs.existsSync(edgeOneDir)) fs.mkdirSync(edgeOneDir, { recursive: true });
+  if (!fs.existsSync(serverHandlerDir)) fs.mkdirSync(serverHandlerDir, { recursive: true });
+  return serverHandlerDir;
+}
+function getConfigPath() {
+  return path.join(ensureServerHandlerDir(), CONFIG_FILE_NAME);
+}
+function writeConfig(config) {
+  const configPath = getConfigPath();
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+function normalizeHeaders(headers) {
+  if (!headers || typeof headers !== "object") return null;
+  const out = {};
+  for (const [k, v] of Object.entries(headers)) {
+    if (typeof k !== "string" || !k) continue;
+    if (typeof v === "string") out[k] = v;
+    else if (typeof v === "number" || typeof v === "boolean") out[k] = String(v);
+  }
+  return Object.keys(out).length ? out : null;
+}
+function extractInlineRuntimeConfigFromNitroMjs(code) {
+  if (!code || typeof code !== "string") return null;
+  const idx = code.search(/\b_inlineRuntimeConfig\b\s*=\s*\{/);
+  if (idx === -1) return null;
+  const braceStart = code.indexOf("{", idx);
+  if (braceStart === -1) return null;
+  let depth = 0;
+  let inStr = false;
+  let quote = "";
+  let escaped = false;
+  let end = -1;
+  for (let i = braceStart; i < code.length; i++) {
+    const ch = code[i];
+    if (inStr) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (ch === quote) {
+        inStr = false;
+        quote = "";
+      }
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inStr = true;
+      quote = ch;
+      continue;
+    }
+    if (ch === "{") {
+      depth++;
+      continue;
+    }
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        end = i;
+        break;
+      }
+      continue;
+    }
+  }
+  if (end === -1) return null;
+  const objStr = code.slice(braceStart, end + 1);
+  try {
+    return JSON.parse(objStr);
+  } catch {
+    return null;
+  }
+}
+async function getRouteRulesFromNitroInlineRuntimeConfig(ctx) {
+  const nitroMjsPath = resolveNitroMjsPath();
+  if (!nitroMjsPath) return null;
+  try {
+    const nitroContent = fs.readFileSync(nitroMjsPath, "utf-8");
+    const inlineCfg = extractInlineRuntimeConfigFromNitroMjs(nitroContent);
+    const rr = inlineCfg?.nitro?.routeRules;
+    if (rr && typeof rr === "object") return rr;
+  } catch {
+  }
+  return null;
+}
+async function getRouteRulesFromBuildOutput(ctx) {
+  const fromNitroMjs = await getRouteRulesFromNitroInlineRuntimeConfig(ctx);
+  if (fromNitroMjs) return fromNitroMjs;
+  try {
+    if (typeof ctx?.getNuxtConfig === "function") {
+      const cfg = await ctx.getNuxtConfig();
+      const parsed = getRouteRulesWithAST(cfg || "");
+      if (parsed && typeof parsed === "object") return parsed;
+    }
+  } catch {
+  }
+  return null;
+}
+async function buildHeadersRoutes(ctx) {
+  const routeRules = await getRouteRulesFromBuildOutput(ctx);
+  if (!routeRules || typeof routeRules !== "object") return [];
+  const out = [];
+  for (const [srcRaw, rule] of Object.entries(routeRules)) {
+    const headers = normalizeHeaders(rule?.headers);
+    if (!headers) continue;
+    const src = typeof srcRaw === "string" && srcRaw.startsWith("^") ? srcRaw : normalizeRoutePath(String(srcRaw)).replace(/\*\*/g, "(.*)");
+    out.push({ src, headers });
+  }
+  return out;
+}
+async function buildStage1Routes(ctx) {
+  const routes = [];
+  routes.push({ src: "^/([^.]+[^/.])$", dest: "/$1/", continue: true });
+  routes.push(...await buildHeadersRoutes(ctx));
+  routes.push({ handle: "filesystem" });
+  return routes;
+}
+function resolveNitroMjsPath() {
+  const edgeOneDir = path.join(process.cwd(), ".edgeone");
+  const defaultNitroPath = path.join(edgeOneDir, "cloud-functions", "ssr-node", "chunks", "nitro", "nitro.mjs");
+  const fallbackNitroPath = path.join(edgeOneDir, "cloud-functions", "ssr-node", "chunks", "_", "nitro.mjs");
+  const nitroPath = fs.existsSync(defaultNitroPath) ? defaultNitroPath : fallbackNitroPath;
+  return fs.existsSync(nitroPath) ? nitroPath : null;
+}
+async function buildExplicitApiRoutes(_ctx) {
+  const nitroPath = resolveNitroMjsPath();
+  if (!nitroPath) {
+    console.error("Nitro entry(nitro.mjs) not found");
+    return [];
+  }
+  try {
+    const nitroContent = fs.readFileSync(nitroPath, "utf-8");
+    const handlersArray = getHandlersArrayWithAST(nitroContent);
+    if (!Array.isArray(handlersArray)) return [];
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    for (const h of handlersArray) {
+      const route = typeof h?.route === "string" ? String(h.route) : "";
+      if (!route) continue;
+      const normalized = normalizeRoutePath(route);
+      if (!normalized.startsWith("/api")) continue;
+      const rule = route.startsWith("^") ? { src: route } : nuxtRoutePathToRouteRule(normalized);
+      const src = rule?.src;
+      if (!src || seen.has(src)) continue;
+      seen.add(src);
+      out.push(rule);
+    }
+    out.sort((a, b) => String(b.src || "").length - String(a.src || "").length);
+    return out;
+  } catch (error) {
+    console.error("Error parsing nitro.mjs for API routes:", error);
+    return [];
+  }
+}
+function isCatchAllLikeRoutePath(p) {
+  const clean = normalizeRoutePath(p);
+  return clean.includes("(.*)") || clean.includes(".*") || clean.includes(":all");
+}
+function nuxtRoutePathToRouteRule(routePath) {
+  const p = normalizeRoutePath(routePath);
+  if (!p.startsWith("/")) return null;
+  if (p === "/") return { src: "^/$" };
+  const parts = p.split("/").filter(Boolean);
+  const srcParts = [];
+  for (const seg of parts) {
+    if (seg === "*" || seg === "**") {
+      srcParts.push("(.*)");
+      continue;
+    }
+    if (seg.startsWith(":")) {
+      const m = seg.match(/^:([A-Za-z_$][\w$]*)(?:\((.*)\))?(\*)?$/);
+      const inner = m ? m[2] : null;
+      const star = m ? m[3] : null;
+      if (star || inner === ".*") {
+        srcParts.push("(.*)");
+        continue;
+      }
+      if (!inner || inner.trim() === "") {
+        srcParts.push("([^/]+)");
+        continue;
+      }
+      srcParts.push(`((?:${inner}))`);
+      continue;
+    }
+    srcParts.push(escapeRegExp(seg));
+  }
+  const srcBody = srcParts.join("/");
+  return { src: `^/${srcBody}$` };
+}
+async function buildExplicitSsrAndSwrRoutes(ctx) {
+  const routesManifest = await ctx.getRoutesManifest();
+  const manifestRoutes = Array.isArray(routesManifest?.routes) ? routesManifest.routes : [];
+  const seen = /* @__PURE__ */ new Set();
+  const tmp = [];
+  for (const r of manifestRoutes) {
+    const p = typeof r?.path === "string" ? r.path : "";
+    if (!p) continue;
+    const normalized = normalizeRoutePath(p);
+    if (normalized.startsWith("/api")) continue;
+    const isSsr = r?.ssr === true;
+    const isSwr = r?.swr !== false && r?.swr !== void 0 && r?.swr !== null;
+    if (!isSsr && !isSwr) continue;
+    const rule = nuxtRoutePathToRouteRule(normalized);
+    const src = rule?.src;
+    if (!src || seen.has(src)) continue;
+    seen.add(src);
+    const score = (isCatchAllLikeRoutePath(normalized) ? -1e4 : 0) + normalized.split("/").length;
+    tmp.push({ score, rule });
+  }
+  tmp.sort((a, b) => b.score - a.score);
+  return tmp.map((x) => x.rule);
+}
+var createNuxtRoutesMeta = async (ctx) => {
+  const routes = await buildStage1Routes(ctx);
+  routes.push(...await buildExplicitApiRoutes(ctx));
+  routes.push(...await buildExplicitSsrAndSwrRoutes(ctx));
+  routes.push({ src: "^/(.*)$" });
+  writeConfig({ version: CONFIG_VERSION, routes });
+};
+var createNuxtPagesRouteMeta = async (ctx) => {
+  await createNuxtRoutesMeta(ctx);
+};
+var createNuxtApiRoutesMeta = async (ctx) => {
+  await createNuxtRoutesMeta(ctx);
+};
+
+export {
+  createNuxtRoutesMeta,
+  createNuxtPagesRouteMeta,
+  createNuxtApiRoutesMeta
+};