@edgeone/nuxt-pages 1.0.0-beta.1

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

@@ -0,0 +1,439 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getModulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRouteRulesWithAST,
+  getRoutesArrayWithAST
+} from "./chunk-5JK44IEA.js";
+
+// src/build/plugin-context.ts
+import { existsSync, readFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+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 = "cloud-functions/ssr-node";
+var PluginContext = class {
+  edgeoneConfig;
+  pluginName;
+  pluginVersion;
+  utils;
+  constants;
+  packageJSON;
+  _nuxtConfigPath = null;
+  _nuxtServerFile = null;
+  /** The directory where the plugin is located */
+  pluginDir = PLUGIN_DIR;
+  serverlessWrapHandler;
+  get relPublishDir() {
+    return this.constants.PUBLISH_DIR ?? join(this.constants.PACKAGE_PATH || "", DEFAULT_OUTPUT_DIR);
+  }
+  /** Absolute path of the publish directory */
+  get publishDir() {
+    return resolve(this.relPublishDir);
+  }
+  /**
+   * Relative package path in non monorepo setups this is an empty string
+   * This path is provided by Nuxt build manifest
+   * @example ''
+   * @example 'apps/my-app'
+   */
+  get relativeAppDir() {
+    return this.buildManifest?.buildDir ?? "";
+  }
+  /**
+   * The working directory inside the lambda that is used for monorepos to execute the serverless function
+   */
+  get lambdaWorkingDirectory() {
+    return "";
+  }
+  /**
+   * The resolved relative nuxt build directory defaults to `.nuxt`,
+   * but can be configured through the nuxt.config.js. For monorepos this will include the packagePath
+   * If we need just the plain build dir use the `nuxtBuildDir`
+   */
+  get buildDir() {
+    const dir = this.buildConfig?.buildDir ?? DEFAULT_BUILD_DIR;
+    return relative(process.cwd(), resolve(this.relativeAppDir, dir));
+  }
+  /** The directory where the Nuxt output is stored */
+  get outputDir() {
+    return DEFAULT_OUTPUT_DIR;
+  }
+  get buildVersion() {
+    return this.constants.BUILD_VERSION || "v0.0.0";
+  }
+  get useRegionalBlobs() {
+    const REQUIRED_BUILD_VERSION = ">=29.41.5";
+    const currentVersion = this.buildVersion.replace("v", "");
+    const requiredVersion = REQUIRED_BUILD_VERSION.replace(">=", "");
+    return currentVersion >= requiredVersion;
+  }
+  /**
+   * Absolute path of the directory containing the files for the serverless lambda function
+   * `.edgeone/functions-internal`
+   */
+  get serverFunctionsDir() {
+    return this.resolveFromPackagePath(".edgeone");
+  }
+  /** Absolute path of the server handler */
+  get serverHandlerRootDir() {
+    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
+  }
+  get serverHandlerDir() {
+    return this.serverHandlerRootDir;
+  }
+  get serverHandlerRuntimeModulesDir() {
+    return join(this.serverHandlerDir, ".edgeone");
+  }
+  get nuxtServerHandler() {
+    return "./.edgeone/dist/run/handlers/server.js";
+  }
+  constructor(options) {
+    options = {
+      ...options,
+      functions: {
+        "*": {}
+      },
+      constants: {
+        // BUILD_VERSION: '32.1.4',
+        ...options.constants,
+        PUBLISH_DIR: options.constants?.PUBLISH_DIR || ".output"
+      }
+    };
+    this.constants = options.constants;
+    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
+    this.pluginName = this.packageJSON.name;
+    this.pluginVersion = this.packageJSON.version;
+  }
+  /** Resolves a path correctly with mono repository awareness for .edgeone directories mainly  */
+  resolveFromPackagePath(...args) {
+    return resolve(this.constants.PACKAGE_PATH || "", ...args);
+  }
+  /** Get the nuxt routes manifest */
+  async getRoutesManifest() {
+    try {
+      let routesData = await this.getRouteRules();
+      if (!routesData) {
+        return { routes: [], prerendered: [] };
+      }
+      const routes = Array.isArray(routesData) ? routesData.map((route) => ({
+        path: route.path || route.route,
+        file: route.file || "",
+        prerender: route.prerender || false,
+        ssr: route.ssr !== false,
+        swr: route.swr ? route.swr : route.isr ? route.isr : false
+      })) : [];
+      return { routes, prerendered: routes.filter((r) => r.prerender).map((r) => r.path) };
+    } catch (error) {
+      return { routes: [], prerendered: [] };
+    }
+  }
+  /**
+   * Uses various heuristics to try to find the .output dir.
+   * Works by looking for nitro.json, so requires the site to have been built
+   */
+  findDotOutput() {
+    for (const dir of [
+      // The publish directory
+      this.publishDir,
+      // In the root
+      resolve(DEFAULT_OUTPUT_DIR),
+      // The sibling of the publish directory
+      resolve(this.publishDir, "..", DEFAULT_OUTPUT_DIR),
+      // In the package dir
+      resolve(this.constants.PACKAGE_PATH || "", DEFAULT_OUTPUT_DIR)
+    ]) {
+      if (existsSync(join(dir, "nitro.json"))) {
+        return dir;
+      }
+    }
+    return false;
+  }
+  // don't make private as it is handy inside testing to override the config
+  _buildManifest = null;
+  /** Get Build manifest from build output **/
+  get buildManifest() {
+    if (!this._buildManifest) {
+      let buildManifestJson = join(this.publishDir, "build-manifest.json");
+      if (!existsSync(buildManifestJson)) {
+        const dotOutput = this.findDotOutput();
+        if (dotOutput) {
+          buildManifestJson = join(dotOutput, "build-manifest.json");
+        }
+      }
+      if (existsSync(buildManifestJson)) {
+        this._buildManifest = JSON.parse(
+          readFileSync(buildManifestJson, "utf-8")
+        );
+      } else {
+        this._buildManifest = {
+          version: "1.0.0",
+          config: {},
+          buildDir: DEFAULT_BUILD_DIR,
+          outputDir: DEFAULT_OUTPUT_DIR,
+          routes: {},
+          assets: {}
+        };
+      }
+    }
+    return this._buildManifest;
+  }
+  #exportDetail = null;
+  /** Get metadata when output = static */
+  get exportDetail() {
+    if (this.buildConfig?.nitro?.prerender !== true) {
+      return null;
+    }
+    if (!this.#exportDetail) {
+      const detailFile = join(
+        this.buildManifest.buildDir,
+        "export-detail.json"
+      );
+      if (!existsSync(detailFile)) {
+        return null;
+      }
+      try {
+        this.#exportDetail = JSON.parse(readFileSync(detailFile, "utf-8"));
+      } catch {
+      }
+    }
+    return this.#exportDetail;
+  }
+  /** Get Nuxt Config from build output **/
+  get buildConfig() {
+    return this.buildManifest.config;
+  }
+  /** Get the path to nuxt.config.ts file */
+  get nuxtConfigPath() {
+    if (!this._nuxtConfigPath) {
+      this._nuxtConfigPath = this.detectNuxtConfigPath();
+    }
+    return this._nuxtConfigPath;
+  }
+  get nuxtServerFile() {
+    if (!this._nuxtServerFile) {
+      this._nuxtServerFile = this.detectNuxtServerFile();
+    }
+    return this._nuxtServerFile;
+  }
+  /** Detect and locate nuxt.config.ts file */
+  detectNuxtConfigPath() {
+    const configFiles = ["nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"];
+    for (const configFile of configFiles) {
+      const configPath = this.resolveFromPackagePath(configFile);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    console.log("Can't find nuxt.config.ts file");
+    return null;
+  }
+  /** Detect and locate server.mjs file */
+  detectNuxtServerFile() {
+    const serverFilePath = this.resolveFromPackagePath(".edgeone", "cloud-functions", "ssr-node", "chunks", "build", "server.mjs");
+    if (existsSync(serverFilePath)) {
+      return serverFilePath;
+    }
+    return null;
+  }
+  /** Read and parse nuxt.config.ts file content */
+  async getNuxtConfig() {
+    const configPath = this.nuxtConfigPath;
+    if (!configPath) {
+      console.warn("No Nuxt config file found");
+      return null;
+    }
+    try {
+      console.log("Loading Nuxt config from:", configPath);
+      const configContent = readFileSync(configPath, "utf-8");
+      console.log("Reading config file content...");
+      return configContent;
+    } catch (error) {
+      console.warn(`Failed to load Nuxt config from ${configPath}:`, error);
+      return null;
+    }
+  }
+  async getNuxtServerFile() {
+    const serverFilePath = this.nuxtServerFile;
+    if (!serverFilePath) {
+      console.warn("No Nuxt server file found");
+      return null;
+    }
+    try {
+      console.log("Loading Nuxt server file from:", serverFilePath);
+      const serverContent = readFileSync(serverFilePath, "utf-8");
+      console.log("Reading server file content...");
+      return serverContent;
+    } catch (error) {
+      console.warn(`Failed to load Nuxt server file from ${serverFilePath}:`, error);
+      return null;
+    }
+  }
+  /** Get routeRules from nuxt.config.ts */
+  async getRouteRules() {
+    const nitroPrerenderRoutes = await this.getPrerenderRoutes();
+    const nuxtConfigRoutes = getRouteRulesWithAST(await this.getNuxtConfig() || "");
+    const result = [];
+    for (const key in nuxtConfigRoutes) {
+      const obj = {
+        path: key,
+        prerender: nuxtConfigRoutes[key].prerender === true,
+        ssr: !nuxtConfigRoutes[key].prerender && !(nuxtConfigRoutes[key].hasOwnProperty("swr") || nuxtConfigRoutes[key].hasOwnProperty("isr")),
+        swr: false
+      };
+      if (nuxtConfigRoutes[key].hasOwnProperty("swr")) {
+        obj.swr = nuxtConfigRoutes[key].swr;
+      }
+      if (nuxtConfigRoutes[key].hasOwnProperty("isr")) {
+        obj.swr = nuxtConfigRoutes[key].isr;
+      }
+      if (nuxtConfigRoutes[key].hasOwnProperty("prerender") && nuxtConfigRoutes[key].prerender) {
+        Object.defineProperty(obj, "file", {
+          value: `asset${key}/index.html`,
+          enumerable: true
+        });
+      }
+      result.push(obj);
+    }
+    const serverRoutes = getRoutesArrayWithAST(await this.getNuxtServerFile() || "");
+    serverRoutes.forEach((item) => {
+      const keys = result.map((obj) => obj.path);
+      const pathWithoutBracket = item.path.replace(/\[|\]$/g, "").replace(/\(|\)$/g, "");
+      if (!keys.includes(pathWithoutBracket)) {
+        if (nitroPrerenderRoutes.includes(item.path)) {
+          result.push({
+            path: item.path,
+            prerender: true,
+            ssr: false,
+            swr: false
+          });
+        } else {
+          result.push({
+            path: item.path,
+            prerender: false,
+            ssr: true,
+            swr: false
+          });
+        }
+      }
+    });
+    return result;
+  }
+  #nuxtVersion = void 0;
+  /**
+   * Get the exact Nuxt version installed in the project.
+   *
+   * Prefer resolving `nuxt/package.json` from the app root (works for monorepo and Yarn PnP),
+   * then fall back to node_modules.
+   */
+  get nuxtVersion() {
+    if (this.#nuxtVersion !== void 0) return this.#nuxtVersion;
+    const roots = [this.constants.PACKAGE_PATH || process.cwd()].filter(Boolean);
+    const readJsonVersion = (pkgJsonPath) => {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+        return typeof pkg.version === "string" && pkg.version.trim() ? pkg.version.trim() : null;
+      } catch {
+        return null;
+      }
+    };
+    try {
+      const require2 = createRequire(import.meta.url);
+      const resolved = require2.resolve("nuxt/package.json", { paths: roots });
+      const v = readJsonVersion(resolved);
+      if (v) {
+        this.#nuxtVersion = v;
+        return this.#nuxtVersion;
+      }
+    } catch {
+    }
+    for (const root of roots) {
+      const candidate = resolve(root, "node_modules", "nuxt", "package.json");
+      if (existsSync(candidate)) {
+        const v = readJsonVersion(candidate);
+        if (v) {
+          this.#nuxtVersion = v;
+          return this.#nuxtVersion;
+        }
+      }
+    }
+    this.#nuxtVersion = null;
+    return this.#nuxtVersion;
+  }
+  #nuxtModules = null;
+  async nuxtModules() {
+    if (!this.#nuxtModules) {
+      const nuxtConfig = await this.getNuxtConfig();
+      if (!nuxtConfig) {
+        this.#nuxtModules = null;
+        return this.#nuxtModules;
+      }
+      try {
+        const modules = getModulesWithAST(nuxtConfig);
+        this.#nuxtModules = modules;
+      } catch (error) {
+        console.error("Error extracting modules from nuxt.config.ts:", error);
+        this.#nuxtModules = null;
+      }
+    }
+    return this.#nuxtModules;
+  }
+  #staticPages = null;
+  /**
+   * Get an array of static pages that are fully prerendered.
+   * Those are being served as-is without involving server-side rendering
+   */
+  async getStaticPages() {
+    if (!this.#staticPages) {
+      const routesManifest = await this.getRoutesManifest();
+      this.#staticPages = routesManifest.routes.filter((route) => route.prerender === true).map((route) => route.path);
+    }
+    return this.#staticPages;
+  }
+  /** Get prerender routes from nuxt.config.ts */
+  async getPrerenderRoutes() {
+    try {
+      const configPath = join(process.cwd(), "nuxt.config.ts");
+      if (!existsSync(configPath)) {
+        console.warn("nuxt.config.ts not found, returning empty prerender routes");
+        return [];
+      }
+      const configContent = await readFile(configPath, "utf-8");
+      const prerenderRoutes = getPrerenderRoutesWithAST(configContent);
+      return prerenderRoutes;
+    } catch (error) {
+      console.error("Error reading prerender routes from nuxt.config.ts:", error);
+      return [];
+    }
+  }
+  async nuxtStaticGeneration() {
+    const nitroJSON = await readFile(join(this.outputDir, "nitro.json"), "utf-8") || "{}";
+    if (!nitroJSON) return false;
+    const nitroJSONData = JSON.parse(nitroJSON);
+    if (nitroJSONData.preset && nitroJSONData.preset === "static") return true;
+    return false;
+  }
+  /** Fails a build with a message and an optional error */
+  failBuild(message, error) {
+    console.error(message);
+    if (error) {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+};
+
+export {
+  SERVER_HANDLER_NAME,
+  PluginContext
+};

package/dist/index.js

@@ -0,0 +1,89 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  PluginContext
+} from "./esm-chunks/chunk-Y3YAV6NZ.js";
+import {
+  createNuxtRoutesMeta
+} from "./esm-chunks/chunk-UFRAZNP3.js";
+import {
+  createServerHandler,
+  patchNitroHandler
+} from "./esm-chunks/chunk-L23O2KDO.js";
+import "./esm-chunks/chunk-TP3RAVPL.js";
+import {
+  addNitroBuildOutputConfig,
+  resetNitroConfig
+} from "./esm-chunks/chunk-7RNB5RB6.js";
+import {
+  resetEdgeOneConfig,
+  useStaticBuild
+} from "./esm-chunks/chunk-5JK44IEA.js";
+import "./esm-chunks/chunk-V2LFVP3C.js";
+import "./esm-chunks/chunk-6BT4RYQJ.js";
+
+// src/index.ts
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+async function checkModules(ctx, targetModules) {
+  const modules = await ctx.nuxtModules();
+  if (!modules) return false;
+  return modules.includes(targetModules);
+}
+var removeServerHandler = async (ctx) => {
+  await rm(ctx.serverHandlerDir, { recursive: true, force: true });
+};
+var removeIndexMJS = async (ctx) => {
+  if (existsSync(join(ctx.serverHandlerDir, "index.mjs"))) {
+    await rm(join(ctx.serverHandlerDir, "index.mjs"), { force: true });
+  }
+};
+var recordOldNitroConfig = null;
+var recordOldEdgeOneConfig = -1;
+var onPreBuild = async (options) => {
+  console.log("\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C}\u{1F62C} ======= new nuxt pages 1.1.0+ ============");
+  try {
+    const ctx = new PluginContext(options);
+    recordOldNitroConfig = await addNitroBuildOutputConfig(ctx);
+    const packagePath = ctx.resolveFromPackagePath("");
+    const cwd = packagePath || process.cwd();
+    if (await checkModules(ctx, "@nuxt/content")) {
+      console.warn("\u26A0\uFE0F @nuxt/content detected, switching to static deployment.");
+      recordOldEdgeOneConfig = useStaticBuild(cwd);
+    }
+  } catch (error) {
+    console.error("onPreBuild failed:", error);
+  }
+};
+var onBuild = async (options) => {
+  const ctx = new PluginContext(options);
+  const isStaticGeneration = await ctx.nuxtStaticGeneration();
+  if (isStaticGeneration) {
+    await removeServerHandler(ctx);
+    return;
+  }
+  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);
+    await removeIndexMJS(ctx);
+  }
+  if (recordOldEdgeOneConfig !== -1) {
+    resetEdgeOneConfig(cwd, recordOldEdgeOneConfig);
+  }
+};
+export {
+  onBuild,
+  onPostBuild,
+  onPreBuild
+};

package/dist/types/options.js

@@ -0,0 +1,6 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    

package/dist/utils.js

@@ -0,0 +1,29 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  addCodeToGenerateEdgeoneWithAST,
+  getHandlersArrayWithAST,
+  getModulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRouteRulesWithAST,
+  getRoutesArrayWithAST,
+  resetEdgeOneConfig,
+  resetNitroConfigWithAST,
+  useStaticBuild
+} from "./esm-chunks/chunk-5JK44IEA.js";
+import "./esm-chunks/chunk-6BT4RYQJ.js";
+export {
+  addCodeToGenerateEdgeoneWithAST,
+  getHandlersArrayWithAST,
+  getModulesWithAST,
+  getPrerenderRoutesWithAST,
+  getRouteRulesWithAST,
+  getRoutesArrayWithAST,
+  resetEdgeOneConfig,
+  resetNitroConfigWithAST,
+  useStaticBuild
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@edgeone/nuxt-pages",
+  "version": "1.0.0-beta.1",
+  "main": "./dist/index.js",
+  "scripts": {
+    "test": "vitest run --passWithNoTests",
+    "build": "node ./tools/build.js",
+    "build:watch": "node ./tools/build.js --watch",
+    "start": "node dist/index.js",
+    "audit": "npm audit",
+    "audit:fix": "npm audit fix",
+    "security": "npm audit && npm outdated"
+  },
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "nuxt",
+    "deploy",
+    "edgeone"
+  ],
+  "author": "Venzil",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/q153877011/edgeone-nuxt-deploy.git"
+  },
+  "bugs": {
+    "url": "https://github.com/q153877011/edgeone-nuxt-deploy/issues"
+  },
+  "homepage": "https://github.com/q153877011/edgeone-nuxt-deploy#readme",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "@babel/parser": "^7.28.4",
+    "@babel/traverse": "^7.28.4",
+    "@babel/types": "^7.28.4",
+    "@netlify/functions": "^3.1.10",
+    "@nuxt/kit": "^3.14.0",
+    "@opentelemetry/api": "^1.9.0",
+    "fast-glob": "^3.3.3",
+    "lru-cache": "^10.4.3",
+    "vitest": "^3.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.23",
+    "@types/picomatch": "^3.0.2",
+    "@types/uuid": "^10.0.0",
+    "esbuild": "^0.25.11",
+    "execa": "^8.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}