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

package/dist/esm-chunks/{chunk-BZQMVWYQ.js → chunk-VDBASNGL.js}

@@ -9,7 +9,7 @@ import {
   getPrerenderRoutesWithAST,
   getRouteRulesWithAST,
   getRoutesArrayWithAST
-} from "./chunk-MONI3XWQ.js";
+} from "./chunk-AZLY3JO2.js";
 
 // src/build/plugin-context.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -21,7 +21,7 @@ var MODULE_DIR = fileURLToPath(new URL(".", import.meta.url));
 var PLUGIN_DIR = join(MODULE_DIR, "../..");
 var DEFAULT_BUILD_DIR = ".nuxt";
 var DEFAULT_OUTPUT_DIR = ".edgeone";
-var SERVER_HANDLER_NAME = "server-handler";
+var SERVER_HANDLER_NAME = "cloud-functions/ssr-node";
 var PluginContext = class {
   edgeoneConfig;
   pluginName;
@@ -240,7 +240,7 @@ var PluginContext = class {
   }
   /** Detect and locate server.mjs file */
   detectNuxtServerFile() {
-    const serverFilePath = this.resolveFromPackagePath(".edgeone", "server-handler", "chunks", "build", "server.mjs");
+    const serverFilePath = this.resolveFromPackagePath(".edgeone", "cloud-functions", "ssr-node", "chunks", "build", "server.mjs");
     if (existsSync(serverFilePath)) {
       return serverFilePath;
     }

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

@@ -0,0 +1,180 @@
+
+      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/build/content/module-inject.ts
+var parser = __toESM(require_lib(), 1);
+import { existsSync } from "node:fs";
+import { readFile, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var traverse = require2("@babel/traverse").default;
+var generate = require2("@babel/generator").default;
+var TEMP_MODULE_FILENAME = ".edgeone-nitro-config.mjs";
+function generateModuleContent() {
+  return `// Auto-generated by @edgeone/nuxt-pages \u2014 DO NOT EDIT
+// This file will be removed after build completes.
+import { defineNuxtModule } from '@nuxt/kit'
+
+export default defineNuxtModule({
+  meta: { name: 'edgeone-nitro-config' },
+  setup(_options, nuxt) {
+    nuxt.hook('nitro:config', (nitroConfig) => {
+      // Store original values for reference
+      const originalOutput = nitroConfig.output ? { ...nitroConfig.output } : null
+      const originalPreset = nitroConfig.preset
+
+      // Override output directories for EdgeOne deployment
+      nitroConfig.output = nitroConfig.output || {}
+      nitroConfig.output.dir = '.edgeone'
+      nitroConfig.output.publicDir = '.edgeone/assets'
+      nitroConfig.output.serverDir = '.edgeone/cloud-functions/ssr-node'
+
+      // Remove preset to use default node-server
+      if (nitroConfig.preset && nitroConfig.preset !== 'node-server') {
+        delete nitroConfig.preset
+      }
+    })
+  }
+})
+`;
+}
+async function writeTempModule(projectRoot) {
+  const modulePath = join(projectRoot, TEMP_MODULE_FILENAME);
+  await writeFile(modulePath, generateModuleContent(), "utf-8");
+  console.log(`Created temporary EdgeOne module: ${modulePath}`);
+  return modulePath;
+}
+async function removeTempModule(projectRoot) {
+  const modulePath = join(projectRoot, TEMP_MODULE_FILENAME);
+  if (existsSync(modulePath)) {
+    await rm(modulePath, { force: true });
+    console.log(`Removed temporary EdgeOne module: ${modulePath}`);
+  }
+}
+function addModuleToConfig(code, moduleRef) {
+  try {
+    const ast = parser.parse(code, {
+      sourceType: "module",
+      plugins: ["typescript"]
+    });
+    let configObjectNode = null;
+    let modulesArrayNode = null;
+    traverse(ast, {
+      CallExpression(path) {
+        const { node } = path;
+        if (node.callee.type === "Identifier" && node.callee.name === "defineNuxtConfig" && node.arguments.length > 0) {
+          let arg = node.arguments[0];
+          while (arg.type === "TSAsExpression" || arg.type === "TSSatisfiesExpression" || arg.type === "TSTypeAssertion") {
+            arg = arg.expression;
+          }
+          if (arg.type !== "ObjectExpression") return;
+          configObjectNode = arg;
+          for (const prop of configObjectNode.properties) {
+            if (prop.type === "ObjectProperty" && prop.key.type === "Identifier" && prop.key.name === "modules" && prop.value.type === "ArrayExpression") {
+              modulesArrayNode = prop.value;
+              break;
+            }
+          }
+          path.stop();
+        }
+      }
+    });
+    if (!configObjectNode) {
+      return null;
+    }
+    const originalCode = code;
+    if (modulesArrayNode) {
+      const stringLiteral = {
+        type: "StringLiteral",
+        value: moduleRef
+      };
+      modulesArrayNode.elements.unshift(stringLiteral);
+    } else {
+      const modulesProp = {
+        type: "ObjectProperty",
+        key: { type: "Identifier", name: "modules" },
+        value: {
+          type: "ArrayExpression",
+          elements: [{ type: "StringLiteral", value: moduleRef }]
+        },
+        computed: false,
+        shorthand: false
+      };
+      configObjectNode.properties.unshift(modulesProp);
+    }
+    const output = generate(ast, { retainLines: true }, code);
+    return { newCode: output.code, originalCode };
+  } catch (e) {
+    console.error("Failed to inject module into nuxt config:", e);
+    return null;
+  }
+}
+async function injectEdgeoneModule(configPath, projectRoot) {
+  const result = {
+    success: false,
+    originalConfigContent: null,
+    configPath,
+    projectRoot
+  };
+  try {
+    await writeTempModule(projectRoot);
+    if (!configPath || !existsSync(configPath)) {
+      const defaultConfig = `export default defineNuxtConfig({
+  modules: ['./${TEMP_MODULE_FILENAME}'],
+})`;
+      const newConfigPath = join(projectRoot, "nuxt.config.ts");
+      await writeFile(newConfigPath, defaultConfig, "utf-8");
+      console.log(`Created nuxt.config.ts with EdgeOne module at: ${newConfigPath}`);
+      result.configPath = newConfigPath;
+      result.originalConfigContent = null;
+      result.success = true;
+      return result;
+    }
+    const configContent = await readFile(configPath, "utf-8");
+    const moduleRef = `./${TEMP_MODULE_FILENAME}`;
+    const astResult = addModuleToConfig(configContent, moduleRef);
+    if (astResult) {
+      await writeFile(configPath, astResult.newCode, "utf-8");
+      console.log(`Injected EdgeOne module into: ${configPath}`);
+      result.originalConfigContent = astResult.originalCode;
+      result.success = true;
+    } else {
+      console.error("Failed to inject module via AST, cleaning up temp module file");
+      await removeTempModule(projectRoot);
+    }
+  } catch (error) {
+    console.error("injectEdgeoneModule failed:", error);
+    await removeTempModule(projectRoot).catch(() => {
+    });
+  }
+  return result;
+}
+async function cleanupEdgeoneModule(injectionResult) {
+  try {
+    const { originalConfigContent, configPath, projectRoot } = injectionResult;
+    if (originalConfigContent !== null && existsSync(configPath)) {
+      await writeFile(configPath, originalConfigContent, "utf-8");
+      console.log(`Restored nuxt config: ${configPath}`);
+    }
+    await removeTempModule(projectRoot);
+  } catch (error) {
+    console.error("cleanupEdgeoneModule failed:", error);
+  }
+}
+
+export {
+  removeTempModule,
+  injectEdgeoneModule,
+  cleanupEdgeoneModule
+};

package/dist/index.js

@@ -6,25 +6,25 @@
     
 import {
   PluginContext
-} from "./esm-chunks/chunk-BZQMVWYQ.js";
+} from "./esm-chunks/chunk-VDBASNGL.js";
 import {
-  createNuxtApiRoutesMeta,
-  createNuxtPagesRouteMeta
-} from "./esm-chunks/chunk-J25U56II.js";
-import {
-  createServerHandler,
-  patchNitroHandler
-} from "./esm-chunks/chunk-RNEZUAPL.js";
-import "./esm-chunks/chunk-NJ4SUJNF.js";
-import {
-  addNitroBuildOutputConfig,
-  resetNitroConfig
-} from "./esm-chunks/chunk-7X4RPD4I.js";
+  createNuxtRoutesMeta
+} from "./esm-chunks/chunk-3HA3DZ3G.js";
 import {
   resetEdgeOneConfig,
   useStaticBuild
-} from "./esm-chunks/chunk-MONI3XWQ.js";
-import "./esm-chunks/chunk-V2LFVP3C.js";
+} from "./esm-chunks/chunk-AZLY3JO2.js";
+import {
+  cleanupEdgeoneModule,
+  injectEdgeoneModule,
+  removeTempModule
+} from "./esm-chunks/chunk-ZR3DYEBK.js";
+import "./esm-chunks/chunk-VCJ5U4PV.js";
+import {
+  createServerHandler,
+  patchNitroHandler
+} from "./esm-chunks/chunk-PJWA566S.js";
+import "./esm-chunks/chunk-K5VT7O2H.js";
 import "./esm-chunks/chunk-6BT4RYQJ.js";
 
 // src/index.ts
@@ -44,17 +44,18 @@ var removeIndexMJS = async (ctx) => {
     await rm(join(ctx.serverHandlerDir, "index.mjs"), { force: true });
   }
 };
-var recordOldNitroConfig = null;
+var moduleInjectionResult = null;
 var recordOldEdgeOneConfig = -1;
 var onPreBuild = async (options) => {
   try {
     const ctx = new PluginContext(options);
-    recordOldNitroConfig = await addNitroBuildOutputConfig(ctx);
     const packagePath = ctx.resolveFromPackagePath("");
-    const cwd = packagePath || process.cwd();
+    const projectRoot = packagePath || process.cwd();
+    const configPath = ctx.nuxtConfigPath || "";
+    moduleInjectionResult = await injectEdgeoneModule(configPath, projectRoot);
     if (await checkModules(ctx, "@nuxt/content")) {
       console.warn("\u26A0\uFE0F @nuxt/content detected, switching to static deployment.");
-      recordOldEdgeOneConfig = useStaticBuild(cwd);
+      recordOldEdgeOneConfig = useStaticBuild(projectRoot);
     }
   } catch (error) {
     console.error("onPreBuild failed:", error);
@@ -67,20 +68,22 @@ var onBuild = async (options) => {
     await removeServerHandler(ctx);
     return;
   }
-  await createServerHandler(ctx), await createNuxtPagesRouteMeta(ctx);
-  await createNuxtApiRoutesMeta(ctx);
+  await createServerHandler(ctx), await createNuxtRoutesMeta(ctx);
   await patchNitroHandler(ctx);
 };
 var onPostBuild = async (options) => {
   const ctx = new PluginContext(options);
   const packagePath = ctx.resolveFromPackagePath("");
-  const cwd = packagePath || process.cwd();
-  if (recordOldNitroConfig) {
-    await resetNitroConfig(recordOldNitroConfig.oldOutput, recordOldNitroConfig.oldPreset);
+  const projectRoot = packagePath || process.cwd();
+  if (moduleInjectionResult) {
+    await cleanupEdgeoneModule(moduleInjectionResult);
     await removeIndexMJS(ctx);
+  } else {
+    await removeTempModule(projectRoot).catch(() => {
+    });
   }
   if (recordOldEdgeOneConfig !== -1) {
-    resetEdgeOneConfig(cwd, recordOldEdgeOneConfig);
+    resetEdgeOneConfig(projectRoot, recordOldEdgeOneConfig);
   }
 };
 export {

package/dist/utils.js

@@ -5,25 +5,22 @@
       })();
     
 import {
-  addCodeToGenerateEdgeoneWithAST,
   getHandlersArrayWithAST,
   getModulesWithAST,
   getPrerenderRoutesWithAST,
   getRouteRulesWithAST,
   getRoutesArrayWithAST,
   resetEdgeOneConfig,
-  resetNitroConfigWithAST,
   useStaticBuild
-} from "./esm-chunks/chunk-MONI3XWQ.js";
+} from "./esm-chunks/chunk-AZLY3JO2.js";
+import "./esm-chunks/chunk-VCJ5U4PV.js";
 import "./esm-chunks/chunk-6BT4RYQJ.js";
 export {
-  addCodeToGenerateEdgeoneWithAST,
   getHandlersArrayWithAST,
   getModulesWithAST,
   getPrerenderRoutesWithAST,
   getRouteRulesWithAST,
   getRoutesArrayWithAST,
   resetEdgeOneConfig,
-  resetNitroConfigWithAST,
   useStaticBuild
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@edgeone/nuxt-pages",
-  "version": "1.1.0-beta.3",
+  "version": "1.1.0",
   "main": "./dist/index.js",
   "scripts": {
-    "test": "ts-node src/test.ts",
+    "test": "vitest run --passWithNoTests",
     "build": "node ./tools/build.js",
     "build:watch": "node ./tools/build.js --watch",
     "start": "node dist/index.js",
@@ -36,6 +36,7 @@
   "license": "ISC",
   "description": "",
   "dependencies": {
+    "@babel/generator": "^7.28.4",
     "@babel/parser": "^7.28.4",
     "@babel/traverse": "^7.28.4",
     "@babel/types": "^7.28.4",

package/dist/esm-chunks/chunk-7X4RPD4I.js

@@ -1,131 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  addCodeToGenerateEdgeoneWithAST,
-  resetNitroConfigWithAST
-} from "./chunk-MONI3XWQ.js";
-import {
-  trace,
-  wrapTracer
-} from "./chunk-V2LFVP3C.js";
-
-// src/build/content/static.ts
-import { existsSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
-var tracer = wrapTracer(trace.getTracer("Nuxt runtime"));
-var addNitroBuildOutputConfig = async (ctx) => {
-  return tracer.withActiveSpan(
-    "addNitroBuildOutputConfig",
-    async (span) => {
-      const result = {
-        success: false,
-        message: ""
-      };
-      try {
-        const nitroConfigDir = ctx.nuxtConfigPath;
-        if (!nitroConfigDir || !existsSync(nitroConfigDir)) {
-          console.log("Nuxt config file not found, creating nuxt.config.ts...");
-          const defaultNuxtConfig = `export default defineNuxtConfig({
-            srcDir: 'app',
-            nitro: {
-              output: {
-                dir: '.edgeone',
-                publicDir: '.edgeone/assets',
-                serverDir: '.edgeone/server-handler',
-              },
-            },
-            devtools: { enabled: true },
-          })`;
-          const configPath = ctx.resolveFromPackagePath("nuxt.config.ts");
-          await writeFile(configPath, defaultNuxtConfig, "utf-8");
-          console.log(`Created nuxt.config.ts at: ${configPath}`);
-          Object.assign(result, {
-            success: true,
-            message: `Created nuxt.config.ts at: ${configPath}`,
-            configPath,
-            newCode: defaultNuxtConfig
-          });
-        } else {
-          console.log("Nuxt config file found, adding nitro.output config...");
-          const configContent = await readFile(nitroConfigDir, "utf-8");
-          const astResult = addCodeToGenerateEdgeoneWithAST(configContent, `
-            nitro: {
-              output: {
-                dir: '.edgeone',
-                publicDir: '.edgeone/assets',
-                serverDir: '.edgeone/server-handler',
-              },
-            },
-          `);
-          if (astResult?.newCode) {
-            await writeFile(nitroConfigDir, astResult.newCode, "utf-8");
-            console.log(`Successfully updated nuxt config file: ${nitroConfigDir}`);
-            Object.assign(result, {
-              success: true,
-              message: `Successfully updated nuxt config file: ${nitroConfigDir}`,
-              configPath: nitroConfigDir,
-              oldOutput: astResult.oldOutput,
-              oldPreset: astResult.oldPreset,
-              newCode: astResult.newCode
-            });
-          } else {
-            console.log("Failed to generate new config code");
-            Object.assign(result, {
-              success: false,
-              message: "Failed to generate new config code",
-              configPath: nitroConfigDir
-            });
-          }
-        }
-      } catch (error) {
-        span.end();
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        ctx.failBuild("Failed copying static assets", error);
-        Object.assign(result, {
-          success: false,
-          message: `Error: ${errorMessage}`
-        });
-      }
-      return result;
-    }
-  );
-};
-var resetNitroConfig = async (oldOutput, oldPreset) => {
-  try {
-    const possiblePaths = [
-      process.cwd() + "/nuxt.config.ts",
-      process.cwd() + "/nuxt.config.js",
-      process.cwd() + "/nuxt.config.mjs"
-    ];
-    let configPath = null;
-    for (const path of possiblePaths) {
-      if (existsSync(path)) {
-        configPath = path;
-        break;
-      }
-    }
-    if (!configPath) {
-      console.warn("nuxt.config.ts not found, cannot reset config");
-      return;
-    }
-    const configContent = await readFile(configPath, "utf-8");
-    const restoredCode = resetNitroConfigWithAST(configContent, oldOutput, oldPreset);
-    if (restoredCode) {
-      await writeFile(configPath, restoredCode, "utf-8");
-      console.log(`Successfully restored nuxt config file: ${configPath}`);
-    } else {
-      console.warn("Failed to restore nuxt.config.ts using AST");
-    }
-  } catch (error) {
-    console.error("Error restoring nuxt.config.ts:", error);
-  }
-};
-
-export {
-  addNitroBuildOutputConfig,
-  resetNitroConfig
-};

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

@@ -1,213 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  getHandlersArrayWithAST
-} from "./chunk-MONI3XWQ.js";
-
-// src/build/routes.ts
-import * as fs from "fs";
-import * as path from "path";
-var convertNuxtRoutePattern = (path2) => {
-  if (!path2.includes("[") && !path2.includes("_")) {
-    return path2;
-  }
-  let convertedPath = path2;
-  const catchAllMatch = path2.match(/\[\.\.\.([^\]]+)\]/);
-  if (catchAllMatch) {
-    const paramName = catchAllMatch[1];
-    convertedPath = convertedPath.replace(/\[\.\.\.([^\]]+)\]/g, `:${paramName}*`);
-  }
-  const dynamicMatch = path2.match(/\[([^\]]+)\]/);
-  if (dynamicMatch) {
-    const paramName = dynamicMatch[1];
-    convertedPath = convertedPath.replace(/\[([^\]]+)\]/g, `:${paramName}`);
-  }
-  const underscoreMatch = path2.match(/_([^\/\.]+)/);
-  if (underscoreMatch) {
-    const paramName = underscoreMatch[1];
-    convertedPath = convertedPath.replace(/_([^\/\.]+)/g, `:${paramName}`);
-  }
-  return convertedPath;
-};
-var createNuxtPagesRouteMeta = async (ctx) => {
-  const routeMap = {};
-  const prerenderRoutes = await ctx.getPrerenderRoutes();
-  if (prerenderRoutes && Array.isArray(prerenderRoutes)) {
-    for (const route of prerenderRoutes) {
-      routeMap[route] = {
-        isStatic: true
-      };
-    }
-  }
-  const staticPages = await ctx.getStaticPages();
-  if (staticPages && Array.isArray(staticPages)) {
-    for (const page of staticPages) {
-      if (!routeMap[page]) {
-        routeMap[page] = {};
-      }
-      routeMap[page].isStatic = true;
-    }
-  }
-  const routesManifest = await ctx.getRoutesManifest();
-  if (routesManifest) {
-    if (routesManifest.routes) {
-      for (let [route, routeInfo] of Object.entries(routesManifest.routes)) {
-        route = routeInfo.path;
-        if (!routeMap[route]) {
-          routeMap[route] = {};
-        }
-        if (routeInfo.prerender !== void 0) {
-          routeMap[route].isStatic = routeInfo.prerender;
-        }
-        if (routeInfo.swr !== void 0 && routeInfo.swr) {
-          routeMap[route].isr = routeInfo.swr;
-        }
-        if (routeInfo.isr !== void 0 && routeInfo.isr) {
-          routeMap[route].isr = routeInfo.isr;
-        }
-      }
-    }
-  }
-  const convertedRouteMap = {};
-  const pathsToDelete = [];
-  for (const [routePath, routeConfig] of Object.entries(routeMap)) {
-    const convertedPath = convertNuxtRoutePattern(routePath);
-    if (convertedPath !== routePath) {
-      pathsToDelete.push(routePath);
-      convertedRouteMap[convertedPath] = routeConfig;
-    }
-  }
-  for (const pathToDelete of pathsToDelete) {
-    delete routeMap[pathToDelete];
-  }
-  Object.assign(routeMap, convertedRouteMap);
-  const routesArray = Object.entries(routeMap).map(([path2, config]) => ({
-    path: path2,
-    ...config
-  }));
-  const edgeOneDir = path.join(process.cwd(), ".edgeone");
-  if (!fs.existsSync(edgeOneDir)) {
-    fs.mkdirSync(edgeOneDir, { recursive: true });
-  }
-  const metaFilePath = path.join(edgeOneDir, "server-handler", "meta.json");
-  let existingMetaData = {};
-  if (fs.existsSync(metaFilePath)) {
-    try {
-      const existingContent = fs.readFileSync(metaFilePath, "utf-8");
-      existingMetaData = JSON.parse(existingContent);
-    } catch (error2) {
-      console.warn("Failed to parse existing meta.json:", error2);
-    }
-  }
-  const mergedMetaData = {
-    ...existingMetaData,
-    routes: routesArray
-  };
-  await fs.writeFileSync(
-    metaFilePath,
-    JSON.stringify(mergedMetaData, null, 2),
-    "utf-8"
-  );
-};
-var createNuxtApiRoutesMeta = async (ctx) => {
-  const edgeOneDir = path.join(process.cwd(), ".edgeone");
-  if (!fs.existsSync(edgeOneDir)) {
-    console.error("Failed to create .edgeone directory:", error);
-    return;
-  }
-  const metaFilePath = path.join(edgeOneDir, "server-handler", "meta.json");
-  if (!fs.existsSync(metaFilePath)) {
-    console.error("Failed to create meta.json file:", error);
-    return;
-  }
-  const existingContent = await fs.readFileSync(metaFilePath, "utf-8");
-  const existingMetaData = JSON.parse(existingContent);
-  const defaultNitroPath = path.join(edgeOneDir, "server-handler", "chunks", "nitro", "nitro.mjs");
-  const fallbackNitroPath = path.join(edgeOneDir, "server-handler", "chunks", "_", "nitro.mjs");
-  const nitroPath = fs.existsSync(defaultNitroPath) ? defaultNitroPath : fallbackNitroPath;
-  let apiRoutes = [];
-  if (fs.existsSync(nitroPath)) {
-    try {
-      const nitroContent = fs.readFileSync(nitroPath, "utf-8");
-      const handlersArray = getHandlersArrayWithAST(nitroContent);
-      if (Array.isArray(handlersArray)) {
-        for (const handler of handlersArray) {
-          if (handler && typeof handler === "object") {
-            let routePath = null;
-            if (handler.route && typeof handler.route === "string") {
-              routePath = handler.route;
-              if (existingMetaData.routes.some((route) => route.path === routePath)) {
-                continue;
-              }
-              apiRoutes.push({
-                path: routePath,
-                handler
-              });
-            }
-          }
-        }
-      }
-    } catch (error2) {
-      console.error("Error parsing nitro.mjs for API routes:", error2);
-    }
-  }
-  const mergedMetaData = {
-    frameworkRoutes: existingMetaData.routes.concat(apiRoutes.map((route) => ({ path: route.path })))
-  };
-  const excludeRoutes = ["/**"];
-  let processedRoutes = mergedMetaData.frameworkRoutes.filter((route) => !excludeRoutes.includes(route.path)).map((route) => {
-    if (!route.path || route.path === "/**") {
-      return {
-        ...route,
-        path: "/"
-      };
-    }
-    if (route.path && route.path.includes("**:")) {
-      route.path = route.path.replaceAll("**:", ":");
-    }
-    if (route.path && route.path.includes("**")) {
-      let regexPath = route.path.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\//g, "\\/");
-      regexPath = `^${regexPath}$`;
-      if (route.path.startsWith("/_ipx")) {
-        regexPath = `/_ipx/:path*`;
-      }
-      return {
-        ...route,
-        path: regexPath
-        // Keep original path
-      };
-    } else if (route.path && route.path.includes("(.*)*")) {
-      let regexPath = route.path.replace(/\(\.\*\)\*/g, "*");
-      regexPath = `${regexPath}`;
-      return {
-        ...route,
-        path: regexPath
-        // Keep original path
-      };
-    }
-    return route;
-  });
-  processedRoutes = processedRoutes.map((route) => {
-    if (route.hasOwnProperty("ssr")) {
-      Reflect.deleteProperty(route, "ssr");
-    }
-    route.path = route.path.replace(/\(/g, "").replace(/\)/g, "");
-    return route;
-  });
-  const finalMetaData = {
-    frameworkRoutes: processedRoutes,
-    conf: {
-      ssr404: true
-    }
-  };
-  await fs.writeFileSync(metaFilePath, JSON.stringify(finalMetaData, null, 2));
-};
-
-export {
-  createNuxtPagesRouteMeta,
-  createNuxtApiRoutesMeta
-};