@netlify/plugin-nextjs 4.0.0-beta.7 → 4.0.0-rc.1

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

@@ -18,18 +18,18 @@ exports.verifyNetlifyBuildVersion = ({ IS_LOCAL, NETLIFY_BUILD_VERSION, failBuil
     }
 };
 exports.checkForOldFunctions = async ({ functions }) => {
-    const oldFunctions = (await functions.list()).filter(({ name }) => name.startsWith('next_'));
+    const allOldFunctions = await functions.list();
+    const oldFunctions = allOldFunctions.filter(({ name }) => name.startsWith('next_'));
     if (oldFunctions.length !== 0) {
         console.log(yellowBright(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_".
+        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'))}
+        ${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:
+        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'))}
-
-    `));
+        ${reset(oldFunctions.map(({ mainFile }) => `- ${path.relative(process.cwd(), path.dirname(mainFile))}`).join('\n'))}
+      `));
     }
 };
 exports.checkNextSiteHasBuilt = ({ publish, failBuild }) => {
@@ -38,20 +38,22 @@ exports.checkNextSiteHasBuilt = ({ publish, failBuild }) => {
       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.
-      `);
+    `);
     }
     if (existsSync(path.join(publish, 'export-detail.json'))) {
         failBuild(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.`);
+      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 `
       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.`);
+      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
@@ -61,17 +63,15 @@ exports.checkZipSize = async (file, maxSize = LAMBDA_MAX_SIZE) => {
         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 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)}.
-    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.
-  
+      The function zip ${yellowBright(relative(process.cwd(), file))} size is ${prettyBytes(fileSize)}, which is larger than the maximum supported size of ${prettyBytes(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 });
     console.log(`Contains ${await zip.entriesCount} files`);

package/lib/index.js

@@ -1,9 +1,10 @@
 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 { 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 = {
@@ -21,25 +22,35 @@ module.exports = {
     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 });
+        const { appDir, basePath, i18n, images, target, ignore, trailingSlash, outdir } = 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 });
+        await movePublicFiles({ appDir, outdir, publish });
+        if (process.env.EXPERIMENTAL_ODB_TTL) {
+            await 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 setupImageFunction({ constants, imageconfig: images, netlifyConfig, basePath });
         await generateRedirects({
             netlifyConfig,
-            basePath,
-            i18n,
+            nextConfig: { basePath, i18n, trailingSlash, appDir },
         });
     },
-    async onPostBuild({ netlifyConfig, utils: { cache, functions }, constants: { FUNCTIONS_DIST } }) {
+    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();

package/lib/templates/getHandler.js

@@ -1,89 +1,32 @@
-const { promises, createWriteStream, existsSync } = require('fs');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHandler = void 0;
+const { promises } = require('fs');
 const { Server } = require('http');
-const { tmpdir } = require('os');
 const path = require('path');
-const { promisify } = require('util');
-const streamPipeline = promisify(require('stream').pipeline);
+// eslint-disable-next-line node/prefer-global/url, node/prefer-global/url-search-params
+const { URLSearchParams, URL } = require('url');
 const { Bridge } = require('@vercel/node/dist/bridge');
-const fetch = require('node-fetch');
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils');
 const makeHandler = () => 
 // We return a function and then call `toString()` on it to serialise it as the launcher function
-(conf, app, pageRoot, staticManifest = []) => {
+// eslint-disable-next-line max-params
+(conf, app, pageRoot, staticManifest = [], mode = 'ssr') => {
     // This is just so nft knows about the page entrypoints. It's not actually used
     try {
         // eslint-disable-next-line node/no-missing-require
         require.resolve('./pages.js');
     }
     catch { }
+    // eslint-disable-next-line no-underscore-dangle
+    process.env._BYPASS_SSG = 'true';
+    const ONE_YEAR_IN_SECONDS = 31536000;
+    // We don't want to write ISR files to disk in the lambda environment
+    conf.experimental.isrFlushToDisk = false;
     // Set during the request as it needs the host header. Hoisted so we can define the function once
     let base;
-    // Only do this if we have some static files moved to the CDN
-    if (staticManifest.length !== 0) {
-        // These are static page files that have been removed from the function bundle
-        // In most cases these are served from the CDN, but for rewrites Next may try to read them
-        // from disk. We need to intercept these and load them from the CDN instead
-        // Sadly the only way to do this is to monkey-patch fs.promises. Yeah, I know.
-        const staticFiles = new Set(staticManifest);
-        // Yes, you can cache stuff locally in a Lambda
-        const cacheDir = path.join(tmpdir(), 'next-static-cache');
-        // Grab the real fs.promises.readFile...
-        const readfileOrig = promises.readFile;
-        // ...then money-patch it to see if it's requesting a CDN file
-        promises.readFile = async (file, options) => {
-            // We only care about page files
-            if (file.startsWith(pageRoot)) {
-                // 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) && !existsSync(file)) {
-                    // This name is safe to use, because it's one that was already created by Next
-                    const cacheFile = path.join(cacheDir, filePath);
-                    // Have we already cached it? We ignore the cache if running locally to avoid staleness
-                    if ((!existsSync(cacheFile) || process.env.NETLIFY_DEV) && base) {
-                        await promises.mkdir(path.dirname(cacheFile), { recursive: true });
-                        // Append the path to our host and we can load it like a regular page
-                        const url = `${base}/${filePath}`;
-                        console.log(`Downloading ${url} to ${cacheFile}`);
-                        const response = await fetch(url);
-                        if (!response.ok) {
-                            // Next catches this and returns it as a not found file
-                            throw new Error(`Failed to fetch ${url}`);
-                        }
-                        // Stream it to disk
-                        await streamPipeline(response.body, createWriteStream(cacheFile));
-                    }
-                    // Return the cache file
-                    return readfileOrig(cacheFile, options);
-                }
-            }
-            return readfileOrig(file, options);
-        };
-    }
-    let NextServer;
-    try {
-        // next >= 11.0.1. Yay breaking changes in patch releases!
-        NextServer = require('next/dist/server/next-server').default;
-    }
-    catch (error) {
-        if (!error.message.includes("Cannot find module 'next/dist/server/next-server'")) {
-            // A different error, so rethrow it
-            throw error;
-        }
-        // Probably an old version of next
-    }
-    if (!NextServer) {
-        try {
-            // next < 11.0.1
-            // eslint-disable-next-line node/no-missing-require, import/no-unresolved
-            NextServer = require('next/dist/next-server/server/next-server').default;
-        }
-        catch (error) {
-            if (!error.message.includes("Cannot find module 'next/dist/next-server/server/next-server'")) {
-                throw error;
-            }
-            throw new Error('Could not find Next.js server');
-        }
-    }
+    augmentFsModule({ promises, staticManifest, pageRoot, getBase: () => base });
+    const NextServer = getNextServer();
     const nextServer = new NextServer({
         conf,
         dir: path.resolve(__dirname, app),
@@ -102,7 +45,8 @@ const makeHandler = () =>
     const bridge = new Bridge(server);
     bridge.listen();
     return async (event, context) => {
-        var _a, _b, _c, _d;
+        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;
         // Next expects to be able to parse the query from the URL
@@ -115,25 +59,27 @@ const makeHandler = () =>
             base = `${protocol}://${host}`;
         }
         const { headers, ...result } = await bridge.launcher(event, context);
-        /** @type import("@netlify/functions").HandlerResponse */
         // Convert all headers to multiValueHeaders
-        const multiValueHeaders = {};
-        for (const key of Object.keys(headers)) {
-            if (Array.isArray(headers[key])) {
-                multiValueHeaders[key] = headers[key];
-            }
-            else {
-                multiValueHeaders[key] = [headers[key]];
-            }
-        }
+        const multiValueHeaders = getMultiValueHeaders(headers);
         if ((_b = (_a = multiValueHeaders['set-cookie']) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.includes('__prerender_bypass')) {
             delete multiValueHeaders.etag;
             multiValueHeaders['cache-control'] = ['no-cache'];
         }
         // Sending SWR headers causes undefined behaviour with the Netlify CDN
-        if ((_d = (_c = multiValueHeaders['cache-control']) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.includes('stale-while-revalidate')) {
+        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') {
+                requestMode = 'isr';
+                const ttl = getMaxAge(cacheHeader);
+                // Long-expiry TTL is basically no TTL
+                if (ttl > 0 && ttl < ONE_YEAR_IN_SECONDS) {
+                    result.ttl = ttl;
+                }
+                multiValueHeaders['x-rendered-at'] = [new Date().toISOString()];
+            }
             multiValueHeaders['cache-control'] = ['public, max-age=0, must-revalidate'];
         }
+        multiValueHeaders['x-render-mode'] = [requestMode];
         return {
             ...result,
             multiValueHeaders,
@@ -143,13 +89,10 @@ const makeHandler = () =>
 };
 const getHandler = ({ isODB = false, publishDir = '../../../.next', appDir = '../../..' }) => `
 const { Server } = require("http");
-const { tmpdir } = require('os')
-const { promises, createWriteStream, existsSync } = require("fs");
-const { promisify } = require('util')
-const streamPipeline = promisify(require('stream').pipeline)
+const { promises } = require("fs");
 // We copy the file here rather than requiring from the node module
 const { Bridge } = require("./bridge");
-const fetch = require('node-fetch')
+const { augmentFsModule, getMaxAge, getMultiValueHeaders, getNextServer } = require('./handlerUtils')
 
 const { builder } = require("@netlify/functions");
 const { config }  = require("${publishDir}/required-server-files.json")
@@ -160,7 +103,8 @@ try {
 const path = require("path");
 const pageRoot = path.resolve(path.join(__dirname, "${publishDir}", config.target === "server" ? "server" : "serverless", "pages"));
 exports.handler = ${isODB
-    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest));`
-    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest);`}
+    ? `builder((${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'odb'));`
+    : `(${makeHandler().toString()})(config, "${appDir}", pageRoot, staticManifest, 'ssr');`}
 `;
-module.exports = getHandler;
+exports.getHandler = getHandler;
+/* eslint-enable @typescript-eslint/no-var-requires */

package/lib/templates/getPageResolver.js

@@ -1,19 +1,27 @@
-const { posix: { resolve, join, relative }, } = require('path');
-const { outdent } = require('outdent');
-const slash = require('slash');
-const glob = require('tiny-glob');
-const { HANDLER_FUNCTION_NAME } = require('../constants');
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPageResolver = void 0;
+const path_1 = require("path");
+const outdent_1 = require("outdent");
+const slash_1 = __importDefault(require("slash"));
+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.
-exports.getPageResolver = async ({ netlifyConfig, target }) => {
-    const functionDir = resolve(join('.netlify', 'functions', HANDLER_FUNCTION_NAME));
-    const root = join(netlifyConfig.build.publish, target === 'server' ? 'server' : 'serverless', 'pages');
-    const pages = await glob('**/*.js', {
+const getPageResolver = async ({ netlifyConfig, 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 tiny_glob_1.default('**/*.js', {
         cwd: root,
         dot: true,
     });
-    const pageFiles = pages.map((page) => `require.resolve('${relative(functionDir, join(root, slash(page)))}')`).sort();
-    return outdent `
+    const pageFiles = pages
+        .map((page) => `require.resolve('${path_1.posix.relative(functionDir, path_1.posix.join(root, slash_1.default(page)))}')`)
+        .sort();
+    return outdent_1.outdent `
     // This file is purely to allow nft to know about these pages. It should be temporary.
     exports.resolvePages = () => {
         try {
@@ -22,3 +30,4 @@ exports.getPageResolver = async ({ netlifyConfig, target }) => {
     }
   `;
 };
+exports.getPageResolver = getPageResolver;