@edgeone/nuxt-pages 1.1.0-beta.3 → 1.1.0

package/dist/build/content/{static.js → module-inject.js}

@@ -5,13 +5,14 @@
       })();
     
 import {
-  addNitroBuildOutputConfig,
-  resetNitroConfig
-} from "../../esm-chunks/chunk-7X4RPD4I.js";
-import "../../esm-chunks/chunk-MONI3XWQ.js";
-import "../../esm-chunks/chunk-V2LFVP3C.js";
+  cleanupEdgeoneModule,
+  injectEdgeoneModule,
+  removeTempModule
+} from "../../esm-chunks/chunk-ZR3DYEBK.js";
+import "../../esm-chunks/chunk-VCJ5U4PV.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {
-  addNitroBuildOutputConfig,
-  resetNitroConfig
+  cleanupEdgeoneModule,
+  injectEdgeoneModule,
+  removeTempModule
 };

package/dist/build/content/server.js

@@ -8,8 +8,7 @@ import {
   RUN_CONFIG_FILE,
   copyNuxtServerCode,
   verifyNuxtHandlerDirStructure
-} from "../../esm-chunks/chunk-NJ4SUJNF.js";
-import "../../esm-chunks/chunk-V2LFVP3C.js";
+} from "../../esm-chunks/chunk-K5VT7O2H.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   RUN_CONFIG_FILE,

package/dist/build/functions/server.js

@@ -7,9 +7,8 @@
 import {
   createServerHandler,
   patchNitroHandler
-} from "../../esm-chunks/chunk-RNEZUAPL.js";
-import "../../esm-chunks/chunk-NJ4SUJNF.js";
-import "../../esm-chunks/chunk-V2LFVP3C.js";
+} from "../../esm-chunks/chunk-PJWA566S.js";
+import "../../esm-chunks/chunk-K5VT7O2H.js";
 import "../../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   createServerHandler,

package/dist/build/plugin-context.js

@@ -7,8 +7,9 @@
 import {
   PluginContext,
   SERVER_HANDLER_NAME
-} from "../esm-chunks/chunk-BZQMVWYQ.js";
-import "../esm-chunks/chunk-MONI3XWQ.js";
+} from "../esm-chunks/chunk-VDBASNGL.js";
+import "../esm-chunks/chunk-AZLY3JO2.js";
+import "../esm-chunks/chunk-VCJ5U4PV.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   PluginContext,

package/dist/build/routes.js

@@ -6,11 +6,14 @@
     
 import {
   createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
-} from "../esm-chunks/chunk-J25U56II.js";
-import "../esm-chunks/chunk-MONI3XWQ.js";
+  createNuxtPagesRouteMeta,
+  createNuxtRoutesMeta
+} from "../esm-chunks/chunk-3HA3DZ3G.js";
+import "../esm-chunks/chunk-AZLY3JO2.js";
+import "../esm-chunks/chunk-VCJ5U4PV.js";
 import "../esm-chunks/chunk-6BT4RYQJ.js";
 export {
   createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
+  createNuxtPagesRouteMeta,
+  createNuxtRoutesMeta
 };

package/dist/esm-chunks/chunk-3HA3DZ3G.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-AZLY3JO2.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
+};

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

@@ -0,0 +1,299 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_lib
+} from "./chunk-VCJ5U4PV.js";
+import {
+  __toESM
+} from "./chunk-6BT4RYQJ.js";
+
+// src/utils.ts
+var parser = __toESM(require_lib(), 1);
+import { createRequire } from "node:module";
+import * as fs from "fs";
+import * as path from "path";
+var require2 = createRequire(import.meta.url);
+var traverse = require2("@babel/traverse").default;
+function useStaticBuild(cwd) {
+  const edgeoneJsonPath = path.join(cwd, "edgeone.json");
+  let originalEdgeOneConfig = null;
+  let config = {};
+  if (!fs.existsSync(edgeoneJsonPath)) {
+    fs.writeFileSync(edgeoneJsonPath, "{}", "utf-8");
+    config = {};
+  } else {
+    try {
+      const fileContent = fs.readFileSync(edgeoneJsonPath, "utf-8");
+      originalEdgeOneConfig = fileContent;
+      config = JSON.parse(fileContent);
+    } catch (error) {
+      console.error("\u8BFB\u53D6 edgeone.json \u6587\u4EF6\u5931\u8D25:", error);
+      config = {};
+    }
+  }
+  config.buildCommand = "npm run generate";
+  try {
+    fs.writeFileSync(edgeoneJsonPath, JSON.stringify(config, null, 2), "utf-8");
+  } catch (error) {
+    console.error("\u5199\u5165 edgeone.json \u6587\u4EF6\u5931\u8D25:", error);
+    throw error;
+  }
+  return originalEdgeOneConfig;
+}
+function resetEdgeOneConfig(cwd, originalEdgeOneConfig) {
+  const edgeoneJsonPath = path.join(cwd, "edgeone.json");
+  try {
+    if (originalEdgeOneConfig == null) {
+      fs.rmSync(edgeoneJsonPath, { recursive: true, force: true });
+      return;
+    }
+    fs.writeFileSync(edgeoneJsonPath, originalEdgeOneConfig, "utf-8");
+  } catch (error) {
+    console.error("\u5199\u5165 edgeone.json \u6587\u4EF6\u5931\u8D25:", error);
+    throw error;
+  }
+}
+function astNodeToObject(node) {
+  if (node.type === "ObjectExpression") {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type === "ObjectProperty" && prop.key.type === "Identifier") {
+        obj[prop.key.name] = astNodeToObject(prop.value);
+      } else if (prop.type === "ObjectProperty" && prop.key.type === "StringLiteral") {
+        obj[prop.key.value] = astNodeToObject(prop.value);
+      }
+    }
+    return obj;
+  } else if (node.type === "ArrayExpression") {
+    return node.elements.map((element) => element ? astNodeToObject(element) : null);
+  } else if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral") {
+    return node.value;
+  } else if (node.type === "NullLiteral") {
+    return null;
+  } else {
+    console.warn(`Unsupported node type in astNodeToObject: ${node.type}`);
+    return void 0;
+  }
+}
+function getRouteRulesWithAST(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let routeRulesObject = null;
+    traverse(ast, {
+      // We're looking for a function call
+      CallExpression(path2) {
+        const { node } = path2;
+        if (node.callee.type === "Identifier" && node.callee.name === "defineNuxtConfig") {
+          if (node.arguments.length > 0 && node.arguments[0].type === "ObjectExpression") {
+            const configObjectNode = node.arguments[0];
+            for (const prop of configObjectNode.properties) {
+              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "routeRules") {
+                routeRulesObject = astNodeToObject(prop.value);
+                path2.stop();
+                break;
+              }
+            }
+          }
+        }
+      }
+    });
+    return routeRulesObject;
+  } catch (e) {
+    console.error("AST parsing or traversal failed:", e);
+    return null;
+  }
+}
+function getPrerenderRoutesWithAST(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let prerenderRoutes = [];
+    traverse(ast, {
+      // We're looking for a function call
+      CallExpression(path2) {
+        const { node } = path2;
+        if (node.callee.type === "Identifier" && node.callee.name === "defineNuxtConfig") {
+          if (node.arguments.length > 0 && node.arguments[0].type === "ObjectExpression") {
+            const configObjectNode = node.arguments[0];
+            for (const prop of configObjectNode.properties) {
+              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "nitro" && prop.value.type === "ObjectExpression") {
+                for (const nitroProp of prop.value.properties) {
+                  if (nitroProp.type === "ObjectProperty" && nitroProp.key.type === "Identifier" && nitroProp.key.name === "prerender" && nitroProp.value.type === "ObjectExpression") {
+                    for (const prerenderProp of nitroProp.value.properties) {
+                      if (prerenderProp.type === "ObjectProperty" && prerenderProp.key.type === "Identifier" && prerenderProp.key.name === "routes" && prerenderProp.value.type === "ArrayExpression") {
+                        const routesArray = astNodeToObject(prerenderProp.value);
+                        if (Array.isArray(routesArray)) {
+                          prerenderRoutes = routesArray.filter((route) => typeof route === "string");
+                        }
+                        path2.stop();
+                        return;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+    return prerenderRoutes;
+  } catch (e) {
+    console.error("AST parsing or traversal failed:", e);
+    return [];
+  }
+}
+function getRoutesArrayWithAST(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let routesArray = null;
+    traverse(ast, {
+      // We're looking for a variable declaration
+      VariableDeclaration(path2) {
+        const { node } = path2;
+        for (const declarator of node.declarations) {
+          if (declarator.type === "VariableDeclarator" && declarator.id.type === "Identifier" && declarator.id.name === "_routes") {
+            if (declarator.init && declarator.init.type === "ArrayExpression") {
+              routesArray = astNodeToObjectForRoutes(declarator.init);
+              path2.stop();
+              break;
+            }
+          }
+        }
+      }
+    });
+    return routesArray;
+  } catch (e) {
+    console.error("AST parsing or traversal failed:", e);
+    return null;
+  }
+}
+function getHandlersArrayWithAST(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let handlersArray = [];
+    traverse(ast, {
+      // We're looking for a variable declaration
+      VariableDeclaration(path2) {
+        const { node } = path2;
+        for (const declarator of node.declarations) {
+          if (declarator.type === "VariableDeclarator" && declarator.id.type === "Identifier" && declarator.id.name === "handlers") {
+            if (declarator.init && declarator.init.type === "ArrayExpression") {
+              handlersArray = astNodeToObjectForRoutes(declarator.init);
+              path2.stop();
+              break;
+            }
+          }
+        }
+      }
+    });
+    return handlersArray;
+  } catch (e) {
+    console.error("AST parsing or traversal failed:", e);
+    return [];
+  }
+}
+function astNodeToObjectForRoutes(node) {
+  if (node.type === "ObjectExpression") {
+    const obj = {};
+    for (const prop of node.properties) {
+      if (prop.type === "ObjectProperty") {
+        let key;
+        if (prop.key.type === "Identifier") {
+          key = prop.key.name;
+        } else if (prop.key.type === "StringLiteral") {
+          key = prop.key.value;
+        } else {
+          continue;
+        }
+        if (prop.value.type === "ArrowFunctionExpression") {
+          if (prop.value.body.type === "CallExpression" && prop.value.body.callee.type === "Import" && prop.value.body.arguments.length > 0 && prop.value.body.arguments[0].type === "StringLiteral") {
+            const importPath = prop.value.body.arguments[0].value;
+            obj[key] = `() => import('${importPath}')`;
+          } else {
+            obj[key] = "[Function]";
+          }
+        } else {
+          obj[key] = astNodeToObjectForRoutes(prop.value);
+        }
+      }
+    }
+    return obj;
+  } else if (node.type === "ArrayExpression") {
+    return node.elements.map((element) => element ? astNodeToObjectForRoutes(element) : null);
+  } else if (node.type === "StringLiteral" || node.type === "NumericLiteral" || node.type === "BooleanLiteral") {
+    return node.value;
+  } else if (node.type === "NullLiteral") {
+    return null;
+  } else {
+    return `[${node.type}]`;
+  }
+}
+function getModulesWithAST(code) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let modulesArray = [];
+    traverse(ast, {
+      CallExpression(path2) {
+        const { node } = path2;
+        if (node.callee.type === "Identifier" && node.callee.name === "defineNuxtConfig") {
+          if (node.arguments.length > 0 && node.arguments[0].type === "ObjectExpression") {
+            const configObject = node.arguments[0];
+            for (const prop of configObject.properties) {
+              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "modules") {
+                if (prop.value.type === "ArrayExpression") {
+                  for (const element of prop.value.elements) {
+                    if (element) {
+                      if (element.type === "StringLiteral") {
+                        modulesArray.push(element.value);
+                      } else if (element.type === "ArrayExpression" && element.elements.length > 0) {
+                        const firstElement = element.elements[0];
+                        if (firstElement && firstElement.type === "StringLiteral") {
+                          modulesArray.push(firstElement.value);
+                        }
+                      }
+                    }
+                  }
+                }
+                path2.stop();
+                return;
+              }
+            }
+          }
+        }
+      }
+    });
+    return modulesArray;
+  } catch (e) {
+    console.error("AST parsing or traversal failed:", e);
+    return [];
+  }
+}
+
+export {
+  useStaticBuild,
+  resetEdgeOneConfig,
+  getRouteRulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRoutesArrayWithAST,
+  getHandlersArrayWithAST,
+  getModulesWithAST
+};