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

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

@@ -0,0 +1,119 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/build/plugin-context.ts
+import { Buffer } from "node:buffer";
+import { readFileSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join, 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 SERVER_HANDLER_NAME = "___netlify-server-handler";
+var EDGE_HANDLER_NAME = "___netlify-edge-handler";
+var PluginContext = class {
+  utils;
+  pluginName;
+  pluginVersion;
+  constants;
+  packageJSON;
+  /** Absolute path of the next runtime plugin directory */
+  pluginDir = PLUGIN_DIR;
+  /** Absolute path of the publish directory */
+  get publishDir() {
+    return resolve(this.constants.PUBLISH_DIR);
+  }
+  /**
+   * Absolute path of the directory that is published and deployed to the Netlify CDN
+   * Will be swapped with the publish directory
+   * `.netlify/static`
+   */
+  get staticDir() {
+    return this.resolve(".netlify/static");
+  }
+  /**
+   * Absolute path of the directory that will be deployed to the blob store
+   * `.netlify/blobs/deploy`
+   */
+  get blobDir() {
+    return this.resolve(".netlify/blobs/deploy");
+  }
+  /**
+   * Absolute path of the directory containing the files for the serverless lambda function
+   * `.netlify/functions-internal`
+   */
+  get serverFunctionsDir() {
+    return this.resolve(".netlify/functions-internal");
+  }
+  /** Absolute path of the server handler */
+  get serverHandlerDir() {
+    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
+  }
+  /**
+   * Absolute path of the directory containing the files for deno edge functions
+   * `.netlify/edge-functions`
+   */
+  get edgeFunctionsDir() {
+    return this.resolve(".netlify/edge-functions");
+  }
+  /** Absolute path of the edge handler */
+  get edgeHandlerDir() {
+    return join(this.edgeFunctionsDir, EDGE_HANDLER_NAME);
+  }
+  constructor(options) {
+    this.packageJSON = JSON.parse(readFileSync(join(PLUGIN_DIR, "package.json"), "utf-8"));
+    this.pluginName = this.packageJSON.name;
+    this.pluginVersion = this.packageJSON.version;
+    this.constants = options.constants;
+    this.utils = options.utils;
+  }
+  /** Resolves a path correctly with mono repository awareness  */
+  resolve(...args) {
+    return resolve(this.constants.PACKAGE_PATH || "", ...args);
+  }
+  /** Get the next prerender-manifest.json */
+  async getPrerenderManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "prerender-manifest.json"), "utf-8"));
+  }
+  /**
+   * Get Next.js middleware config from the build output
+   */
+  async getMiddlewareManifest() {
+    return JSON.parse(
+      await readFile(join(this.publishDir, "server/middleware-manifest.json"), "utf-8")
+    );
+  }
+  /**
+   * Get Next.js routes manifest from the build output
+   */
+  async getRoutesManifest() {
+    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "utf-8"));
+  }
+  /**
+   * Write a cache entry to the blob upload directory using
+   * base64 keys to avoid collisions with directories
+   */
+  async writeCacheEntry(key, value) {
+    const path = join(this.blobDir, Buffer.from(key).toString("base64"));
+    const entry = JSON.stringify({
+      lastModified: Date.now(),
+      value
+    });
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, entry, "utf-8");
+  }
+  /** Fails a build with a message and an optional error */
+  failBuild(message, error) {
+    return this.utils.build.failBuild(message, error instanceof Error ? { error } : void 0);
+  }
+};
+
+export {
+  SERVER_HANDLER_NAME,
+  EDGE_HANDLER_NAME,
+  PluginContext
+};

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

@@ -0,0 +1,60 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+
+// src/run/systemlog.ts
+var systemLogTag = "__nfSystemLog";
+var serializeError = (error) => {
+  const cause = error?.cause instanceof Error ? serializeError(error.cause) : error.cause;
+  return {
+    error: error.message,
+    error_cause: cause,
+    error_stack: error.stack
+  };
+};
+var StructuredLogger = class _StructuredLogger {
+  fields;
+  message;
+  constructor(message, fields) {
+    this.fields = fields ?? {};
+    this.message = message ?? "";
+  }
+  // TODO: add sampling
+  doLog(logger2, message) {
+    logger2(systemLogTag, JSON.stringify({ msg: message, fields: this.fields }));
+  }
+  log(message) {
+    this.doLog(console.log, message);
+  }
+  info(message) {
+    this.doLog(console.info, message);
+  }
+  debug(message) {
+    this.doLog(console.debug, message);
+  }
+  warn(message) {
+    this.doLog(console.warn, message);
+  }
+  error(message) {
+    this.doLog(console.error, message);
+  }
+  withError(error) {
+    const fields = error instanceof Error ? serializeError(error) : { error };
+    return this.withFields(fields);
+  }
+  withFields(fields) {
+    return new _StructuredLogger(this.message, {
+      ...this.fields,
+      ...fields
+    });
+  }
+};
+var logger = new StructuredLogger();
+
+export {
+  StructuredLogger,
+  logger
+};

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

@@ -0,0 +1,78 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  require_out
+} from "./chunk-AVWFCGVE.js";
+import {
+  __toESM
+} from "./chunk-RSKIKBZH.js";
+
+// src/build/content/static.ts
+var import_fast_glob = __toESM(require_out(), 1);
+import { Buffer } from "node:buffer";
+import { existsSync } from "node:fs";
+import { cp, mkdir, rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+var copyStaticContent = async (ctx) => {
+  const srcDir = join(ctx.publishDir, "server/pages");
+  const destDir = ctx.blobDir;
+  const paths = await (0, import_fast_glob.default)("**/*.+(html|json)", {
+    cwd: srcDir,
+    extglob: true
+  });
+  try {
+    await Promise.all(
+      paths.filter((path) => !paths.includes(`${path.slice(0, -5)}.json`)).map(async (path) => {
+        const key = Buffer.from(path).toString("base64");
+        await cp(join(srcDir, path), join(destDir, key), { recursive: true });
+      })
+    );
+  } catch (error) {
+    ctx.failBuild("Failed assembling static pages for upload", error);
+  }
+};
+var copyStaticAssets = async (ctx) => {
+  try {
+    await rm(ctx.staticDir, { recursive: true, force: true });
+    const { basePath } = await ctx.getRoutesManifest();
+    if (existsSync(ctx.resolve("public"))) {
+      await cp(ctx.resolve("public"), join(ctx.staticDir, basePath), { recursive: true });
+    }
+    if (existsSync(join(ctx.publishDir, "static"))) {
+      await cp(join(ctx.publishDir, "static"), join(ctx.staticDir, basePath, "_next/static"), {
+        recursive: true
+      });
+    }
+  } catch (error) {
+    ctx.failBuild("Failed copying static assets", error);
+  }
+};
+var publishStaticDir = async (ctx) => {
+  try {
+    await mkdir(ctx.resolve(".netlify/.next"), { recursive: true });
+    await rename(ctx.publishDir, ctx.resolve(".netlify/.next"));
+    await rename(ctx.staticDir, ctx.publishDir);
+  } catch (error) {
+    ctx.failBuild("Failed publishing static content", error instanceof Error ? { error } : {});
+  }
+};
+var unpublishStaticDir = async (ctx) => {
+  try {
+    if (existsSync(ctx.resolve(".netlify/.next"))) {
+      await rename(ctx.publishDir, ctx.staticDir);
+      await rename(ctx.resolve(".netlify/.next"), ctx.publishDir);
+    }
+  } catch {
+  }
+};
+
+export {
+  copyStaticContent,
+  copyStaticAssets,
+  publishStaticDir,
+  unpublishStaticDir
+};

package/dist/index.js

@@ -0,0 +1,66 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  copyFetchContent,
+  copyPrerenderedContent
+} from "./esm-chunks/chunk-G3GM7JNF.js";
+import {
+  copyStaticAssets,
+  copyStaticContent,
+  publishStaticDir,
+  unpublishStaticDir
+} from "./esm-chunks/chunk-Z7ZMLVTM.js";
+import {
+  createEdgeHandlers
+} from "./esm-chunks/chunk-UXLNY5XK.js";
+import {
+  createServerHandler
+} from "./esm-chunks/chunk-NOX2JUQZ.js";
+import "./esm-chunks/chunk-A22224GM.js";
+import "./esm-chunks/chunk-AVWFCGVE.js";
+import {
+  restoreBuildCache,
+  saveBuildCache
+} from "./esm-chunks/chunk-GGHAQM5D.js";
+import {
+  PluginContext
+} from "./esm-chunks/chunk-VP3PT3VV.js";
+import "./esm-chunks/chunk-RSKIKBZH.js";
+
+// src/index.ts
+import { existsSync } from "node:fs";
+var onPreBuild = async (options) => {
+  process.env.NEXT_PRIVATE_STANDALONE = "true";
+  await restoreBuildCache(new PluginContext(options));
+};
+var onBuild = async (options) => {
+  const ctx = new PluginContext(options);
+  if (!existsSync(ctx.publishDir)) {
+    ctx.failBuild("Publish directory not found, please check your netlify.toml");
+  }
+  await saveBuildCache(ctx);
+  await Promise.all([
+    copyStaticAssets(ctx),
+    copyStaticContent(ctx),
+    copyPrerenderedContent(ctx),
+    copyFetchContent(ctx),
+    createServerHandler(ctx),
+    createEdgeHandlers(ctx)
+  ]);
+};
+var onPostBuild = async (options) => {
+  await publishStaticDir(new PluginContext(options));
+};
+var onEnd = async (options) => {
+  await unpublishStaticDir(new PluginContext(options));
+};
+export {
+  onBuild,
+  onEnd,
+  onPostBuild,
+  onPreBuild
+};

package/dist/run/config.js

@@ -0,0 +1,18 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  getRunConfig,
+  getTagsManifest,
+  setRunConfig
+} from "../esm-chunks/chunk-R4NHZWGU.js";
+import "../esm-chunks/chunk-4AJYXTWN.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  getRunConfig,
+  getTagsManifest,
+  setRunConfig
+};

package/dist/run/constants.js

@@ -0,0 +1,15 @@
+
+      const require = await (async () => {
+        const { createRequire } = await import("node:module");
+        return createRequire(import.meta.url);
+      })();
+    
+import {
+  MODULE_DIR,
+  PLUGIN_DIR
+} from "../esm-chunks/chunk-4AJYXTWN.js";
+import "../esm-chunks/chunk-RSKIKBZH.js";
+export {
+  MODULE_DIR,
+  PLUGIN_DIR
+};