@netlify/plugin-nextjs 4.0.0-rc.0 → 4.1.0

package/README.md

@@ -1,9 +1,6 @@
-![Next.js on Netlify Build Plugin](next-on-netlify.png)
+![Essential Next.js Build Plugin](next-on-netlify.png)
 
-# Essential Next.js Build Plugin (beta)
-
-:warning: This is the beta version of the Essential Next.js plugin. For the stable version, refer to
-[Essential Next.js plugin v3](https://github.com/netlify/netlify-plugin-nextjs/tree/v3#readme) :warning:
+# Essential Next.js Build Plugin
 
 <p align="center">
   <a aria-label="npm version" href="https://www.npmjs.com/package/@netlify/plugin-nextjs">
@@ -19,36 +16,46 @@
 Version 4 is a complete rewrite of the Essential Next.js plugin. For full details of everything that's new, check out
 [the v4 release notes](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/release-notes/v4.md)
 
-## Installing the beta
+## Installing the plugin
 
-- Install the module:
+The plugin installs automatically for new Next.js sites on Netlify. You can also install it manually like this:
 
 ```shell
-npm install -D @netlify/plugin-nextjs@beta
+npm install -D @netlify/plugin-nextjs
 ```
 
-- Change the `publish` directory to `.next` and add the plugin to `netlify.toml` if not already installed:
+...then add the plugin to your `netlify.toml` file:
 
 ```toml
-[build]
-publish = ".next"
-
 [[plugins]]
 package = "@netlify/plugin-nextjs"
 ```
 
-If you previously set a custom `distDir` in your `next.config.js`, or set `node_bundler` or `external_node_modules` in
-your `netlify.toml` these are no longer needed and can be removed.
+## Migrating from an older version of the plugin
+
+You can manually upgrade from the previous version of the plugin by running the following command:
+
+```shell
+npm install -D @netlify/plugin-nextjs@latest
+```
+
+Change the `publish` directory to `.next`:
+
+```toml
+[build]
+publish = ".next"
+```
+
+If you previously set these values, they're no longer needed and can be removed:
+
+- `distDir` in your `next.config.js`
+- `node_bundler = "esbuild"` in `netlify.toml`
+- `external_node_modules` in `netlify.toml`
 
 The `serverless` and `experimental-serverless-trace` targets are deprecated in Next 12, and all builds with this plugin
 will now use the default `server` target. If you previously set the target in your `next.config.js`, you should remove
 it.
 
-If you are using a monorepo you will need to change `publish` to point to the full path to the built `.next` directory,
-which may be in a subdirectory. If you have changed your `distDir` then it will need to match that.
-
-If you are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`.
-
 If you currently use redirects or rewrites on your site, see
 [the Rewrites and Redirects guide](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/redirects-rewrites.md)
 for information on changes to how they are handled in this version.
@@ -57,7 +64,29 @@ If you want to use Next 12's beta Middleware feature, this will mostly work as e
 [read the docs on some caveats and workarounds](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/middleware.md)
 that are currently needed.
 
-## Beta feedback
+## Monorepos
+
+If you are using a monorepo you will need to change `publish` to point to the full path to the built `.next` directory,
+which may be in a subdirectory. If you have changed your `distDir` then it will need to match that.
+
+If you are using Nx, then you will need to point `publish` to the folder inside `dist`, e.g. `dist/apps/myapp/.next`.
+
+## Incremental Static Regeneration (ISR)
+
+The Essential Next.js plugin now fully supports ISR on Netlify. For more details see
+[the ISR docs](https://github.com/netlify/netlify-plugin-nextjs/blob/main/docs/isr.md).
+
+## Use with `next export`
+
+If you are using `next export` to generate a static site, you do not need most of the functionality of this plugin and
+you can remove it. Alternatively you can
+[set the environment variable](https://docs.netlify.com/configure-builds/environment-variables/)
+`NETLIFY_NEXT_PLUGIN_SKIP` to `true` and the plugin will handle caching but won't generate any functions for SSR
+support. See [`demos/next-export`](https://github.com/netlify/netlify-plugin-nextjs/tree/main/demos/next-export) for an
+example.
+
+## Feedback
 
-Please share any thoughts, feedback or questions about the beta
-[in our discussion](https://github.com/netlify/netlify-plugin-nextjs/discussions/706).
+If you think you have found a bug in the plugin,
+[please open an issue](https://github.com/netlify/netlify-plugin-nextjs/issues). If you have comments or feature
+requests, [see the dicussion board](https://github.com/netlify/netlify-plugin-nextjs/discussions)

package/lib/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DYNAMIC_PARAMETER_REGEX = exports.OPTIONAL_CATCH_ALL_REGEX = exports.CATCH_ALL_REGEX = exports.DEFAULT_FUNCTIONS_SRC = exports.HANDLER_FUNCTION_PATH = exports.ODB_FUNCTION_PATH = exports.HIDDEN_PATHS = exports.IMAGE_FUNCTION_NAME = exports.ODB_FUNCTION_NAME = exports.HANDLER_FUNCTION_NAME = void 0;
+exports.DIVIDER = exports.LAMBDA_MAX_SIZE = exports.MINIMUM_REVALIDATE_SECONDS = exports.DYNAMIC_PARAMETER_REGEX = exports.OPTIONAL_CATCH_ALL_REGEX = exports.CATCH_ALL_REGEX = exports.DEFAULT_FUNCTIONS_SRC = exports.HANDLER_FUNCTION_PATH = exports.ODB_FUNCTION_PATH = exports.HIDDEN_PATHS = exports.IMAGE_FUNCTION_NAME = exports.ODB_FUNCTION_NAME = exports.HANDLER_FUNCTION_NAME = void 0;
 exports.HANDLER_FUNCTION_NAME = '___netlify-handler';
 exports.ODB_FUNCTION_NAME = '___netlify-odb-handler';
 exports.IMAGE_FUNCTION_NAME = '_ipx';
@@ -22,3 +22,9 @@ exports.DEFAULT_FUNCTIONS_SRC = 'netlify/functions';
 exports.CATCH_ALL_REGEX = /\/\[\.{3}(.*)](.json)?$/;
 exports.OPTIONAL_CATCH_ALL_REGEX = /\/\[{2}\.{3}(.*)]{2}(.json)?$/;
 exports.DYNAMIC_PARAMETER_REGEX = /\/\[(.*?)]/g;
+exports.MINIMUM_REVALIDATE_SECONDS = 60;
+// 50MB, which is the documented max, though the hard max seems to be higher
+exports.LAMBDA_MAX_SIZE = 1024 * 1024 * 50;
+exports.DIVIDER = `
+────────────────────────────────────────────────────────────────
+`;

package/lib/helpers/cache.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.saveCache = exports.restoreCache = void 0;
 const path_1 = require("path");
 const restoreCache = async ({ cache, publish }) => {
-    const cacheDir = path_1.posix.join(publish, 'cache');
+    const cacheDir = path_1.join(publish, 'cache');
     if (await cache.restore(cacheDir)) {
         console.log('Next.js cache restored.');
     }
@@ -13,8 +13,8 @@ const restoreCache = async ({ cache, publish }) => {
 };
 exports.restoreCache = restoreCache;
 const saveCache = async ({ cache, publish }) => {
-    const cacheDir = path_1.posix.join(publish, 'cache');
-    const buildManifest = path_1.posix.join(publish, 'build-manifest.json');
+    const cacheDir = path_1.join(publish, 'cache');
+    const buildManifest = path_1.join(publish, 'build-manifest.json');
     if (await cache.save(cacheDir, { digests: [buildManifest] })) {
         console.log('Next.js cache saved.');
     }

package/lib/helpers/config.js

@@ -13,7 +13,7 @@ const defaultFailBuild = (message, { error }) => {
 };
 const getNextConfig = async function getNextConfig({ publish, failBuild = defaultFailBuild, }) {
     try {
-        const { config, appDir, ignore } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(publish, 'required-server-files.json'));
+        const { config, appDir, ignore } = await fs_extra_1.readJSON(pathe_1.join(publish, 'required-server-files.json'));
         if (!config) {
             // eslint-disable-next-line @typescript-eslint/ban-ts-comment
             // @ts-ignore
@@ -28,7 +28,7 @@ const getNextConfig = async function getNextConfig({ publish, failBuild = defaul
 exports.getNextConfig = getNextConfig;
 const resolveModuleRoot = (moduleName) => {
     try {
-        return (0, pathe_1.dirname)((0, pathe_1.relative)(process.cwd(), require.resolve(`${moduleName}/package.json`, { paths: [process.cwd()] })));
+        return pathe_1.dirname(pathe_1.relative(process.cwd(), require.resolve(`${moduleName}/package.json`, { paths: [process.cwd()] })));
     }
     catch (error) {
         return null;
@@ -45,7 +45,7 @@ const configureHandlerFunctions = ({ netlifyConfig, publish, ignore = [] }) => {
         (_a = netlifyConfig.functions)[functionName] || (_a[functionName] = { included_files: [], external_node_modules: [] });
         netlifyConfig.functions[functionName].node_bundler = 'nft';
         (_b = netlifyConfig.functions[functionName]).included_files || (_b.included_files = []);
-        netlifyConfig.functions[functionName].included_files.push('.env', '.env.local', '.env.production', '.env.production.local', `${publish}/server/**`, `${publish}/serverless/**`, `${publish}/*.json`, `${publish}/BUILD_ID`, `${publish}/static/chunks/webpack-middleware*.js`, `!${publish}/server/**/*.js.nft.json`, ...ignore.map((path) => `!${(0, slash_1.default)(path)}`));
+        netlifyConfig.functions[functionName].included_files.push('.env', '.env.local', '.env.production', '.env.production.local', `${publish}/server/**`, `${publish}/serverless/**`, `${publish}/*.json`, `${publish}/BUILD_ID`, `${publish}/static/chunks/webpack-middleware*.js`, `!${publish}/server/**/*.js.nft.json`, ...ignore.map((path) => `!${slash_1.default(path)}`));
         const nextRoot = resolveModuleRoot('next');
         if (nextRoot) {
             netlifyConfig.functions[functionName].included_files.push(`!${nextRoot}/dist/server/lib/squoosh/**/*.wasm`, `!${nextRoot}/dist/next-server/server/lib/squoosh/**/*.wasm`, `!${nextRoot}/dist/compiled/webpack/bundle4.js`, `!${nextRoot}/dist/compiled/webpack/bundle5.js`, `!${nextRoot}/dist/compiled/terser/bundle.min.js`);

package/lib/helpers/files.js

@@ -1,14 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.movePublicFiles = exports.unpatchNextFiles = exports.patchNextFiles = exports.moveStaticPages = exports.matchesRewrite = exports.matchesRedirect = exports.matchMiddleware = exports.stripLocale = exports.isDynamicRoute = void 0;
 /* eslint-disable max-lines */
-const { cpus } = require('os');
-const { yellowBright } = require('chalk');
-const { existsSync, readJson, move, copy, writeJson, readFile, writeFile, ensureDir, readFileSync, } = require('fs-extra');
-const globby = require('globby');
-const { outdent } = require('outdent');
-const pLimit = require('p-limit');
-const { join } = require('pathe');
-const slash = require('slash');
+const os_1 = require("os");
+const chalk_1 = require("chalk");
+const fs_extra_1 = require("fs-extra");
+const globby_1 = __importDefault(require("globby"));
+const outdent_1 = require("outdent");
+const p_limit_1 = __importDefault(require("p-limit"));
+const pathe_1 = require("pathe");
+const slash_1 = __importDefault(require("slash"));
+const constants_1 = require("../constants");
 const TEST_ROUTE = /(|\/)\[[^/]+?](\/|\.html|$)/;
 const isDynamicRoute = (route) => TEST_ROUTE.test(route);
+exports.isDynamicRoute = isDynamicRoute;
 const stripLocale = (rawPath, locales = []) => {
     const [locale, ...segments] = rawPath.split('/');
     if (locales.includes(locale)) {
@@ -16,8 +24,10 @@ const stripLocale = (rawPath, locales = []) => {
     }
     return rawPath;
 };
+exports.stripLocale = stripLocale;
 const matchMiddleware = (middleware, filePath) => (middleware === null || middleware === void 0 ? void 0 : middleware.includes('')) ||
     (middleware === null || middleware === void 0 ? void 0 : middleware.find((middlewarePath) => filePath === middlewarePath || filePath === `${middlewarePath}.html` || filePath.startsWith(`${middlewarePath}/`)));
+exports.matchMiddleware = matchMiddleware;
 const matchesRedirect = (file, redirects) => {
     if (!Array.isArray(redirects)) {
         return false;
@@ -30,66 +40,67 @@ const matchesRedirect = (file, redirects) => {
         return new RegExp(redirect.regex).test(`/${file.slice(0, -5)}`);
     });
 };
+exports.matchesRedirect = matchesRedirect;
 const matchesRewrite = (file, rewrites) => {
     if (Array.isArray(rewrites)) {
-        return matchesRedirect(file, rewrites);
+        return exports.matchesRedirect(file, rewrites);
     }
     if (!Array.isArray(rewrites === null || rewrites === void 0 ? void 0 : rewrites.beforeFiles)) {
         return false;
     }
-    return matchesRedirect(file, rewrites.beforeFiles);
+    return exports.matchesRedirect(file, rewrites.beforeFiles);
 };
-exports.matchesRedirect = matchesRedirect;
 exports.matchesRewrite = matchesRewrite;
-exports.matchMiddleware = matchMiddleware;
-exports.stripLocale = stripLocale;
-exports.isDynamicRoute = isDynamicRoute;
 // eslint-disable-next-line max-lines-per-function
-exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
+const moveStaticPages = async ({ netlifyConfig, target, i18n, }) => {
     console.log('Moving static page files to serve from CDN...');
-    const outputDir = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
-    const root = join(outputDir, 'pages');
-    const buildId = readFileSync(join(netlifyConfig.build.publish, 'BUILD_ID'), 'utf8').trim();
-    const dataDir = join('_next', 'data', buildId);
-    await ensureDir(dataDir);
+    const outputDir = pathe_1.join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless');
+    const root = pathe_1.join(outputDir, 'pages');
+    const buildId = fs_extra_1.readFileSync(pathe_1.join(netlifyConfig.build.publish, 'BUILD_ID'), 'utf8').trim();
+    const dataDir = pathe_1.join('_next', 'data', buildId);
+    await fs_extra_1.ensureDir(dataDir);
     // Load the middleware manifest so we can check if a file matches it before moving
     let middleware;
-    const manifestPath = join(outputDir, 'middleware-manifest.json');
-    if (existsSync(manifestPath)) {
-        const manifest = await readJson(manifestPath);
+    const manifestPath = pathe_1.join(outputDir, 'middleware-manifest.json');
+    if (fs_extra_1.existsSync(manifestPath)) {
+        const manifest = await fs_extra_1.readJson(manifestPath);
         if (manifest === null || manifest === void 0 ? void 0 : manifest.middleware) {
             middleware = Object.keys(manifest.middleware).map((path) => path.slice(1));
         }
     }
-    const prerenderManifest = await readJson(join(netlifyConfig.build.publish, 'prerender-manifest.json'));
-    const { redirects, rewrites } = await readJson(join(netlifyConfig.build.publish, 'routes-manifest.json'));
+    const prerenderManifest = await fs_extra_1.readJson(pathe_1.join(netlifyConfig.build.publish, 'prerender-manifest.json'));
+    const { redirects, rewrites } = await fs_extra_1.readJson(pathe_1.join(netlifyConfig.build.publish, 'routes-manifest.json'));
     const isrFiles = new Set();
+    const shortRevalidateRoutes = [];
     Object.entries(prerenderManifest.routes).forEach(([route, { initialRevalidateSeconds }]) => {
         if (initialRevalidateSeconds) {
             // Find all files used by ISR routes
-            const trimmedPath = route.slice(1);
+            const trimmedPath = route === '/' ? 'index' : route.slice(1);
             isrFiles.add(`${trimmedPath}.html`);
             isrFiles.add(`${trimmedPath}.json`);
+            if (initialRevalidateSeconds < constants_1.MINIMUM_REVALIDATE_SECONDS) {
+                shortRevalidateRoutes.push({ Route: route, Revalidate: initialRevalidateSeconds });
+            }
         }
     });
     const files = [];
     const filesManifest = {};
     const moveFile = async (file) => {
         const isData = file.endsWith('.json');
-        const source = join(root, file);
-        const target = isData ? join(dataDir, file) : file;
+        const source = pathe_1.join(root, file);
+        const targetFile = isData ? pathe_1.join(dataDir, file) : file;
         files.push(file);
-        filesManifest[file] = target;
-        const dest = join(netlifyConfig.build.publish, target);
+        filesManifest[file] = targetFile;
+        const dest = pathe_1.join(netlifyConfig.build.publish, targetFile);
         try {
-            await move(source, dest);
+            await fs_extra_1.move(source, dest);
         }
         catch (error) {
             console.warn('Error moving file', source, error);
         }
     };
     // Move all static files, except error documents and nft manifests
-    const pages = await globby(['**/*.{html,json}', '!**/(500|404|*.js.nft).{html,json}'], {
+    const pages = await globby_1.default(['**/*.{html,json}', '!**/(500|404|*.js.nft).{html,json}'], {
         cwd: root,
         dot: true,
     });
@@ -98,27 +109,27 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
     const matchedRedirects = new Set();
     const matchedRewrites = new Set();
     // Limit concurrent file moves to number of cpus or 2 if there is only 1
-    const limit = pLimit(Math.max(2, cpus().length));
-    const promises = pages.map(async (rawPath) => {
-        const filePath = slash(rawPath);
+    const limit = p_limit_1.default(Math.max(2, os_1.cpus().length));
+    const promises = pages.map((rawPath) => {
+        const filePath = slash_1.default(rawPath);
         // Don't move ISR files, as they're used for the first request
         if (isrFiles.has(filePath)) {
             return;
         }
-        if (isDynamicRoute(filePath)) {
+        if (exports.isDynamicRoute(filePath)) {
             return;
         }
-        if (matchesRedirect(filePath, redirects)) {
+        if (exports.matchesRedirect(filePath, redirects)) {
             matchedRedirects.add(filePath);
             return;
         }
-        if (matchesRewrite(filePath, rewrites)) {
+        if (exports.matchesRewrite(filePath, rewrites)) {
             matchedRewrites.add(filePath);
             return;
         }
         // Middleware matches against the unlocalised path
-        const unlocalizedPath = stripLocale(rawPath, i18n === null || i18n === void 0 ? void 0 : i18n.locales);
-        const middlewarePath = matchMiddleware(middleware, unlocalizedPath);
+        const unlocalizedPath = exports.stripLocale(rawPath, i18n === null || i18n === void 0 ? void 0 : i18n.locales);
+        const middlewarePath = exports.matchMiddleware(middleware, unlocalizedPath);
         // If a file matches middleware it can't be offloaded to the CDN, and needs to stay at the origin to be served by next/server
         if (middlewarePath) {
             matchingMiddleware.add(middlewarePath);
@@ -130,81 +141,92 @@ exports.moveStaticPages = async ({ netlifyConfig, target, i18n }) => {
     await Promise.all(promises);
     console.log(`Moved ${files.length} files`);
     if (matchedPages.size !== 0) {
-        console.log(yellowBright(outdent `
+        console.log(chalk_1.yellowBright(outdent_1.outdent `
         Skipped moving ${matchedPages.size} ${matchedPages.size === 1 ? 'file because it matches' : 'files because they match'} middleware, so cannot be deployed to the CDN and will be served from the origin instead.
         This is fine, but we're letting you know because it may not be what you expect.
       `));
-        console.log(outdent `
+        console.log(outdent_1.outdent `
         The following middleware matched statically-rendered pages:
 
-        ${yellowBright([...matchingMiddleware].map((mid) => `- /${mid}/_middleware`).join('\n'))}
-
-        ────────────────────────────────────────────────────────────────
+        ${chalk_1.yellowBright([...matchingMiddleware].map((mid) => `- /${mid}/_middleware`).join('\n'))}
+        ${constants_1.DIVIDER}
       `);
         // There could potentially be thousands of matching pages, so we don't want to spam the console with this
         if (matchedPages.size < 50) {
-            console.log(outdent `
+            console.log(outdent_1.outdent `
           The following files matched middleware and were not moved to the CDN:
 
-          ${yellowBright([...matchedPages].map((mid) => `- ${mid}`).join('\n'))}
-
-          ────────────────────────────────────────────────────────────────
+          ${chalk_1.yellowBright([...matchedPages].map((mid) => `- ${mid}`).join('\n'))}
+          ${constants_1.DIVIDER}
         `);
         }
     }
     if (matchedRedirects.size !== 0 || matchedRewrites.size !== 0) {
-        console.log(yellowBright(outdent `
+        console.log(chalk_1.yellowBright(outdent_1.outdent `
         Skipped moving ${matchedRedirects.size + matchedRewrites.size} files because they match redirects or beforeFiles rewrites, so cannot be deployed to the CDN and will be served from the origin instead.
       `));
         if (matchedRedirects.size < 50 && matchedRedirects.size !== 0) {
-            console.log(outdent `
+            console.log(outdent_1.outdent `
           The following files matched redirects and were not moved to the CDN:
 
-          ${yellowBright([...matchedRedirects].map((mid) => `- ${mid}`).join('\n'))}
-
-          ────────────────────────────────────────────────────────────────
+          ${chalk_1.yellowBright([...matchedRedirects].map((mid) => `- ${mid}`).join('\n'))}
+          ${constants_1.DIVIDER}
         `);
         }
         if (matchedRewrites.size < 50 && matchedRewrites.size !== 0) {
-            console.log(outdent `
+            console.log(outdent_1.outdent `
           The following files matched beforeFiles rewrites and were not moved to the CDN:
 
-          ${yellowBright([...matchedRewrites].map((mid) => `- ${mid}`).join('\n'))}
-
-          ────────────────────────────────────────────────────────────────
+          ${chalk_1.yellowBright([...matchedRewrites].map((mid) => `- ${mid}`).join('\n'))}
+          ${constants_1.DIVIDER}
         `);
         }
     }
     // Write the manifest for use in the serverless functions
-    await writeJson(join(netlifyConfig.build.publish, 'static-manifest.json'), Object.entries(filesManifest));
+    await fs_extra_1.writeJson(pathe_1.join(netlifyConfig.build.publish, 'static-manifest.json'), Object.entries(filesManifest));
     if (i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) {
         // Copy the default locale into the root
-        const defaultLocaleDir = join(netlifyConfig.build.publish, i18n.defaultLocale);
-        if (existsSync(defaultLocaleDir)) {
-            await copy(defaultLocaleDir, `${netlifyConfig.build.publish}/`);
+        const defaultLocaleDir = pathe_1.join(netlifyConfig.build.publish, i18n.defaultLocale);
+        if (fs_extra_1.existsSync(defaultLocaleDir)) {
+            await fs_extra_1.copy(defaultLocaleDir, `${netlifyConfig.build.publish}/`);
         }
-        const defaultLocaleIndex = join(netlifyConfig.build.publish, `${i18n.defaultLocale}.html`);
-        const indexHtml = join(netlifyConfig.build.publish, 'index.html');
-        if (existsSync(defaultLocaleIndex) && !existsSync(indexHtml)) {
+        const defaultLocaleIndex = pathe_1.join(netlifyConfig.build.publish, `${i18n.defaultLocale}.html`);
+        const indexHtml = pathe_1.join(netlifyConfig.build.publish, 'index.html');
+        if (fs_extra_1.existsSync(defaultLocaleIndex) && !fs_extra_1.existsSync(indexHtml)) {
             try {
-                await copy(defaultLocaleIndex, indexHtml, { overwrite: false });
-                await copy(join(netlifyConfig.build.publish, `${i18n.defaultLocale}.json`), join(netlifyConfig.build.publish, 'index.json'), { overwrite: false });
+                await fs_extra_1.copy(defaultLocaleIndex, indexHtml, { overwrite: false });
+                await fs_extra_1.copy(pathe_1.join(netlifyConfig.build.publish, `${i18n.defaultLocale}.json`), pathe_1.join(netlifyConfig.build.publish, 'index.json'), { overwrite: false });
             }
             catch { }
         }
     }
+    if (shortRevalidateRoutes.length !== 0) {
+        console.log(outdent_1.outdent `
+      The following routes use "revalidate" values of under ${constants_1.MINIMUM_REVALIDATE_SECONDS} seconds, which is not supported.
+      They will use a revalidate time of ${constants_1.MINIMUM_REVALIDATE_SECONDS} seconds instead.
+    `);
+        console.table(shortRevalidateRoutes);
+        // TODO: add these docs
+        // console.log(
+        //   outdent`
+        //     For more information, see https://ntl.fyi/next-revalidate-time
+        //     ${DIVIDER}
+        //   `,
+        // )
+    }
 };
+exports.moveStaticPages = moveStaticPages;
 const patchFile = async ({ file, from, to }) => {
-    if (!existsSync(file)) {
+    if (!fs_extra_1.existsSync(file)) {
         return;
     }
-    const content = await readFile(file, 'utf8');
+    const content = await fs_extra_1.readFile(file, 'utf8');
     if (content.includes(to)) {
         return;
     }
     const newContent = content.replace(from, to);
-    await writeFile(`${file}.orig`, content);
-    await writeFile(file, newContent);
+    await fs_extra_1.writeFile(`${file}.orig`, content);
+    await fs_extra_1.writeFile(file, newContent);
 };
 const getServerFile = (root) => {
     let serverFile;
@@ -225,7 +247,7 @@ const getServerFile = (root) => {
     }
     return serverFile;
 };
-exports.patchNextFiles = async (root) => {
+const patchNextFiles = async (root) => {
     const serverFile = getServerFile(root);
     console.log(`Patching ${serverFile}`);
     if (serverFile) {
@@ -236,23 +258,26 @@ exports.patchNextFiles = async (root) => {
         });
     }
 };
-exports.unpatchNextFiles = async (root) => {
+exports.patchNextFiles = patchNextFiles;
+const unpatchNextFiles = async (root) => {
     const serverFile = getServerFile(root);
     const origFile = `${serverFile}.orig`;
-    if (existsSync(origFile)) {
-        await move(origFile, serverFile, { overwrite: true });
+    if (fs_extra_1.existsSync(origFile)) {
+        await fs_extra_1.move(origFile, serverFile, { overwrite: true });
     }
 };
-exports.movePublicFiles = async ({ appDir, outdir, publish }) => {
+exports.unpatchNextFiles = unpatchNextFiles;
+const movePublicFiles = async ({ appDir, outdir, publish, }) => {
     // `outdir` is a config property added when using Next.js with Nx. It's typically
     // a relative path outside of the appDir, e.g. '../../dist/apps/<app-name>', and
     // the parent directory of the .next directory.
     // If it exists, copy the files from the public folder there in order to include
     // any files that were generated during the build. Otherwise, copy the public
     // directory from the original app directory.
-    const publicDir = outdir ? join(appDir, outdir, 'public') : join(appDir, 'public');
-    if (existsSync(publicDir)) {
-        await copy(publicDir, `${publish}/`);
+    const publicDir = outdir ? pathe_1.join(appDir, outdir, 'public') : pathe_1.join(appDir, 'public');
+    if (fs_extra_1.existsSync(publicDir)) {
+        await fs_extra_1.copy(publicDir, `${publish}/`);
     }
 };
+exports.movePublicFiles = movePublicFiles;
 /* eslint-enable max-lines */

package/lib/helpers/functions.js

@@ -9,14 +9,14 @@ const getPageResolver_1 = require("../templates/getPageResolver");
 const generateFunctions = async ({ FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
     const functionsDir = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
     const bridgeFile = require.resolve('@vercel/node/dist/bridge');
-    const functionDir = (0, pathe_1.join)(process.cwd(), functionsDir, constants_1.HANDLER_FUNCTION_NAME);
-    const publishDir = (0, pathe_1.relative)(functionDir, (0, pathe_1.join)(process.cwd(), PUBLISH_DIR));
+    const functionDir = pathe_1.join(process.cwd(), functionsDir, constants_1.HANDLER_FUNCTION_NAME);
+    const publishDir = pathe_1.relative(functionDir, pathe_1.join(process.cwd(), PUBLISH_DIR));
     const writeHandler = async (func, isODB) => {
-        const handlerSource = await (0, getHandler_1.getHandler)({ isODB, publishDir, appDir: (0, pathe_1.relative)(functionDir, appDir) });
-        await (0, fs_extra_1.ensureDir)((0, pathe_1.join)(functionsDir, func));
-        await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsDir, func, `${func}.js`), handlerSource);
-        await (0, fs_extra_1.copyFile)(bridgeFile, (0, pathe_1.join)(functionsDir, func, 'bridge.js'));
-        await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), (0, pathe_1.join)(functionsDir, func, 'handlerUtils.js'));
+        const handlerSource = await getHandler_1.getHandler({ isODB, publishDir, appDir: pathe_1.relative(functionDir, appDir) });
+        await fs_extra_1.ensureDir(pathe_1.join(functionsDir, func));
+        await fs_extra_1.writeFile(pathe_1.join(functionsDir, func, `${func}.js`), handlerSource);
+        await fs_extra_1.copyFile(bridgeFile, pathe_1.join(functionsDir, func, 'bridge.js'));
+        await fs_extra_1.copyFile(pathe_1.join(__dirname, '..', '..', 'lib', 'templates', 'handlerUtils.js'), pathe_1.join(functionsDir, func, 'handlerUtils.js'));
     };
     await writeHandler(constants_1.HANDLER_FUNCTION_NAME, false);
     await writeHandler(constants_1.ODB_FUNCTION_NAME, true);
@@ -26,27 +26,27 @@ exports.generateFunctions = generateFunctions;
  * Writes a file in each function directory that contains references to every page entrypoint.
  * This is just so that the nft bundler knows about them. We'll eventually do this better.
  */
-const generatePagesResolver = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC }, netlifyConfig, target, }) => {
+const generatePagesResolver = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC, PUBLISH_DIR }, target, }) => {
     const functionsPath = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
-    const jsSource = await (0, getPageResolver_1.getPageResolver)({
-        netlifyConfig,
+    const jsSource = await getPageResolver_1.getPageResolver({
+        publish: PUBLISH_DIR,
         target,
     });
-    await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsPath, constants_1.ODB_FUNCTION_NAME, 'pages.js'), jsSource);
-    await (0, fs_extra_1.writeFile)((0, pathe_1.join)(functionsPath, constants_1.HANDLER_FUNCTION_NAME, 'pages.js'), jsSource);
+    await fs_extra_1.writeFile(pathe_1.join(functionsPath, constants_1.ODB_FUNCTION_NAME, 'pages.js'), jsSource);
+    await fs_extra_1.writeFile(pathe_1.join(functionsPath, constants_1.HANDLER_FUNCTION_NAME, 'pages.js'), jsSource);
 };
 exports.generatePagesResolver = generatePagesResolver;
 // Move our next/image function into the correct functions directory
 const setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = constants_1.DEFAULT_FUNCTIONS_SRC }, imageconfig = {}, netlifyConfig, basePath, }) => {
     const functionsPath = INTERNAL_FUNCTIONS_SRC || FUNCTIONS_SRC;
     const functionName = `${constants_1.IMAGE_FUNCTION_NAME}.js`;
-    const functionDirectory = (0, pathe_1.join)(functionsPath, constants_1.IMAGE_FUNCTION_NAME);
-    await (0, fs_extra_1.ensureDir)(functionDirectory);
-    await (0, fs_extra_1.writeJSON)((0, pathe_1.join)(functionDirectory, 'imageconfig.json'), {
+    const functionDirectory = pathe_1.join(functionsPath, constants_1.IMAGE_FUNCTION_NAME);
+    await fs_extra_1.ensureDir(functionDirectory);
+    await fs_extra_1.writeJSON(pathe_1.join(functionDirectory, 'imageconfig.json'), {
         ...imageconfig,
         basePath: [basePath, constants_1.IMAGE_FUNCTION_NAME].join('/'),
     });
-    await (0, fs_extra_1.copyFile)((0, pathe_1.join)(__dirname, '..', '..', 'lib', 'templates', 'ipx.js'), (0, pathe_1.join)(functionDirectory, functionName));
+    await fs_extra_1.copyFile(pathe_1.join(__dirname, '..', '..', 'lib', 'templates', 'ipx.js'), pathe_1.join(functionDirectory, functionName));
     const imagePath = imageconfig.path || '/_next/image';
     netlifyConfig.redirects.push({
         from: `${imagePath}*`,

package/lib/helpers/redirects.js

@@ -1,9 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRedirects = void 0;
-const chalk_1 = require("chalk");
+exports.generateRedirects = exports.generateStaticRedirects = void 0;
 const fs_extra_1 = require("fs-extra");
-const outdent_1 = require("outdent");
+const globby_1 = __importDefault(require("globby"));
 const pathe_1 = require("pathe");
 const constants_1 = require("../constants");
 const utils_1 = require("./utils");
@@ -35,8 +37,16 @@ const generateLocaleRedirects = ({ i18n, basePath, trailingSlash, }) => {
     });
     return redirects;
 };
-const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash }, }) => {
-    const { dynamicRoutes, routes: staticRoutes } = await (0, fs_extra_1.readJSON)((0, pathe_1.join)(netlifyConfig.build.publish, 'prerender-manifest.json'));
+const generateStaticRedirects = ({ netlifyConfig, nextConfig: { i18n, basePath }, }) => {
+    // Static files are in `static`
+    netlifyConfig.redirects.push({ from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 });
+    if (i18n) {
+        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
+    }
+};
+exports.generateStaticRedirects = generateStaticRedirects;
+const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath, trailingSlash, appDir }, }) => {
+    const { dynamicRoutes, routes: staticRoutes } = await fs_extra_1.readJSON(pathe_1.join(netlifyConfig.build.publish, 'prerender-manifest.json'));
     netlifyConfig.redirects.push(...constants_1.HIDDEN_PATHS.map((path) => ({
         from: `${basePath}${path}`,
         to: '/404.html',
@@ -49,7 +59,6 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     const dataRedirects = [];
     const pageRedirects = [];
     const isrRedirects = [];
-    let hasIsr = false;
     const dynamicRouteEntries = Object.entries(dynamicRoutes);
     const staticRouteEntries = Object.entries(staticRoutes);
     staticRouteEntries.forEach(([route, { dataRoute, initialRevalidateSeconds }]) => {
@@ -61,24 +70,19 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
         if ((i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) && route.startsWith(`/${i18n.defaultLocale}/`)) {
             route = route.slice(i18n.defaultLocale.length + 1);
         }
-        hasIsr = true;
-        isrRedirects.push(...(0, utils_1.netlifyRoutesForNextRoute)(dataRoute), ...(0, utils_1.netlifyRoutesForNextRoute)(route));
+        isrRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute), ...utils_1.netlifyRoutesForNextRoute(route));
     });
     dynamicRouteEntries.forEach(([route, { dataRoute, fallback }]) => {
         // Add redirects if fallback is "null" (aka blocking) or true/a string
         if (fallback === false) {
             return;
         }
-        pageRedirects.push(...(0, utils_1.netlifyRoutesForNextRoute)(route));
-        dataRedirects.push(...(0, utils_1.netlifyRoutesForNextRoute)(dataRoute));
+        pageRedirects.push(...utils_1.netlifyRoutesForNextRoute(route));
+        dataRedirects.push(...utils_1.netlifyRoutesForNextRoute(dataRoute));
     });
-    if (i18n) {
-        netlifyConfig.redirects.push({ from: `${basePath}/:locale/_next/static/*`, to: `/static/:splat`, status: 200 });
-    }
+    const publicFiles = await globby_1.default('**/*', { cwd: pathe_1.join(appDir, 'public') });
     // This is only used in prod, so dev uses `next dev` directly
     netlifyConfig.redirects.push(
-    // Static files are in `static`
-    { from: `${basePath}/_next/static/*`, to: `/static/:splat`, status: 200 }, 
     // API routes always need to be served from the regular function
     {
         from: `${basePath}/api`,
@@ -89,20 +93,24 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
         to: constants_1.HANDLER_FUNCTION_PATH,
         status: 200,
     }, 
-    // Preview mode gets forced to the function, to bypess pre-rendered pages
-    {
+    // Preview mode gets forced to the function, to bypass pre-rendered pages, but static files need to be skipped
+    ...publicFiles.map((file) => ({
+        from: `${basePath}/${file}`,
+        // This is a no-op, but we do it to stop it matching the following rule
+        to: `${basePath}/${file}`,
+        conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
+        status: 200,
+    })), {
         from: `${basePath}/*`,
         to: constants_1.HANDLER_FUNCTION_PATH,
         status: 200,
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore The conditions type is incorrect
         conditions: { Cookie: ['__prerender_bypass', '__next_preview_data'] },
         force: true,
     }, 
     // ISR redirects are handled by the regular function. Forced to avoid pre-rendered pages
     ...isrRedirects.map((redirect) => ({
         from: `${basePath}${redirect}`,
-        to: process.env.EXPERIMENTAL_ODB_TTL ? constants_1.ODB_FUNCTION_PATH : constants_1.HANDLER_FUNCTION_PATH,
+        to: constants_1.ODB_FUNCTION_PATH,
         status: 200,
         force: true,
     })), 
@@ -121,10 +129,5 @@ const generateRedirects = async ({ netlifyConfig, nextConfig: { i18n, basePath,
     })), 
     // Everything else is handled by the regular function
     { from: `${basePath}/*`, to: constants_1.HANDLER_FUNCTION_PATH, status: 200 });
-    if (hasIsr) {
-        console.log((0, chalk_1.yellowBright)((0, outdent_1.outdent) `
-        You have some pages that use ISR (pages that use getStaticProps with revalidate set), which is not currently fully-supported by this plugin. Be aware that results may be unreliable.
-      `));
-    }
 };
 exports.generateRedirects = generateRedirects;

package/lib/helpers/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.netlifyRoutesForNextRoute = void 0;
+exports.shouldSkip = exports.netlifyRoutesForNextRoute = void 0;
 const constants_1 = require("../constants");
 const netlifyRoutesForNextRoute = (nextRoute) => {
     const netlifyRoutes = [nextRoute];
@@ -30,3 +30,8 @@ const netlifyRoutesForNextRoute = (nextRoute) => {
         .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
 };
 exports.netlifyRoutesForNextRoute = netlifyRoutesForNextRoute;
+const shouldSkip = () => process.env.NEXT_PLUGIN_FORCE_RUN === 'false' ||
+    process.env.NEXT_PLUGIN_FORCE_RUN === '0' ||
+    process.env.NETLIFY_NEXT_PLUGIN_SKIP === 'true' ||
+    process.env.NETLIFY_NEXT_PLUGIN_SKIP === '1';
+exports.shouldSkip = shouldSkip;

package/lib/helpers/verification.js

@@ -1,94 +1,156 @@
-const { existsSync, promises } = require('fs');
-const path = require('path');
-const { relative } = require('path');
-const { yellowBright, greenBright, blueBright, redBright, reset } = require('chalk');
-const { async: StreamZip } = require('node-stream-zip');
-const outdent = require('outdent');
-const prettyBytes = require('pretty-bytes');
-const { satisfies } = require('semver');
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.warnForProblematicUserRewrites = exports.getProblematicUserRewrites = exports.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+/* eslint-disable max-lines */
+const fs_1 = require("fs");
+const path_1 = __importStar(require("path"));
+const chalk_1 = require("chalk");
+const node_stream_zip_1 = require("node-stream-zip");
+const outdent_1 = require("outdent");
+const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
+const semver_1 = require("semver");
+const constants_1 = require("../constants");
 // This is when nft support was added
 const REQUIRED_BUILD_VERSION = '>=18.16.0';
-exports.verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild }) => {
+const verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuild, }) => {
     // We check for build version because that's what's available to us, but prompt about the cli because that's what they can upgrade
-    if (IS_LOCAL && !satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
-        return failBuild(outdent `
+    if (IS_LOCAL && !semver_1.satisfies(NETLIFY_BUILD_VERSION, REQUIRED_BUILD_VERSION, { includePrerelease: true })) {
+        return failBuild(outdent_1.outdent `
       This version of the Essential Next.js plugin requires netlify-cli@6.12.4 or higher. Please upgrade and try again.
       You can do this by running: "npm install -g netlify-cli@latest" or "yarn global add netlify-cli@latest"
     `);
     }
 };
-exports.checkForOldFunctions = async ({ functions }) => {
+exports.verifyNetlifyBuildVersion = verifyNetlifyBuildVersion;
+const checkForOldFunctions = async ({ functions }) => {
     const allOldFunctions = await functions.list();
     const oldFunctions = allOldFunctions.filter(({ name }) => name.startsWith('next_'));
     if (oldFunctions.length !== 0) {
-        console.log(yellowBright(outdent `
+        console.log(chalk_1.yellowBright(outdent_1.outdent `
         We have found the following functions in your site that seem to be left over from the old Next.js plugin (v3). We have guessed this because the name starts with "next_".
 
-        ${reset(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
+        ${chalk_1.reset(oldFunctions.map(({ name }) => `- ${name}`).join('\n'))}
 
         If they were created by the old plugin, these functions are likely to cause errors so should be removed. You can do this by deleting the following directories:
 
-        ${reset(oldFunctions.map(({ mainFile }) => `- ${path.relative(process.cwd(), path.dirname(mainFile))}`).join('\n'))}
+        ${chalk_1.reset(oldFunctions.map(({ mainFile }) => `- ${path_1.default.relative(process.cwd(), path_1.default.dirname(mainFile))}`).join('\n'))}
       `));
     }
 };
-exports.checkNextSiteHasBuilt = ({ publish, failBuild }) => {
-    if (!existsSync(path.join(publish, 'BUILD_ID'))) {
-        return failBuild(outdent `
-      The directory "${path.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory. 
-      In most cases it should be set to the site's ".next" directory path, unless you have chosen a custom "distDir" in your Next config. 
-      If you are using "next export" then the Essential Next.js plugin should be removed. See https://ntl.fyi/remove-plugin for details.
+exports.checkForOldFunctions = checkForOldFunctions;
+const checkNextSiteHasBuilt = ({ publish, failBuild, }) => {
+    if (!fs_1.existsSync(path_1.default.join(publish, 'BUILD_ID'))) {
+        const outWarning = path_1.default.basename(publish) === 'out'
+            ? `Your publish directory is set to "out", but in most cases it should be ".next".`
+            : `In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config.`;
+        return failBuild(outdent_1.outdent `
+      The directory "${path_1.default.relative(process.cwd(), publish)}" does not contain a Next.js production build. Perhaps the build command was not run, or you specified the wrong publish directory.
+      ${outWarning}
+      If you are using "next export" then you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
     }
-    if (existsSync(path.join(publish, 'export-detail.json'))) {
-        failBuild(outdent `
+    if (fs_1.existsSync(path_1.default.join(publish, 'export-detail.json'))) {
+        failBuild(outdent_1.outdent `
       Detected that "next export" was run, but site is incorrectly publishing the ".next" directory.
-      This plugin is not needed for "next export" so should be removed, and publish directory set to "out".
-      See https://ntl.fyi/remove-plugin for more details on how to remove this plugin.
+      The publish directory should be set to "out", and you should set the environment variable NETLIFY_NEXT_PLUGIN_SKIP to "true".
     `);
     }
 };
-exports.checkForRootPublish = ({ publish, failBuild }) => {
-    if (path.resolve(publish) === path.resolve('.')) {
-        failBuild(outdent `
+exports.checkNextSiteHasBuilt = checkNextSiteHasBuilt;
+const checkForRootPublish = ({ publish, failBuild, }) => {
+    if (path_1.default.resolve(publish) === path_1.default.resolve('.')) {
+        failBuild(outdent_1.outdent `
       Your publish directory is pointing to the base directory of your site. This is not supported for Next.js sites, and is probably a mistake. 
       In most cases it should be set to ".next", unless you have chosen a custom "distDir" in your Next config, or the Next site is in a subdirectory.
     `);
     }
 };
-// 50MB, which is the documented max, though the hard max seems to be higher
-const LAMBDA_MAX_SIZE = 1024 * 1024 * 50;
-exports.checkZipSize = async (file, maxSize = LAMBDA_MAX_SIZE) => {
-    if (!existsSync(file)) {
+exports.checkForRootPublish = checkForRootPublish;
+const checkZipSize = async (file, maxSize = constants_1.LAMBDA_MAX_SIZE) => {
+    if (!fs_1.existsSync(file)) {
         console.warn(`Could not check zip size because ${file} does not exist`);
         return;
     }
-    const size = await promises.stat(file).then(({ size }) => size);
-    if (size < maxSize) {
+    const fileSize = await fs_1.promises.stat(file).then(({ size }) => size);
+    if (fileSize < maxSize) {
         return;
     }
     // We don't fail the build, because the actual hard max size is larger so it might still succeed
-    console.log(redBright(outdent `
-      The function zip ${yellowBright(relative(process.cwd(), file))} size is ${prettyBytes(size)}, which is larger than the maximum supported size of ${prettyBytes(maxSize)}.
+    console.log(chalk_1.redBright(outdent_1.outdent `
+      The function zip ${chalk_1.yellowBright(path_1.relative(process.cwd(), file))} size is ${pretty_bytes_1.default(fileSize)}, which is larger than the maximum supported size of ${pretty_bytes_1.default(maxSize)}.
       There are a few reasons this could happen. You may have accidentally bundled a large dependency, or you might have a
       large number of pre-rendered pages included.
     `));
-    const zip = new StreamZip({ file });
+    const zip = new node_stream_zip_1.async({ file });
     console.log(`Contains ${await zip.entriesCount} files`);
     const sortedFiles = Object.values(await zip.entries()).sort((a, b) => b.size - a.size);
     const largest = {};
     for (let i = 0; i < 10 && i < sortedFiles.length; i++) {
         largest[`${i + 1}`] = {
             File: sortedFiles[i].name,
-            'Compressed Size': prettyBytes(sortedFiles[i].compressedSize),
-            'Uncompressed Size': prettyBytes(sortedFiles[i].size),
+            'Compressed Size': pretty_bytes_1.default(sortedFiles[i].compressedSize),
+            'Uncompressed Size': pretty_bytes_1.default(sortedFiles[i].size),
         };
     }
-    console.log(yellowBright `\n\nThese are the largest files in the zip:`);
+    console.log(chalk_1.yellowBright `\n\nThese are the largest files in the zip:`);
     console.table(largest);
-    console.log(greenBright `\n\nFor more information on fixing this, see ${blueBright `https://ntl.fyi/large-next-functions`}`);
+    console.log(chalk_1.greenBright `\n\nFor more information on fixing this, see ${chalk_1.blueBright `https://ntl.fyi/large-next-functions`}`);
 };
-exports.logBetaMessage = () => console.log(greenBright(outdent `
-        Thank you for trying the Essential Next.js beta plugin. 
-        Please share feedback (both good and bad) at ${blueBright `https://ntl.fyi/next-beta-feedback`}
-      `));
+exports.checkZipSize = checkZipSize;
+const getProblematicUserRewrites = ({ redirects, basePath, }) => {
+    const userRewrites = [];
+    for (const redirect of redirects) {
+        // This is the first of the plugin-generated redirects so we can stop checking
+        if (redirect.from === `${basePath}/_next/static/*` && redirect.to === `/static/:splat` && redirect.status === 200) {
+            break;
+        }
+        if (
+        // Redirects are fine
+        (redirect.status === 200 || redirect.status === 404) &&
+            // Rewriting to a function is also fine
+            !redirect.to.startsWith('/.netlify/') &&
+            // ...so is proxying
+            !redirect.to.startsWith('http')) {
+            userRewrites.push(redirect);
+        }
+    }
+    return userRewrites;
+};
+exports.getProblematicUserRewrites = getProblematicUserRewrites;
+const warnForProblematicUserRewrites = ({ redirects, basePath, }) => {
+    const userRewrites = exports.getProblematicUserRewrites({ redirects, basePath });
+    if (userRewrites.length === 0) {
+        return;
+    }
+    console.log(chalk_1.yellowBright(outdent_1.outdent `
+      You have the following Netlify rewrite${userRewrites.length === 1 ? '' : 's'} that might cause conflicts with the Next.js plugin:
+
+      ${chalk_1.reset(userRewrites.map(({ from, to, status }) => `- ${from} ${to} ${status}`).join('\n'))}
+
+      For more information, see https://ntl.fyi/next-rewrites
+    `));
+};
+exports.warnForProblematicUserRewrites = warnForProblematicUserRewrites;
+/* eslint-enable max-lines */

package/lib/index.js

@@ -1,58 +1,83 @@
-const { join, relative } = require('path');
-const { ODB_FUNCTION_NAME } = require('./constants');
-const { restoreCache, saveCache } = require('./helpers/cache');
-const { getNextConfig, configureHandlerFunctions } = require('./helpers/config');
-const { moveStaticPages, movePublicFiles, patchNextFiles, unpatchNextFiles } = require('./helpers/files');
-const { generateFunctions, setupImageFunction, generatePagesResolver } = require('./helpers/functions');
-const { generateRedirects } = require('./helpers/redirects');
-const { verifyNetlifyBuildVersion, checkNextSiteHasBuilt, checkForRootPublish, logBetaMessage, checkZipSize, checkForOldFunctions, } = require('./helpers/verification');
-/** @type import("@netlify/build").NetlifyPlugin */
-module.exports = {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const constants_1 = require("./constants");
+const cache_1 = require("./helpers/cache");
+const config_1 = require("./helpers/config");
+const files_1 = require("./helpers/files");
+const functions_1 = require("./helpers/functions");
+const redirects_1 = require("./helpers/redirects");
+const utils_1 = require("./helpers/utils");
+const verification_1 = require("./helpers/verification");
+const plugin = {
     async onPreBuild({ constants, netlifyConfig, utils: { build: { failBuild }, cache, }, }) {
         var _a;
-        logBetaMessage();
         const { publish } = netlifyConfig.build;
-        checkForRootPublish({ publish, failBuild });
-        verifyNetlifyBuildVersion({ failBuild, ...constants });
-        await restoreCache({ cache, publish });
+        if (utils_1.shouldSkip()) {
+            await cache_1.restoreCache({ cache, publish });
+            console.log('Not running Essential Next.js plugin');
+            if (fs_extra_1.existsSync(path_1.join(constants.INTERNAL_FUNCTIONS_SRC, constants_1.HANDLER_FUNCTION_NAME))) {
+                console.log(`Please ensure you remove any generated functions from ${constants.INTERNAL_FUNCTIONS_SRC}`);
+            }
+            return;
+        }
+        verification_1.checkForRootPublish({ publish, failBuild });
+        verification_1.verifyNetlifyBuildVersion({ failBuild, ...constants });
+        await cache_1.restoreCache({ cache, publish });
         (_a = netlifyConfig.build).environment || (_a.environment = {});
         // eslint-disable-next-line unicorn/consistent-destructuring
         netlifyConfig.build.environment.NEXT_PRIVATE_TARGET = 'server';
     },
     async onBuild({ constants, netlifyConfig, utils: { build: { failBuild }, }, }) {
+        if (utils_1.shouldSkip()) {
+            return;
+        }
         const { publish } = netlifyConfig.build;
-        checkNextSiteHasBuilt({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await getNextConfig({
+        verification_1.checkNextSiteHasBuilt({ publish, failBuild });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await config_1.getNextConfig({
             publish,
             failBuild,
         });
-        configureHandlerFunctions({ netlifyConfig, ignore, publish: relative(process.cwd(), publish) });
-        await generateFunctions(constants, appDir);
-        await generatePagesResolver({ netlifyConfig, target, constants });
-        await movePublicFiles({ appDir, outdir, publish });
+        config_1.configureHandlerFunctions({ netlifyConfig, ignore, publish: path_1.relative(process.cwd(), publish) });
+        await functions_1.generateFunctions(constants, appDir);
+        await functions_1.generatePagesResolver({ target, constants });
+        await files_1.movePublicFiles({ appDir, outdir, publish });
         if (process.env.EXPERIMENTAL_ODB_TTL) {
-            await patchNextFiles(basePath);
+            await files_1.patchNextFiles(basePath);
         }
         if (process.env.EXPERIMENTAL_MOVE_STATIC_PAGES) {
             console.log("The flag 'EXPERIMENTAL_MOVE_STATIC_PAGES' is no longer required, as it is now the default. To disable this behavior, set the env var 'SERVE_STATIC_FILES_FROM_ORIGIN' to 'true'");
         }
         if (!process.env.SERVE_STATIC_FILES_FROM_ORIGIN) {
-            await moveStaticPages({ target, failBuild, netlifyConfig, i18n });
+            await files_1.moveStaticPages({ target, netlifyConfig, i18n });
         }
-        await setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
-        await generateRedirects({
+        await redirects_1.generateStaticRedirects({
             netlifyConfig,
-            nextConfig: { basePath, i18n, trailingSlash },
+            nextConfig: { basePath, i18n },
+        });
+        await functions_1.setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
+        await redirects_1.generateRedirects({
+            netlifyConfig,
+            nextConfig: { basePath, i18n, trailingSlash, appDir },
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions, failBuild }, constants: { FUNCTIONS_DIST } }) {
-        await saveCache({ cache, publish: netlifyConfig.build.publish });
-        await checkForOldFunctions({ functions });
-        await checkZipSize(join(FUNCTIONS_DIST, `${ODB_FUNCTION_NAME}.zip`));
-        const { basePath } = await getNextConfig({ publish: netlifyConfig.build.publish, failBuild });
-        await unpatchNextFiles(basePath);
-    },
-    onEnd() {
-        logBetaMessage();
+    async onPostBuild({ netlifyConfig: { build: { publish }, redirects, }, utils: { status, cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
+        await cache_1.saveCache({ cache, publish });
+        if (utils_1.shouldSkip()) {
+            status.show({
+                title: 'Essential Next.js plugin did not run',
+                summary: `Next cache was stored, but all other functions were skipped because ${process.env.NETLIFY_NEXT_PLUGIN_SKIP
+                    ? `NETLIFY_NEXT_PLUGIN_SKIP is set`
+                    : `NEXT_PLUGIN_FORCE_RUN is set to ${process.env.NEXT_PLUGIN_FORCE_RUN}`}`,
+            });
+            return;
+        }
+        await verification_1.checkForOldFunctions({ functions });
+        await verification_1.checkZipSize(path_1.join(FUNCTIONS_DIST, `${constants_1.ODB_FUNCTION_NAME}.zip`));
+        const { basePath } = await config_1.getNextConfig({ publish, failBuild });
+        verification_1.warnForProblematicUserRewrites({ basePath, redirects });
+        await files_1.unpatchNextFiles(basePath);
     },
 };
+module.exports = plugin;

package/lib/templates/getHandler.js

@@ -48,7 +48,7 @@ const makeHandler = () =>
         var _a, _b, _c;
         let requestMode = mode;
         // Ensure that paths are encoded - but don't double-encode them
-        event.path = new URL(event.path, event.rawUrl).pathname;
+        event.path = new URL(event.rawUrl).pathname;
         // Next expects to be able to parse the query from the URL
         const query = new URLSearchParams(event.queryStringParameters).toString();
         event.path = query ? `${event.path}?${query}` : event.path;
@@ -68,7 +68,7 @@ const makeHandler = () =>
         // Sending SWR headers causes undefined behaviour with the Netlify CDN
         const cacheHeader = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0];
         if (cacheHeader === null || cacheHeader === void 0 ? void 0 : cacheHeader.includes('stale-while-revalidate')) {
-            if (requestMode === 'odb' && process.env.EXPERIMENTAL_ODB_TTL) {
+            if (requestMode === 'odb') {
                 requestMode = 'isr';
                 const ttl = getMaxAge(cacheHeader);
                 // Long-expiry TTL is basically no TTL

package/lib/templates/getPageResolver.js

@@ -11,17 +11,17 @@ const tiny_glob_1 = __importDefault(require("tiny-glob"));
 const constants_1 = require("../constants");
 // Generate a file full of require.resolve() calls for all the pages in the
 // build. This is used by the nft bundler to find all the pages.
-const getPageResolver = async ({ netlifyConfig, target }) => {
+const getPageResolver = async ({ publish, target }) => {
     const functionDir = path_1.posix.resolve(path_1.posix.join('.netlify', 'functions', constants_1.HANDLER_FUNCTION_NAME));
-    const root = path_1.posix.join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless', 'pages');
-    const pages = await (0, tiny_glob_1.default)('**/*.js', {
+    const root = path_1.posix.resolve(slash_1.default(publish), target === 'server' ? 'server' : 'serverless', 'pages');
+    const pages = await tiny_glob_1.default('**/*.js', {
         cwd: root,
         dot: true,
     });
     const pageFiles = pages
-        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, (0, slash_1.default)(page)))}')`)
+        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, slash_1.default(page)))}')`)
         .sort();
-    return (0, outdent_1.outdent) `
+    return outdent_1.outdent `
     // This file is purely to allow nft to know about these pages. It should be temporary.
     exports.resolvePages = () => {
         try {

package/lib/templates/handlerUtils.js

@@ -11,7 +11,7 @@ const os_1 = require("os");
 const path_1 = __importDefault(require("path"));
 const stream_1 = require("stream");
 const util_1 = require("util");
-const streamPipeline = (0, util_1.promisify)(stream_1.pipeline);
+const streamPipeline = util_1.promisify(stream_1.pipeline);
 const downloadFile = async (url, destination) => {
     console.log(`Downloading ${url} to ${destination}`);
     const httpx = url.startsWith('https') ? https_1.default : http_1.default;
@@ -21,7 +21,7 @@ const downloadFile = async (url, destination) => {
                 reject(new Error(`Failed to download ${url}: ${response.statusCode} ${response.statusMessage || ''}`));
                 return;
             }
-            const fileStream = (0, fs_1.createWriteStream)(destination);
+            const fileStream = fs_1.createWriteStream(destination);
             streamPipeline(response, fileStream)
                 .then(resolve)
                 .catch((error) => {
@@ -78,7 +78,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
     const staticFiles = new Map(staticManifest);
     const downloadPromises = new Map();
     // Yes, you can cache stuff locally in a Lambda
-    const cacheDir = path_1.default.join((0, os_1.tmpdir)(), 'next-static-cache');
+    const cacheDir = path_1.default.join(os_1.tmpdir(), 'next-static-cache');
     // Grab the real fs.promises.readFile...
     const readfileOrig = promises.readFile;
     const statsOrig = promises.stat;
@@ -90,7 +90,7 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
             // We only want the part after `pages/`
             const filePath = file.slice(pageRoot.length + 1);
             // Is it in the CDN and not local?
-            if (staticFiles.has(filePath) && !(0, fs_1.existsSync)(file)) {
+            if (staticFiles.has(filePath) && !fs_1.existsSync(file)) {
                 // This name is safe to use, because it's one that was already created by Next
                 const cacheFile = path_1.default.join(cacheDir, filePath);
                 const url = `${base}/${staticFiles.get(filePath)}`;
@@ -99,11 +99,11 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
                     await downloadPromises.get(url);
                 }
                 // Have we already cached it? We download every time if running locally to avoid staleness
-                if ((!(0, fs_1.existsSync)(cacheFile) || process.env.NETLIFY_DEV) && base) {
+                if ((!fs_1.existsSync(cacheFile) || process.env.NETLIFY_DEV) && base) {
                     await promises.mkdir(path_1.default.dirname(cacheFile), { recursive: true });
                     try {
                         // Append the path to our host and we can load it like a regular page
-                        const downloadPromise = (0, exports.downloadFile)(url, cacheFile);
+                        const downloadPromise = exports.downloadFile(url, cacheFile);
                         downloadPromises.set(url, downloadPromise);
                         await downloadPromise;
                     }
@@ -117,12 +117,12 @@ const augmentFsModule = ({ promises, staticManifest, pageRoot, getBase, }) => {
         }
         return readfileOrig(file, options);
     });
-    promises.stat = (async (file, options) => {
+    promises.stat = ((file, options) => {
         // We only care about page files
         if (file.startsWith(pageRoot)) {
             // We only want the part after `pages/`
             const cacheFile = path_1.default.join(cacheDir, file.slice(pageRoot.length + 1));
-            if ((0, fs_1.existsSync)(cacheFile)) {
+            if (fs_1.existsSync(cacheFile)) {
                 return statsOrig(cacheFile, options);
             }
         }

package/lib/templates/ipx.js

@@ -5,7 +5,7 @@ exports.handler = void 0;
 const ipx_1 = require("@netlify/ipx");
 // @ts-ignore Injected at build time
 const imageconfig_json_1 = require("./imageconfig.json");
-exports.handler = (0, ipx_1.createIPXHandler)({
+exports.handler = ipx_1.createIPXHandler({
     basePath: imageconfig_json_1.basePath,
     domains: imageconfig_json_1.domains,
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@netlify/plugin-nextjs",
-  "version": "4.0.0-rc.0",
+  "version": "4.1.0",
   "description": "Run Next.js seamlessly on Netlify",
   "main": "lib/index.js",
   "files": [
@@ -10,7 +10,6 @@
   "scripts": {
     "build:demo": "next build demos/default",
     "cy:open": "cypress open --config-file cypress/config/all.json",
-    "cy:run": "cypress run --config-file ../../cypress/config/ci.json",
     "dev:demo": "next dev demos/default",
     "format": "run-s format:check-fix:*",
     "format:ci": "run-s format:check:*",
@@ -34,8 +33,8 @@
     "watch": "tsc --watch"
   },
   "config": {
-    "eslint": "--cache --format=codeframe --max-warnings=0 \"{src,scripts,tests,.github}/**/*.{js,md,html}\" \"*.{js,md,html}\" \".*.{js,md,html}\"",
-    "prettier": "--loglevel=warn \"{src,scripts,tests,.github}/**/*.{js,md,yml,json,html}\" \"*.{js,yml,json,html}\" \".*.{js,yml,json,html}\" \"!package-lock.json\""
+    "eslint": "--cache --format=codeframe --max-warnings=0 \"{src,scripts,tests,.github}/**/*.{ts,js,md,html}\" \"*.{ts,js,md,html}\" \".*.{ts,js,md,html}\"",
+    "prettier": "--loglevel=warn \"{src,scripts,tests,.github}/**/*.{ts,js,md,yml,json,html}\" \"*.{ts,js,yml,json,html}\" \".*.{ts,js,yml,json,html}\" \"!package-lock.json\""
   },
   "repository": {
     "type": "git",
@@ -55,7 +54,7 @@
   "homepage": "https://github.com/netlify/netlify-plugin-nextjs#readme",
   "dependencies": {
     "@netlify/functions": "^0.10.0",
-    "@netlify/ipx": "^0.0.7",
+    "@netlify/ipx": "^0.0.8",
     "@vercel/node": "^1.11.2-canary.4",
     "chalk": "^4.1.2",
     "fs-extra": "^10.0.0",
@@ -75,8 +74,8 @@
     "@babel/core": "^7.15.8",
     "@babel/preset-env": "^7.15.8",
     "@babel/preset-typescript": "^7.16.0",
-    "@netlify/build": "^20.0.4",
-    "@netlify/eslint-config-node": "^3.3.11",
+    "@netlify/build": "^25.0.1",
+    "@netlify/eslint-config-node": "^4.0.1",
     "@testing-library/cypress": "^8.0.1",
     "@types/fs-extra": "^9.0.13",
     "@types/jest": "^27.0.2",