@edgeone/nuxt-pages 1.0.0-beta.1 → 1.0.0-beta.2

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

@@ -5,13 +5,14 @@
       })();
     
 import {
-  addNitroBuildOutputConfig,
-  resetNitroConfig
-} from "../../esm-chunks/chunk-7RNB5RB6.js";
-import "../../esm-chunks/chunk-5JK44IEA.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-TP3RAVPL.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-L23O2KDO.js";
-import "../../esm-chunks/chunk-TP3RAVPL.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-Y3YAV6NZ.js";
-import "../esm-chunks/chunk-5JK44IEA.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

@@ -8,8 +8,9 @@ import {
   createNuxtApiRoutesMeta,
   createNuxtPagesRouteMeta,
   createNuxtRoutesMeta
-} from "../esm-chunks/chunk-UFRAZNP3.js";
-import "../esm-chunks/chunk-5JK44IEA.js";
+} 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,

package/dist/esm-chunks/{chunk-UFRAZNP3.js → chunk-3HA3DZ3G.js}

@@ -7,7 +7,7 @@
 import {
   getHandlersArrayWithAST,
   getRouteRulesWithAST
-} from "./chunk-5JK44IEA.js";
+} from "./chunk-AZLY3JO2.js";
 
 // src/build/routes.ts
 import * as fs from "fs";

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
+};