@netlify/plugin-nextjs 4.0.0-beta.9 → 4.0.0

package/lib/helpers/functions.js

@@ -1,56 +1,61 @@
-const { copyFile, ensureDir, writeFile, writeJSON } = require('fs-extra');
-const { join, relative } = require('pathe');
-const { HANDLER_FUNCTION_NAME, ODB_FUNCTION_NAME, IMAGE_FUNCTION_NAME } = require('../constants');
-const getHandler = require('../templates/getHandler');
-const { getPageResolver } = require('../templates/getPageResolver');
-const DEFAULT_FUNCTIONS_SRC = 'netlify/functions';
-exports.generateFunctions = async ({ FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC, INTERNAL_FUNCTIONS_SRC, PUBLISH_DIR }, appDir) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupImageFunction = exports.generatePagesResolver = exports.generateFunctions = void 0;
+const fs_extra_1 = require("fs-extra");
+const pathe_1 = require("pathe");
+const constants_1 = require("../constants");
+const getHandler_1 = require("../templates/getHandler");
+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 = join(process.cwd(), functionsDir, HANDLER_FUNCTION_NAME);
-    const publishDir = relative(functionDir, 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 getHandler({ isODB, publishDir, appDir: relative(functionDir, appDir) });
-        await ensureDir(join(functionsDir, func));
-        await writeFile(join(functionsDir, func, `${func}.js`), handlerSource);
-        await copyFile(bridgeFile, join(functionsDir, func, 'bridge.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(HANDLER_FUNCTION_NAME, false);
-    await writeHandler(ODB_FUNCTION_NAME, true);
+    await writeHandler(constants_1.HANDLER_FUNCTION_NAME, false);
+    await writeHandler(constants_1.ODB_FUNCTION_NAME, true);
 };
+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.
  */
-exports.generatePagesResolver = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = 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 getPageResolver({
-        netlifyConfig,
+    const jsSource = await getPageResolver_1.getPageResolver({
+        publish: PUBLISH_DIR,
         target,
     });
-    await writeFile(join(functionsPath, ODB_FUNCTION_NAME, 'pages.js'), jsSource);
-    await writeFile(join(functionsPath, 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
-exports.setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCTIONS_SRC = DEFAULT_FUNCTIONS_SRC }, imageconfig = {}, netlifyConfig, basePath, }) => {
+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 = `${IMAGE_FUNCTION_NAME}.js`;
-    const functionDirectory = join(functionsPath, IMAGE_FUNCTION_NAME);
-    await ensureDir(functionDirectory);
-    await writeJSON(join(functionDirectory, 'imageconfig.json'), {
+    const functionName = `${constants_1.IMAGE_FUNCTION_NAME}.js`;
+    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, IMAGE_FUNCTION_NAME].join('/'),
+        basePath: [basePath, constants_1.IMAGE_FUNCTION_NAME].join('/'),
     });
-    await copyFile(join(__dirname, '..', 'templates', 'ipx.js'), 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}*`,
         query: { url: ':url', w: ':width', q: ':quality' },
-        to: `${basePath}/${IMAGE_FUNCTION_NAME}/w_:width,q_:quality/:url`,
+        to: `${basePath}/${constants_1.IMAGE_FUNCTION_NAME}/w_:width,q_:quality/:url`,
         status: 301,
     }, {
-        from: `${basePath}/${IMAGE_FUNCTION_NAME}/*`,
-        to: `/.netlify/builders/${IMAGE_FUNCTION_NAME}`,
+        from: `${basePath}/${constants_1.IMAGE_FUNCTION_NAME}/*`,
+        to: `/.netlify/builders/${constants_1.IMAGE_FUNCTION_NAME}`,
         status: 200,
     });
     if (basePath) {
@@ -62,3 +67,4 @@ exports.setupImageFunction = async ({ constants: { INTERNAL_FUNCTIONS_SRC, FUNCT
         });
     }
 };
+exports.setupImageFunction = setupImageFunction;

package/lib/helpers/redirects.js

@@ -0,0 +1,130 @@
+"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 fs_extra_1 = require("fs-extra");
+const globby_1 = __importDefault(require("globby"));
+const pathe_1 = require("pathe");
+const constants_1 = require("../constants");
+const utils_1 = require("./utils");
+const generateLocaleRedirects = ({ i18n, basePath, trailingSlash, }) => {
+    const redirects = [];
+    // If the cookie is set, we need to redirect at the origin
+    redirects.push({
+        from: `${basePath}/`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+        force: true,
+        conditions: {
+            Cookie: ['NEXT_LOCALE'],
+        },
+    });
+    i18n.locales.forEach((locale) => {
+        if (locale === i18n.defaultLocale) {
+            return;
+        }
+        redirects.push({
+            from: `${basePath}/`,
+            to: `${basePath}/${locale}${trailingSlash ? '/' : ''}`,
+            status: 301,
+            conditions: {
+                Language: [locale],
+            },
+            force: true,
+        });
+    });
+    return redirects;
+};
+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',
+        status: 404,
+        force: true,
+    })));
+    if (i18n && i18n.localeDetection !== false) {
+        netlifyConfig.redirects.push(...generateLocaleRedirects({ i18n, basePath, trailingSlash }));
+    }
+    const dataRedirects = [];
+    const pageRedirects = [];
+    const isrRedirects = [];
+    const dynamicRouteEntries = Object.entries(dynamicRoutes);
+    const staticRouteEntries = Object.entries(staticRoutes);
+    staticRouteEntries.forEach(([route, { dataRoute, initialRevalidateSeconds }]) => {
+        // Only look for revalidate as we need to rewrite these to SSR rather than ODB
+        if (initialRevalidateSeconds === false) {
+            // These can be ignored, as they're static files handled by the CDN
+            return;
+        }
+        if ((i18n === null || i18n === void 0 ? void 0 : i18n.defaultLocale) && route.startsWith(`/${i18n.defaultLocale}/`)) {
+            route = route.slice(i18n.defaultLocale.length + 1);
+        }
+        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(...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`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    }, {
+        from: `${basePath}/api/*`,
+        to: constants_1.HANDLER_FUNCTION_PATH,
+        status: 200,
+    }, 
+    // 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,
+        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: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+        force: true,
+    })), 
+    // These are pages with fallback set, which need an ODB
+    // Data redirects go first, to avoid conflict with splat redirects
+    ...dataRedirects.map((redirect) => ({
+        from: `${basePath}${redirect}`,
+        to: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+    })), 
+    // ...then all the other fallback pages
+    ...pageRedirects.map((redirect) => ({
+        from: `${basePath}${redirect}`,
+        to: constants_1.ODB_FUNCTION_PATH,
+        status: 200,
+    })), 
+    // Everything else is handled by the regular function
+    { from: `${basePath}/*`, to: constants_1.HANDLER_FUNCTION_PATH, status: 200 });
+};
+exports.generateRedirects = generateRedirects;

package/lib/helpers/utils.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.netlifyRoutesForNextRoute = void 0;
+const constants_1 = require("../constants");
+const netlifyRoutesForNextRoute = (nextRoute) => {
+    const netlifyRoutes = [nextRoute];
+    // If the route is an optional catch-all route, we need to add a second
+    // Netlify route for the base path (when no parameters are present).
+    // The file ending must be present!
+    if (constants_1.OPTIONAL_CATCH_ALL_REGEX.test(nextRoute)) {
+        let netlifyRoute = nextRoute.replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '$2');
+        // create an empty string, but actually needs to be a forward slash
+        if (netlifyRoute === '') {
+            netlifyRoute = '/';
+        }
+        // When optional catch-all route is at top-level, the regex on line 19 will
+        // create an incorrect route for the data route. For example, it creates
+        // /_next/data/%BUILDID%.json, but NextJS looks for
+        // /_next/data/%BUILDID%/index.json
+        netlifyRoute = netlifyRoute.replace(/(\/_next\/data\/[^/]+).json/, '$1/index.json');
+        // Add second route to the front of the array
+        netlifyRoutes.unshift(netlifyRoute);
+    }
+    return netlifyRoutes.map((route) => route
+        // Replace catch-all, e.g., [...slug]
+        .replace(constants_1.CATCH_ALL_REGEX, '/:$1/*')
+        // Replace optional catch-all, e.g., [[...slug]]
+        .replace(constants_1.OPTIONAL_CATCH_ALL_REGEX, '/*')
+        // Replace dynamic parameters, e.g., [id]
+        .replace(constants_1.DYNAMIC_PARAMETER_REGEX, '/:$1'));
+};
+exports.netlifyRoutesForNextRoute = netlifyRoutesForNextRoute;

package/lib/helpers/verification.js

@@ -1,93 +1,121 @@
-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.checkZipSize = exports.checkForRootPublish = exports.checkNextSiteHasBuilt = exports.checkForOldFunctions = exports.verifyNetlifyBuildVersion = void 0;
+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 }) => {
-    const oldFunctions = (await functions.list()).filter(({ name }) => name.startsWith('next_'));
+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. 
+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 the Essential Next.js plugin should be removed. See https://ntl.fyi/remove-plugin for details.
     `);
     }
-    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.
     `);
     }
 };
-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;

package/lib/index.js

@@ -1,50 +1,56 @@
-const { join, relative } = require('path');
-const { ODB_FUNCTION_NAME } = require('./constants');
-const { restoreCache, saveCache } = require('./helpers/cache');
-const { getNextConfig, configureHandlerFunctions, generateRedirects } = require('./helpers/config');
-const { moveStaticPages, movePublicFiles } = require('./helpers/files');
-const { generateFunctions, setupImageFunction, generatePagesResolver } = require('./helpers/functions');
-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 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 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 });
+        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 }, }, }) {
         const { publish } = netlifyConfig.build;
-        checkNextSiteHasBuilt({ publish, failBuild });
-        const { appDir, basePath, i18n, images, target, ignore } = await getNextConfig({ publish, failBuild });
-        configureHandlerFunctions({ netlifyConfig, ignore, publish: relative(process.cwd(), publish) });
-        await generateFunctions(constants, appDir);
-        await generatePagesResolver({ netlifyConfig, target, constants });
-        await movePublicFiles({ appDir, publish });
+        verification_1.checkNextSiteHasBuilt({ publish, failBuild });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = await config_1.getNextConfig({
+            publish,
+            failBuild,
+        });
+        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 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 functions_1.setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
+        await redirects_1.generateRedirects({
             netlifyConfig,
-            basePath,
-            i18n,
+            nextConfig: { basePath, i18n, trailingSlash, appDir },
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions }, constants: { FUNCTIONS_DIST } }) {
-        await saveCache({ cache, publish: netlifyConfig.build.publish });
-        await checkForOldFunctions({ functions });
-        await checkZipSize(join(FUNCTIONS_DIST, `${ODB_FUNCTION_NAME}.zip`));
-    },
-    onEnd() {
-        logBetaMessage();
+    async onPostBuild({ netlifyConfig, utils: { cache, functions, build: { failBuild }, }, constants: { FUNCTIONS_DIST }, }) {
+        await cache_1.saveCache({ cache, publish: netlifyConfig.build.publish });
+        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: netlifyConfig.build.publish, failBuild });
+        await files_1.unpatchNextFiles(basePath);
     },
 };
+module.exports = plugin;