@netlify/plugin-nextjs 4.41.3 → 5.0.0-beta.0

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

@@ -0,0 +1,32 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  PLUGIN_DIR
+} from "./chunk-4AJYXTWN.js";
+
+// src/run/config.ts
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+var getRunConfig = async () => {
+  return JSON.parse(await readFile(resolve(".next/required-server-files.json"), "utf-8")).config;
+};
+var setRunConfig = (config) => {
+  config.experimental = {
+    ...config.experimental,
+    incrementalCacheHandlerPath: `${PLUGIN_DIR}/dist/run/handlers/cache.cjs`
+  };
+  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
+};
+var getTagsManifest = async () => {
+  return JSON.parse(await readFile(resolve(".netlify/tags-manifest.json"), "utf-8"));
+};
+
+export {
+  getRunConfig,
+  setRunConfig,
+  getTagsManifest
+};

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

@@ -0,0 +1,44 @@
+
+      const require = await (async () => {
+        const { 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-XD5TSLZO.js

@@ -0,0 +1,85 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  EDGE_HANDLER_NAME
+} from "./chunk-HPGTYMVD.js";
+
+// src/build/functions/edge.ts
+import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+var writeEdgeManifest = async (ctx, manifest) => {
+  await mkdir(ctx.edgeFunctionsDir, { recursive: true });
+  await writeFile(join(ctx.edgeFunctionsDir, "manifest.json"), JSON.stringify(manifest, null, 2));
+};
+var writeHandlerFile = async (ctx, { name }) => {
+  const handlerName = getHandlerName({ name });
+  await cp(
+    join(ctx.pluginDir, "edge-runtime"),
+    join(ctx.edgeFunctionsDir, handlerName, "edge-runtime"),
+    { recursive: true }
+  );
+  await writeFile(
+    join(ctx.edgeFunctionsDir, handlerName, `${handlerName}.js`),
+    `
+    import {handleMiddleware} from './edge-runtime/middleware.ts';
+    import handler from './server/${name}.js';
+    export default (req, context) => handleMiddleware(req, context, handler);
+    `
+  );
+};
+var copyHandlerDependencies = async (ctx, { name, files }) => {
+  const edgeRuntimePath = join(ctx.pluginDir, "edge-runtime");
+  const srcDir = ctx.resolve(".next/standalone/.next");
+  const shimPath = join(edgeRuntimePath, "shim/index.js");
+  const shim = await readFile(shimPath, "utf8");
+  const imports = `import './edge-runtime-webpack.js';`;
+  const exports = `export default _ENTRIES["middleware_${name}"].default;`;
+  await Promise.all(
+    files.map(async (file) => {
+      const destDir = join(ctx.edgeFunctionsDir, getHandlerName({ name }));
+      if (file === `server/${name}.js`) {
+        const entrypoint = await readFile(join(srcDir, file), "utf8");
+        const parts = [shim, imports, entrypoint, exports];
+        await mkdir(dirname(join(destDir, file)), { recursive: true });
+        await writeFile(join(destDir, file), parts.join("\n;"));
+        return;
+      }
+      await cp(join(srcDir, file), join(destDir, file));
+    })
+  );
+};
+var createEdgeHandler = async (ctx, definition) => {
+  await copyHandlerDependencies(ctx, definition);
+  await writeHandlerFile(ctx, definition);
+};
+var getHandlerName = ({ name }) => `${EDGE_HANDLER_NAME}-${name.replace(/\W/g, "-")}`;
+var buildHandlerDefinition = (ctx, { name, matchers, page }) => ({
+  function: getHandlerName({ name }),
+  name: name === "middleware" ? "Next.js Middleware Handler" : `Next.js Edge Handler: ${page}`,
+  pattern: matchers[0].regexp,
+  cache: name === "middleware" ? void 0 : "manual",
+  generator: `${ctx.pluginName}@${ctx.pluginVersion}`
+});
+var createEdgeHandlers = async (ctx) => {
+  await rm(ctx.edgeFunctionsDir, { recursive: true, force: true });
+  const nextManifest = await ctx.getMiddlewareManifest();
+  const nextDefinitions = [
+    ...Object.values(nextManifest.middleware)
+    // ...Object.values(nextManifest.functions)
+  ];
+  await Promise.all(nextDefinitions.map((def) => createEdgeHandler(ctx, def)));
+  const netlifyDefinitions = nextDefinitions.map((def) => buildHandlerDefinition(ctx, def));
+  const netlifyManifest = {
+    version: 1,
+    functions: netlifyDefinitions
+  };
+  await writeEdgeManifest(ctx, netlifyManifest);
+};
+
+export {
+  createEdgeHandlers
+};