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

package/dist/esm-chunks/{chunk-RNEZUAPL.js → chunk-PJWA566S.js}

@@ -7,7 +7,7 @@
 import {
   require_out,
   verifyNuxtHandlerDirStructure
-} from "./chunk-NJ4SUJNF.js";
+} from "./chunk-K5VT7O2H.js";
 import {
   __require,
   __toESM
@@ -101,10 +101,10 @@ var createServerHandler = async (ctx) => {
 };
 async function patchNitroHandler(ctx) {
   const fs = __require("fs");
-  const defaultNitroMjsPath = ".edgeone/server-handler/chunks/nitro/nitro.mjs";
-  const fallbackNitroMjsPath = ".edgeone/server-handler/chunks/_/nitro.mjs";
+  const defaultNitroMjsPath = join(ctx.serverHandlerDir, "chunks", "nitro", "nitro.mjs");
+  const fallbackNitroMjsPath = join(ctx.serverHandlerDir, "chunks", "_", "nitro.mjs");
   const nitroMjsPath = fs.existsSync(defaultNitroMjsPath) ? defaultNitroMjsPath : fallbackNitroMjsPath;
-  const handlerTmplPath = ".edgeone/server-handler/handler.js";
+  const handlerTmplPath = join(ctx.serverHandlerRootDir, "handler.js");
   const nitroCode = fs.readFileSync(nitroMjsPath, "utf-8");
   const match = nitroCode.match(/export\s*\{[^}]*\buseNitroApp\s+as\s+([A-Za-z_$][\w$]*)/) ?? nitroCode.match(/\buseNitroApp\s+as\s+([A-Za-z_$][\w$]*)\b/);
   if (!match) throw new Error("Cannot find useNitroApp export symbol in nitro.mjs!");

package/dist/esm-chunks/{chunk-MONI3XWQ.js → chunk-VCJ5U4PV.js}

@@ -5,8 +5,7 @@
       })();
     
 import {
-  __commonJS,
-  __toESM
+  __commonJS
 } from "./chunk-6BT4RYQJ.js";
 
 // node_modules/@babel/parser/lib/index.js
@@ -1557,12 +1556,12 @@ var require_lib = __commonJS({
       }
     };
     var ScopeHandler = class {
-      constructor(parser2, inModule) {
+      constructor(parser, inModule) {
         this.parser = void 0;
         this.scopeStack = [];
         this.inModule = void 0;
         this.undefinedExports = /* @__PURE__ */ new Map();
-        this.parser = parser2;
+        this.parser = parser;
         this.inModule = inModule;
       }
       get inTopLevel() {
@@ -3103,14 +3102,14 @@ var require_lib = __commonJS({
         super.checkParams(node, false, true);
         this.scope.exit();
       }
-      forwardNoArrowParamsConversionAt(node, parse3) {
+      forwardNoArrowParamsConversionAt(node, parse2) {
         let result;
         if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
           this.state.noArrowParamsConversionAt.push(this.state.start);
-          result = parse3();
+          result = parse2();
           this.state.noArrowParamsConversionAt.pop();
         } else {
-          result = parse3();
+          result = parse2();
         }
         return result;
       }
@@ -6692,11 +6691,11 @@ var require_lib = __commonJS({
       }
     };
     var ClassScopeHandler = class {
-      constructor(parser2) {
+      constructor(parser) {
         this.parser = void 0;
         this.stack = [];
         this.undefinedPrivateNames = /* @__PURE__ */ new Map();
-        this.parser = parser2;
+        this.parser = parser;
       }
       current() {
         return this.stack[this.stack.length - 1];
@@ -6789,10 +6788,10 @@ var require_lib = __commonJS({
       }
     };
     var ExpressionScopeHandler = class {
-      constructor(parser2) {
+      constructor(parser) {
         this.parser = void 0;
         this.stack = [new ExpressionScope()];
-        this.parser = parser2;
+        this.parser = parser;
       }
       enter(scope) {
         this.stack.push(scope);
@@ -7105,13 +7104,13 @@ var require_lib = __commonJS({
       }
     };
     var Node = class {
-      constructor(parser2, pos, loc) {
+      constructor(parser, pos, loc) {
         this.type = "";
         this.start = pos;
         this.end = 0;
         this.loc = new SourceLocation(loc);
-        if ((parser2 == null ? void 0 : parser2.optionFlags) & 128) this.range = [pos, 0];
-        if (parser2 != null && parser2.filename) this.loc.filename = parser2.filename;
+        if ((parser == null ? void 0 : parser.optionFlags) & 128) this.range = [pos, 0];
+        if (parser != null && parser.filename) this.loc.filename = parser.filename;
       }
     };
     var NodePrototype = Node.prototype;
@@ -14492,18 +14491,18 @@ var require_lib = __commonJS({
         return file;
       }
     };
-    function parse2(input, options) {
+    function parse(input, options) {
       var _options;
       if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
         options = Object.assign({}, options);
         try {
           options.sourceType = "module";
-          const parser2 = getParser(options, input);
-          const ast = parser2.parse();
-          if (parser2.sawUnambiguousESM) {
+          const parser = getParser(options, input);
+          const ast = parser.parse();
+          if (parser.sawUnambiguousESM) {
             return ast;
           }
-          if (parser2.ambiguousScriptDifferentAst) {
+          if (parser.ambiguousScriptDifferentAst) {
             try {
               options.sourceType = "script";
               return getParser(options, input).parse();
@@ -14526,11 +14525,11 @@ var require_lib = __commonJS({
       }
     }
     function parseExpression(input, options) {
-      const parser2 = getParser(options, input);
-      if (parser2.options.strictMode) {
-        parser2.state.strict = true;
+      const parser = getParser(options, input);
+      if (parser.options.strictMode) {
+        parser.state.strict = true;
       }
-      return parser2.getExpression();
+      return parser.getExpression();
     }
     function generateExportedTokenTypes(internalTokenTypes) {
       const tokenTypes2 = {};
@@ -14579,528 +14578,12 @@ var require_lib = __commonJS({
       }
       return cls;
     }
-    exports.parse = parse2;
+    exports.parse = parse;
     exports.parseExpression = parseExpression;
     exports.tokTypes = tokTypes;
   }
 });
 
-// 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 addCodeToGenerateEdgeoneWithAST(code, insertCode) {
-  try {
-    const ast = parser.parse(code, {
-      sourceType: "module",
-      plugins: ["typescript"]
-    });
-    let oldOutputValue = null;
-    let configObjectNode = null;
-    let configStart = null;
-    let configEnd = null;
-    let nitroProperty = null;
-    let hasNitro = false;
-    let presetValue = null;
-    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") {
-            configObjectNode = node.arguments[0];
-            configStart = configObjectNode.start;
-            configEnd = configObjectNode.end;
-            for (const prop of configObjectNode.properties) {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "nitro") {
-                hasNitro = true;
-                nitroProperty = prop;
-                break;
-              }
-            }
-            path2.stop();
-          }
-        }
-      }
-    });
-    if (!configObjectNode || configStart === null || configEnd === null) {
-      return null;
-    }
-    let newConfigCode = "";
-    let needsUpdate = true;
-    const newOutputConfig = {
-      dir: ".edgeone",
-      publicDir: ".edgeone/assets",
-      serverDir: ".edgeone/server-handler"
-    };
-    if (!hasNitro) {
-      oldOutputValue = null;
-      const existingConfigContent = code.slice(configStart + 1, configEnd - 1).trim();
-      const nitroConfig = `  nitro: {
-    output: {
-      dir: '.edgeone',
-      publicDir: '.edgeone/assets',
-      serverDir: '.edgeone/server-handler',
-    },
-  }`;
-      if (existingConfigContent) {
-        const trimmedContent = existingConfigContent.replace(/,\s*$/, "");
-        newConfigCode = `{
-${trimmedContent},
-${nitroConfig}
-}`;
-      } else {
-        newConfigCode = `{
-${nitroConfig}
-}`;
-      }
-    } else {
-      const nitroStart = nitroProperty.value.start;
-      const nitroEnd = nitroProperty.value.end;
-      let hasOutput = false;
-      let hasPreset = false;
-      if (nitroProperty.value.type === "ObjectExpression") {
-        for (const nitroProp of nitroProperty.value.properties) {
-          if (nitroProp.type === "ObjectProperty" && nitroProp.key.type === "Identifier") {
-            if (nitroProp.key.name === "output") {
-              hasOutput = true;
-              oldOutputValue = astNodeToObject(nitroProp.value);
-            } else if (nitroProp.key.name === "preset") {
-              hasPreset = true;
-              presetValue = astNodeToObject(nitroProp.value);
-            }
-          }
-        }
-      }
-      if (!hasOutput) {
-        oldOutputValue = null;
-      }
-      const needsPresetUpdate = hasPreset && presetValue !== "node-server";
-      const outputConfigStr = `    output: {
-      dir: '.edgeone',
-      publicDir: '.edgeone/assets',
-      serverDir: '.edgeone/server-handler',
-    }`;
-      let newNitroContent;
-      const properties = [];
-      for (const nitroProp of nitroProperty.value.properties) {
-        if (nitroProp.type === "ObjectProperty" && nitroProp.key.type === "Identifier") {
-          if (nitroProp.key.name === "output") {
-            properties.push(outputConfigStr);
-          } else if (nitroProp.key.name === "preset") {
-            continue;
-          } else {
-            const propStart = nitroProp.start - nitroStart;
-            const propEnd = nitroProp.end - nitroStart;
-            const propContent = code.slice(nitroStart + propStart, nitroStart + propEnd);
-            properties.push(`    ${propContent.trim()}`);
-          }
-        }
-      }
-      if (!hasOutput) {
-        properties.push(outputConfigStr);
-      }
-      newNitroContent = `{
-${properties.join(",\n")}
-  }`;
-      const beforeNitro = code.slice(configStart, nitroStart);
-      const afterNitro = code.slice(nitroEnd, configEnd);
-      newConfigCode = beforeNitro + newNitroContent + afterNitro;
-    }
-    const newCode = code.slice(0, configStart) + newConfigCode + code.slice(configEnd);
-    try {
-      parser.parse(newCode, {
-        sourceType: "module",
-        plugins: ["typescript"]
-      });
-    } catch (parseError) {
-      console.warn("Generated code has syntax issues:", parseError);
-    }
-    return {
-      oldPreset: presetValue,
-      oldOutput: oldOutputValue,
-      newCode
-    };
-  } catch (e) {
-    console.error("AST parsing or traversal failed:", e);
-    return null;
-  }
-}
-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 resetNitroConfigWithAST(code, oldOutput, oldPreset) {
-  try {
-    const ast = parser.parse(code, {
-      sourceType: "module",
-      plugins: ["typescript"]
-    });
-    let configObjectNode = null;
-    let configStart = null;
-    let configEnd = null;
-    let nitroProperty = null;
-    let hasNitro = false;
-    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") {
-            configObjectNode = node.arguments[0];
-            configStart = configObjectNode.start;
-            configEnd = configObjectNode.end;
-            for (const prop of configObjectNode.properties) {
-              if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "nitro") {
-                hasNitro = true;
-                nitroProperty = prop;
-                break;
-              }
-            }
-            path2.stop();
-          }
-        }
-      }
-    });
-    if (!configObjectNode || configStart === null || configEnd === null) {
-      return null;
-    }
-    if (!hasNitro) {
-      return code;
-    }
-    const nitroStart = nitroProperty.value.start;
-    const nitroEnd = nitroProperty.value.end;
-    const properties = [];
-    for (const nitroProp of nitroProperty.value.properties) {
-      if (nitroProp.type === "ObjectProperty" && nitroProp.key.type === "Identifier") {
-        const propName = nitroProp.key.name;
-        if (propName === "output") {
-          if (oldOutput !== null && oldOutput !== void 0) {
-            let outputConfigStr = "";
-            if (typeof oldOutput === "object" && oldOutput !== null) {
-              const outputProps = [];
-              for (const [key, value] of Object.entries(oldOutput)) {
-                if (typeof value === "string") {
-                  outputProps.push(`      ${key}: '${value}'`);
-                } else if (typeof value === "number" || typeof value === "boolean") {
-                  outputProps.push(`      ${key}: ${value}`);
-                } else {
-                  outputProps.push(`      ${key}: ${JSON.stringify(value)}`);
-                }
-              }
-              outputConfigStr = `    output: {
-${outputProps.join(",\n")}
-    }`;
-            } else {
-              outputConfigStr = `    output: ${JSON.stringify(oldOutput)}`;
-            }
-            properties.push(outputConfigStr);
-          }
-        } else if (propName === "preset") {
-          if (oldPreset !== null && oldPreset !== void 0) {
-            properties.push(`    preset: '${oldPreset}'`);
-          }
-        } else {
-          const propStart = nitroProp.start - nitroStart;
-          const propEnd = nitroProp.end - nitroStart;
-          const propContent = code.slice(nitroStart + propStart, nitroStart + propEnd);
-          properties.push(`    ${propContent.trim()}`);
-        }
-      }
-    }
-    let newNitroContent;
-    if (properties.length > 0) {
-      newNitroContent = `{
-${properties.join(",\n")}
-  }`;
-    } else {
-      newNitroContent = `{}`;
-    }
-    const beforeNitro = code.slice(configStart, nitroStart);
-    const afterNitro = code.slice(nitroEnd, configEnd);
-    const newConfigCode = beforeNitro + newNitroContent + afterNitro;
-    const newCode = code.slice(0, configStart) + newConfigCode + code.slice(configEnd);
-    return newCode;
-  } catch (e) {
-    console.error("AST parsing or traversal failed:", e);
-    return null;
-  }
-}
-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,
-  addCodeToGenerateEdgeoneWithAST,
-  resetNitroConfigWithAST,
-  getModulesWithAST
+  require_lib
 };