@edgeone/nuxt-pages 1.0.0-beta.1

package/dist/esm-chunks/chunk-6BT4RYQJ.js

@@ -0,0 +1,43 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __commonJS,
+  __toESM
+};

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

@@ -0,0 +1,131 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  addCodeToGenerateEdgeoneWithAST,
+  resetNitroConfigWithAST
+} from "./chunk-5JK44IEA.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/cloud-functions/ssr-node',
+              },
+            },
+            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/cloud-functions/ssr-node',
+              },
+            },
+          `);
+          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-L23O2KDO.js

@@ -0,0 +1,120 @@
+
+      var require = await (async () => {
+        var { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out,
+  verifyNuxtHandlerDirStructure
+} from "./chunk-TP3RAVPL.js";
+import {
+  __require,
+  __toESM
+} from "./chunk-6BT4RYQJ.js";
+
+// src/build/functions/server.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { cp, mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, relative } from "node:path";
+import { join as posixJoin } from "node:path/posix";
+var copyHandlerDependencies = async (ctx) => {
+  const promises = [];
+  const { included_files: includedFiles = [] } = {};
+  includedFiles.push(
+    posixJoin(ctx.relativeAppDir, ".env"),
+    posixJoin(ctx.relativeAppDir, ".env.production"),
+    posixJoin(ctx.relativeAppDir, ".env.local"),
+    posixJoin(ctx.relativeAppDir, ".env.production.local")
+  );
+  const resolvedFiles = await Promise.all(
+    includedFiles.map((globPattern) => (0, import_fast_glob.glob)(globPattern, { cwd: process.cwd() }))
+  );
+  for (const filePath of resolvedFiles.flat()) {
+    promises.push(
+      cp(
+        join(process.cwd(), filePath),
+        // the serverHandlerDir is aware of the dist dir.
+        // The distDir must not be the package path therefore we need to rely on the
+        // serverHandlerDir instead of the serverHandlerRootDir
+        // therefore we need to remove the package path from the filePath
+        join(ctx.serverHandlerDir, relative(ctx.relativeAppDir, filePath)),
+        {
+          recursive: true,
+          force: true
+        }
+      )
+    );
+  }
+  promises.push(
+    writeFile(
+      join(ctx.serverHandlerRuntimeModulesDir, "package.json"),
+      JSON.stringify({ type: "module" })
+    )
+  );
+  const fileList = await (0, import_fast_glob.glob)("dist/**/*", { cwd: ctx.pluginDir });
+  for (const filePath of fileList) {
+    promises.push(
+      cp(join(ctx.pluginDir, filePath), join(ctx.serverHandlerRuntimeModulesDir, filePath), {
+        recursive: true,
+        force: true
+      })
+    );
+  }
+  await Promise.all(promises);
+};
+var applyTemplateVariables = (template, variables) => {
+  return Object.entries(variables).reduce((acc, [key, value]) => {
+    return acc.replaceAll(key, value);
+  }, template);
+};
+var getHandlerFile = async (ctx) => {
+  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
+  const templateVariables = {
+    "{{useRegionalBlobs}}": ctx.useRegionalBlobs.toString()
+  };
+  if (ctx.relativeAppDir.length !== 0) {
+    const templateName2 = "nuxt-handler-monorepo.tmpl.js";
+    const template = await readFile(join(templatesDir, templateName2), "utf-8");
+    console.log("Lambda working directory:", ctx.lambdaWorkingDirectory);
+    console.log("Server handler path:", ctx.nuxtServerHandler);
+    templateVariables["{{cwd}}"] = posixJoin(ctx.lambdaWorkingDirectory);
+    templateVariables["{{nuxtServerHandler}}"] = posixJoin(ctx.nuxtServerHandler);
+    return applyTemplateVariables(template, templateVariables);
+  }
+  const templateName = "nuxt-handler.tmpl.js";
+  console.log(`Using 'Nuxt' handler template: ${templateName}`);
+  return applyTemplateVariables(
+    await readFile(join(templatesDir, templateName), "utf-8"),
+    templateVariables
+  );
+};
+var writeHandlerFile = async (ctx) => {
+  const handler = await getHandlerFile(ctx);
+  await writeFile(join(ctx.serverHandlerRootDir, `handler.js`), handler);
+};
+var createServerHandler = async (ctx) => {
+  await mkdir(join(ctx.serverHandlerRuntimeModulesDir), { recursive: true });
+  await copyHandlerDependencies(ctx);
+  await writeHandlerFile(ctx);
+  await verifyNuxtHandlerDirStructure(ctx);
+};
+async function patchNitroHandler(ctx) {
+  const fs = __require("fs");
+  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 = 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!");
+  const symbol = match[1];
+  let handlerCode = await fs.readFileSync(handlerTmplPath, "utf-8");
+  handlerCode = handlerCode.replace(/{{USE_NITRO_APP_SYMBOL}}/g, symbol);
+  await fs.writeFileSync(handlerTmplPath, handlerCode);
+}
+
+export {
+  createServerHandler,
+  patchNitroHandler
+};