@netlify/plugin-nextjs 5.1.1 → 5.2.0

package/dist/esm-chunks/chunk-3NYX5FXN.js

@@ -1,188 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-
-// src/build/plugin-context.ts
-import { readFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-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_PUBLISH_DIR = ".next";
-var SERVER_HANDLER_NAME = "___netlify-server-handler";
-var EDGE_HANDLER_NAME = "___netlify-edge-handler";
-var PluginContext = class {
-  utils;
-  netlifyConfig;
-  pluginName;
-  pluginVersion;
-  constants;
-  packageJSON;
-  /** Absolute path of the next runtime plugin directory */
-  pluginDir = PLUGIN_DIR;
-  get relPublishDir() {
-    return this.constants.PUBLISH_DIR ?? join(this.constants.PACKAGE_PATH || "", DEFAULT_PUBLISH_DIR);
-  }
-  /** Temporary directory for stashing the build output */
-  get tempPublishDir() {
-    return this.resolveFromPackagePath(".netlify/.next");
-  }
-  /** 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 Next.js RequiredServerFiles manifest
-   * @example ''
-   * @example 'apps/my-app'
-   */
-  get relativeAppDir() {
-    return this.requiredServerFiles.relativeAppDir ?? "";
-  }
-  /**
-   * The working directory inside the lambda that is used for monorepos to execute the serverless function
-   */
-  get lambdaWorkingDirectory() {
-    return join("/var/task", this.distDirParent);
-  }
-  /**
-   * Retrieves the root of the `.next/standalone` directory
-   */
-  get standaloneRootDir() {
-    return join(this.publishDir, "standalone");
-  }
-  /**
-   * The resolved relative next dist directory defaults to `.next`,
-   * but can be configured through the next.config.js. For monorepos this will include the packagePath
-   * If we need just the plain dist dir use the `nextDistDir`
-   */
-  get distDir() {
-    const dir = this.buildConfig.distDir ?? DEFAULT_PUBLISH_DIR;
-    return relative(process.cwd(), resolve(this.relativeAppDir, dir));
-  }
-  /** Represents the parent directory of the .next folder or custom distDir */
-  get distDirParent() {
-    return join(this.distDir, "..");
-  }
-  /** The `.next` folder or what the custom dist dir is set to */
-  get nextDistDir() {
-    return relative(this.distDirParent, this.distDir);
-  }
-  /** Retrieves the `.next/standalone/` directory monorepo aware */
-  get standaloneDir() {
-    return join(this.standaloneRootDir, this.distDirParent);
-  }
-  /**
-   * 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.resolveFromPackagePath(".netlify/static");
-  }
-  /**
-   * Absolute path of the directory that will be deployed to the blob store
-   * `.netlify/blobs/deploy`
-   */
-  get blobDir() {
-    return this.resolveFromPackagePath(".netlify/blobs/deploy");
-  }
-  /**
-   * Absolute path of the directory containing the files for the serverless lambda function
-   * `.netlify/functions-internal`
-   */
-  get serverFunctionsDir() {
-    return this.resolveFromPackagePath(".netlify/functions-internal");
-  }
-  /** Absolute path of the server handler */
-  get serverHandlerRootDir() {
-    return join(this.serverFunctionsDir, SERVER_HANDLER_NAME);
-  }
-  get serverHandlerDir() {
-    if (this.relativeAppDir.length === 0) {
-      return this.serverHandlerRootDir;
-    }
-    return join(this.serverHandlerRootDir, this.distDirParent);
-  }
-  get nextServerHandler() {
-    if (this.relativeAppDir.length !== 0) {
-      return join(this.lambdaWorkingDirectory, ".netlify/dist/run/handlers/server.js");
-    }
-    return "./.netlify/dist/run/handlers/server.js";
-  }
-  /**
-   * Absolute path of the directory containing the files for deno edge functions
-   * `.netlify/edge-functions`
-   */
-  get edgeFunctionsDir() {
-    return this.resolveFromPackagePath(".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;
-    this.netlifyConfig = options.netlifyConfig;
-  }
-  /** Resolves a path correctly with mono repository awareness for .netlify directories mainly  */
-  resolveFromPackagePath(...args) {
-    return resolve(this.constants.PACKAGE_PATH || "", ...args);
-  }
-  /** Resolves a path correctly from site directory */
-  resolveFromSiteDir(...args) {
-    return resolve(this.requiredServerFiles.appDir, ...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")
-    );
-  }
-  // don't make private as it is handy inside testing to override the config
-  _requiredServerFiles = null;
-  /** Get RequiredServerFiles manifest from build output **/
-  get requiredServerFiles() {
-    if (!this._requiredServerFiles) {
-      this._requiredServerFiles = JSON.parse(
-        readFileSync(join(this.publishDir, "required-server-files.json"), "utf-8")
-      );
-    }
-    return this._requiredServerFiles;
-  }
-  /** Get Next Config from build output **/
-  get buildConfig() {
-    return this.requiredServerFiles.config;
-  }
-  /**
-   * Get Next.js routes manifest from the build output
-   */
-  async getRoutesManifest() {
-    return JSON.parse(await readFile(join(this.publishDir, "routes-manifest.json"), "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-3SUDZQ7L.js

@@ -1,40 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  PLUGIN_DIR,
-  RUN_CONFIG
-} from "./chunk-UYKENJEU.js";
-
-// src/run/config.ts
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
-var getRunConfig = async () => {
-  return JSON.parse(await readFile(resolve(PLUGIN_DIR, RUN_CONFIG), "utf-8"));
-};
-var setRunConfig = (config) => {
-  const cacheHandler = join(PLUGIN_DIR, ".netlify/dist/run/handlers/cache.cjs");
-  if (!existsSync(cacheHandler)) {
-    throw new Error(`Cache handler not found at ${cacheHandler}`);
-  }
-  config.experimental = {
-    ...config.experimental,
-    incrementalCacheHandlerPath: cacheHandler
-  };
-  config.cacheHandler = cacheHandler;
-  config.cacheMaxMemorySize = 0;
-  process.env.__NEXT_PRIVATE_STANDALONE_CONFIG = JSON.stringify(config);
-};
-var getTagsManifest = async () => {
-  return JSON.parse(await readFile(resolve(PLUGIN_DIR, ".netlify/tags-manifest.json"), "utf-8"));
-};
-
-export {
-  getRunConfig,
-  setRunConfig,
-  getTagsManifest
-};

package/dist/esm-chunks/chunk-72ZI2IVI.js

@@ -1,36 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-
-// src/build/cache.ts
-import { existsSync } from "node:fs";
-import { rm } from "node:fs/promises";
-import { join } from "node:path";
-var saveBuildCache = async (ctx) => {
-  const { cache } = ctx.utils;
-  const cacheDir = join(ctx.publishDir, "cache");
-  if (existsSync(cacheDir)) {
-    await rm(join(cacheDir, "fetch-cache"), { recursive: true, force: true });
-    await cache.save(cacheDir);
-    console.log("Next.js cache saved");
-  } else {
-    console.log("No Next.js cache to save");
-  }
-};
-var restoreBuildCache = async (ctx) => {
-  const { cache } = ctx.utils;
-  const cacheDir = join(ctx.publishDir, "cache");
-  if (await cache.restore(cacheDir)) {
-    console.log("Next.js cache restored");
-  } else {
-    console.log("No Next.js cache to restore");
-  }
-};
-
-export {
-  saveBuildCache,
-  restoreBuildCache
-};

package/dist/esm-chunks/chunk-74THQNRG.js

@@ -1,110 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  encodeBlobKey
-} from "./chunk-TYCYFZ22.js";
-import {
-  wrapTracer
-} from "./chunk-PDPDW32D.js";
-import {
-  init_esm,
-  trace
-} from "./chunk-Y3K5Q6FP.js";
-import {
-  require_out
-} from "./chunk-VZNKO4OO.js";
-import {
-  __toESM
-} from "./chunk-5JVNISGM.js";
-
-// src/build/content/static.ts
-init_esm();
-import { existsSync } from "node:fs";
-import { cp, mkdir, rename, rm } from "node:fs/promises";
-import { basename, join } from "node:path";
-var import_fast_glob = __toESM(require_out(), 1);
-var tracer = wrapTracer(trace.getTracer("Next runtime"));
-var copyStaticContent = async (ctx) => {
-  return tracer.withActiveSpan("copyStaticContent", async () => {
-    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) => {
-          await cp(join(srcDir, path), join(destDir, await encodeBlobKey(path)), {
-            recursive: true,
-            force: true
-          });
-        })
-      );
-    } catch (error) {
-      ctx.failBuild("Failed assembling static pages for upload", error);
-    }
-  });
-};
-var copyStaticAssets = async (ctx) => {
-  return tracer.withActiveSpan("copyStaticAssets", async (span) => {
-    try {
-      await rm(ctx.staticDir, { recursive: true, force: true });
-      const { basePath } = await ctx.getRoutesManifest();
-      if (existsSync(ctx.resolveFromSiteDir("public"))) {
-        await cp(ctx.resolveFromSiteDir("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) {
-      span.end();
-      ctx.failBuild("Failed copying static assets", error);
-    }
-  });
-};
-var copyStaticExport = async (ctx) => {
-  await tracer.withActiveSpan("copyStaticExport", async () => {
-    try {
-      await rm(ctx.staticDir, { recursive: true, force: true });
-      await cp(ctx.resolveFromSiteDir("out"), ctx.staticDir, { recursive: true });
-    } catch (error) {
-      ctx.failBuild("Failed copying static export", error);
-    }
-  });
-};
-var publishStaticDir = async (ctx) => {
-  try {
-    await rm(ctx.tempPublishDir, { recursive: true, force: true });
-    await mkdir(basename(ctx.tempPublishDir), { recursive: true });
-    await rename(ctx.publishDir, ctx.tempPublishDir);
-    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.tempPublishDir)) {
-      await rename(ctx.publishDir, ctx.staticDir);
-      await rename(ctx.tempPublishDir, ctx.publishDir);
-    }
-  } catch {
-  }
-};
-
-export {
-  copyStaticContent,
-  copyStaticAssets,
-  copyStaticExport,
-  publishStaticDir,
-  unpublishStaticDir
-};

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

@@ -1,133 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  __require
-} from "./chunk-5JVNISGM.js";
-
-// src/build/advanced-api-routes.ts
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-var ApiRouteType = /* @__PURE__ */ ((ApiRouteType2) => {
-  ApiRouteType2["SCHEDULED"] = "experimental-scheduled";
-  ApiRouteType2["BACKGROUND"] = "experimental-background";
-  return ApiRouteType2;
-})(ApiRouteType || {});
-async function getAPIRoutesConfigs(ctx) {
-  const functionsConfigManifestPath = join(
-    ctx.publishDir,
-    "server",
-    "functions-config-manifest.json"
-  );
-  if (!existsSync(functionsConfigManifestPath)) {
-    return [];
-  }
-  const functionsConfigManifest = JSON.parse(
-    await readFile(functionsConfigManifestPath, "utf-8")
-  );
-  const appDir = ctx.resolveFromSiteDir(".");
-  const pagesDir = join(appDir, "pages");
-  const srcPagesDir = join(appDir, "src", "pages");
-  const { pageExtensions } = ctx.requiredServerFiles.config;
-  return Promise.all(
-    Object.keys(functionsConfigManifest.functions).map(async (apiRoute) => {
-      const filePath = getSourceFileForPage(apiRoute, [pagesDir, srcPagesDir], pageExtensions);
-      const sharedFields = {
-        apiRoute,
-        filePath,
-        config: {}
-      };
-      if (filePath) {
-        const config = await extractConfigFromFile(filePath, appDir);
-        return {
-          ...sharedFields,
-          config
-        };
-      }
-      return sharedFields;
-    })
-  );
-}
-var SOURCE_FILE_EXTENSIONS = ["js", "jsx", "ts", "tsx"];
-var getSourceFileForPage = (page, roots, pageExtensions = SOURCE_FILE_EXTENSIONS) => {
-  for (const root of roots) {
-    for (const extension of pageExtensions) {
-      const file = join(root, `${page}.${extension}`);
-      if (existsSync(file)) {
-        return file;
-      }
-      const fileAtFolderIndex = join(root, page, `index.${extension}`);
-      if (existsSync(fileAtFolderIndex)) {
-        return fileAtFolderIndex;
-      }
-    }
-  }
-};
-var findModuleFromBase = ({
-  paths,
-  candidates
-}) => {
-  for (const candidate of candidates) {
-    try {
-      const modulePath = __require.resolve(candidate, { paths });
-      if (modulePath) {
-        return modulePath;
-      }
-    } catch {
-    }
-  }
-  for (const candidate of candidates) {
-    try {
-      const modulePath = __require.resolve(candidate);
-      if (modulePath) {
-        return modulePath;
-      }
-    } catch {
-    }
-  }
-  return null;
-};
-var extractConstValue;
-var parseModule;
-var extractConfigFromFile = async (apiFilePath, appDir) => {
-  if (!apiFilePath || !existsSync(apiFilePath)) {
-    return {};
-  }
-  const extractConstValueModulePath = findModuleFromBase({
-    paths: [appDir],
-    candidates: ["next/dist/build/analysis/extract-const-value"]
-  });
-  const parseModulePath = findModuleFromBase({
-    paths: [appDir],
-    candidates: ["next/dist/build/analysis/parse-module"]
-  });
-  if (!extractConstValueModulePath || !parseModulePath) {
-    return {};
-  }
-  if (!extractConstValue && extractConstValueModulePath) {
-    extractConstValue = __require(extractConstValueModulePath);
-  }
-  if (!parseModule && parseModulePath) {
-    parseModule = __require(parseModulePath).parseModule;
-  }
-  const { extractExportedConstValue } = extractConstValue;
-  const fileContent = await readFile(apiFilePath, "utf8");
-  if (!fileContent.includes("config")) {
-    return {};
-  }
-  const ast = await parseModule(apiFilePath, fileContent);
-  try {
-    return extractExportedConstValue(ast, "config");
-  } catch {
-    return {};
-  }
-};
-
-export {
-  ApiRouteType,
-  getAPIRoutesConfigs
-};

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

@@ -1,127 +0,0 @@
-
-      var require = await (async () => {
-        var { createRequire } = await import("node:module");
-        return createRequire(import.meta.url);
-      })();
-    
-import {
-  copyNextDependencies,
-  copyNextServerCode,
-  verifyHandlerDirStructure,
-  writeTagsManifest
-} from "./chunk-ZKJEJNSJ.js";
-import {
-  wrapTracer
-} from "./chunk-PDPDW32D.js";
-import {
-  init_esm,
-  trace
-} from "./chunk-Y3K5Q6FP.js";
-import {
-  require_out
-} from "./chunk-VZNKO4OO.js";
-import {
-  SERVER_HANDLER_NAME
-} from "./chunk-3NYX5FXN.js";
-import {
-  __toESM
-} from "./chunk-5JVNISGM.js";
-
-// src/build/functions/server.ts
-init_esm();
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import { join, relative } from "node:path";
-import { join as posixJoin } from "node:path/posix";
-var import_fast_glob = __toESM(require_out(), 1);
-var tracer = wrapTracer(trace.getTracer("Next runtime"));
-var copyHandlerDependencies = async (ctx) => {
-  await tracer.withActiveSpan("copyHandlerDependencies", async (span) => {
-    const promises = [];
-    const { included_files: includedFiles = [] } = ctx.netlifyConfig.functions?.["*"] || {};
-    span.setAttribute("next.includedFiles", includedFiles.join(","));
-    if (includedFiles.length !== 0) {
-      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
-            }
-          )
-        );
-      }
-    }
-    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.serverHandlerDir, ".netlify", filePath), {
-          recursive: true,
-          force: true
-        })
-      );
-    }
-    await Promise.all(promises);
-  });
-};
-var writeHandlerManifest = async (ctx) => {
-  await writeFile(
-    join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.json`),
-    JSON.stringify({
-      config: {
-        name: "Next.js Server Handler",
-        generator: `${ctx.pluginName}@${ctx.pluginVersion}`,
-        nodeBundler: "none",
-        // the folders can vary in monorepos based on the folder structure of the user so we have to glob all
-        includedFiles: ["**"],
-        includedFilesBasePath: ctx.serverHandlerRootDir
-      },
-      version: 1
-    }),
-    "utf-8"
-  );
-};
-var writePackageMetadata = async (ctx) => {
-  await writeFile(
-    join(ctx.serverHandlerRootDir, "package.json"),
-    JSON.stringify({ type: "module" })
-  );
-};
-var getHandlerFile = async (ctx) => {
-  const templatesDir = join(ctx.pluginDir, "dist/build/templates");
-  if (ctx.relativeAppDir.length !== 0) {
-    const template = await readFile(join(templatesDir, "handler-monorepo.tmpl.js"), "utf-8");
-    return template.replaceAll("{{cwd}}", posixJoin(ctx.lambdaWorkingDirectory)).replace("{{nextServerHandler}}", posixJoin(ctx.nextServerHandler));
-  }
-  return await readFile(join(templatesDir, "handler.tmpl.js"), "utf-8");
-};
-var writeHandlerFile = async (ctx) => {
-  const handler = await getHandlerFile(ctx);
-  await writeFile(join(ctx.serverHandlerRootDir, `${SERVER_HANDLER_NAME}.mjs`), handler);
-};
-var createServerHandler = async (ctx) => {
-  await tracer.withActiveSpan("createServerHandler", async () => {
-    await rm(ctx.serverFunctionsDir, { recursive: true, force: true });
-    await mkdir(join(ctx.serverHandlerDir, ".netlify"), { recursive: true });
-    await copyNextServerCode(ctx);
-    await copyNextDependencies(ctx);
-    await writeTagsManifest(ctx);
-    await copyHandlerDependencies(ctx);
-    await writeHandlerManifest(ctx);
-    await writePackageMetadata(ctx);
-    await writeHandlerFile(ctx);
-    await verifyHandlerDirStructure(ctx);
-  });
-};
-
-export {
-  createServerHandler
-};