@opennextjs/aws 3.1.6 → 3.2.1

package/dist/build/createServerBundle.js

@@ -1,19 +1,15 @@
-import { existsSync } from "node:fs";
-import { createRequire as topLevelCreateRequire } from "node:module";
-import fs from "fs";
-import path from "path";
-import url from "url";
-import { compileCache } from "../build.js";
+import fs from "node:fs";
+import path from "node:path";
 import logger from "../logger.js";
 import { minifyAll } from "../minimize-js.js";
 import { openNextReplacementPlugin } from "../plugins/replacement.js";
 import { openNextResolvePlugin } from "../plugins/resolve.js";
 import { bundleNextServer } from "./bundleNextServer.js";
+import { compileCache } from "./compileCache.js";
 import { copyTracedFiles } from "./copyTracedFiles.js";
 import { generateEdgeBundle } from "./edge/createEdgeBundle.js";
-import { compareSemver, copyEnvFile, copyOpenNextConfig, esbuildAsync, traverseFiles, } from "./helper.js";
-const require = topLevelCreateRequire(import.meta.url);
-const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
 export async function createServerBundle(options) {
     const { config } = options;
     const foundRoutes = new Set();
@@ -29,24 +25,24 @@ export async function createServerBundle(options) {
         const routes = fnOptions.routes;
         routes.forEach((route) => foundRoutes.add(route));
         if (fnOptions.runtime === "edge") {
-            await generateEdgeBundle(name, config, options, fnOptions);
+            await generateEdgeBundle(name, options, fnOptions);
         }
         else {
-            await generateBundle(name, config, options, fnOptions);
+            await generateBundle(name, options, fnOptions);
         }
     });
     //TODO: throw an error if not all edge runtime routes has been bundled in a separate function
     // We build every other function than default before so we know which route there is left
     await Promise.all(promises);
     const remainingRoutes = new Set();
-    const { monorepoRoot, appBuildOutputPath } = options;
+    const { appBuildOutputPath, monorepoRoot } = options;
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     // Find remaining routes
     const serverPath = path.join(appBuildOutputPath, ".next", "standalone", packagePath, ".next", "server");
     // Find app dir routes
-    if (existsSync(path.join(serverPath, "app"))) {
+    if (fs.existsSync(path.join(serverPath, "app"))) {
         const appPath = path.join(serverPath, "app");
-        traverseFiles(appPath, (file) => {
+        buildHelper.traverseFiles(appPath, (file) => {
             if (file.endsWith("page.js") || file.endsWith("route.js")) {
                 const route = `app/${file.replace(/\.js$/, "")}`;
                 if (!foundRoutes.has(route)) {
@@ -57,9 +53,9 @@ export async function createServerBundle(options) {
         }, () => { });
     }
     // Find pages dir routes
-    if (existsSync(path.join(serverPath, "pages"))) {
+    if (fs.existsSync(path.join(serverPath, "pages"))) {
         const pagePath = path.join(serverPath, "pages");
-        traverseFiles(pagePath, (file) => {
+        buildHelper.traverseFiles(pagePath, (file) => {
             if (file.endsWith(".js")) {
                 const route = `pages/${file.replace(/\.js$/, "")}`;
                 if (!foundRoutes.has(route)) {
@@ -70,15 +66,15 @@ export async function createServerBundle(options) {
         }, () => { });
     }
     // Generate default function
-    await generateBundle("default", config, options, {
+    await generateBundle("default", options, {
         ...defaultFn,
         // @ts-expect-error - Those string are RouteTemplate
         routes: Array.from(remainingRoutes),
         patterns: ["*"],
     });
 }
-async function generateBundle(name, config, options, fnOptions) {
-    const { appPath, appBuildOutputPath, outputDir, monorepoRoot } = options;
+async function generateBundle(name, options, fnOptions) {
+    const { appPath, appBuildOutputPath, config, outputDir, monorepoRoot } = options;
     logger.info(`Building server function: ${name}...`);
     // Create output folder
     const outputPath = path.join(outputDir, "server-functions", name);
@@ -91,7 +87,7 @@ async function generateBundle(name, config, options, fnOptions) {
     const packagePath = path.relative(monorepoRoot, appBuildOutputPath);
     fs.mkdirSync(path.join(outputPath, packagePath), { recursive: true });
     const ext = fnOptions.runtime === "deno" ? "mjs" : "cjs";
-    fs.copyFileSync(path.join(outputDir, ".build", `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
+    fs.copyFileSync(path.join(options.buildDir, `cache.${ext}`), path.join(outputPath, packagePath, "cache.cjs"));
     if (fnOptions.runtime === "deno") {
         addDenoJson(outputPath, packagePath);
     }
@@ -100,37 +96,34 @@ async function generateBundle(name, config, options, fnOptions) {
     if (isBundled) {
         await bundleNextServer(path.join(outputPath, packagePath), appPath);
     }
-    // // Copy middleware
-    if (!config.middleware?.external &&
-        existsSync(path.join(outputDir, ".build", "middleware.mjs"))) {
-        fs.copyFileSync(path.join(outputDir, ".build", "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
+    // Copy middleware
+    if (!config.middleware?.external) {
+        fs.copyFileSync(path.join(options.buildDir, "middleware.mjs"), path.join(outputPath, packagePath, "middleware.mjs"));
     }
     // Copy open-next.config.mjs
-    copyOpenNextConfig(path.join(outputDir, ".build"), path.join(outputPath, packagePath));
-    //Copy env files
-    copyEnvFile(appBuildOutputPath, packagePath, outputPath);
+    buildHelper.copyOpenNextConfig(options.buildDir, path.join(outputPath, packagePath));
+    // Copy env files
+    buildHelper.copyEnvFile(appBuildOutputPath, packagePath, outputPath);
     // Copy all necessary traced files
     await copyTracedFiles(appBuildOutputPath, packagePath, outputPath, fnOptions.routes ?? ["app/page.tsx"], isBundled);
     // Build Lambda code
     // note: bundle in OpenNext package b/c the adapter relies on the
     //       "serverless-http" package which is not a dependency in user's
     //       Next.js app.
-    const disableNextPrebundledReact = compareSemver(options.nextVersion, "13.5.1") >= 0 ||
-        compareSemver(options.nextVersion, "13.4.1") <= 0;
+    const disableNextPrebundledReact = buildHelper.compareSemver(options.nextVersion, "13.5.1") >= 0 ||
+        buildHelper.compareSemver(options.nextVersion, "13.4.1") <= 0;
     const overrides = fnOptions.override ?? {};
-    const isBefore13413 = compareSemver(options.nextVersion, "13.4.13") <= 0;
-    const isAfter141 = compareSemver(options.nextVersion, "14.0.4") >= 0;
+    const isBefore13413 = buildHelper.compareSemver(options.nextVersion, "13.4.13") <= 0;
+    const isAfter141 = buildHelper.compareSemver(options.nextVersion, "14.0.4") >= 0;
     const disableRouting = isBefore13413 || config.middleware?.external;
     const plugins = [
         openNextReplacementPlugin({
             name: `requestHandlerOverride ${name}`,
             target: /core(\/|\\)requestHandler\.js/g,
-            deletes: disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : [],
-            replacements: disableRouting
-                ? [
-                    require.resolve("../adapters/plugins/without-routing/requestHandler.js"),
-                ]
-                : [],
+            deletes: [
+                ...(disableNextPrebundledReact ? ["applyNextjsPrebundledReact"] : []),
+                ...(disableRouting ? ["withRouting"] : []),
+            ],
         }),
         openNextReplacementPlugin({
             name: `utilOverride ${name}`,
@@ -154,8 +147,10 @@ async function generateBundle(name, config, options, fnOptions) {
             .join(",")}] for Next version: ${options.nextVersion}`);
     }
     const outfileExt = fnOptions.runtime === "deno" ? "ts" : "mjs";
-    await esbuildAsync({
-        entryPoints: [path.join(__dirname, "../adapters", "server-adapter.js")],
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "server-adapter.js"),
+        ],
         external: ["next", "./middleware.mjs", "./next-server.runtime.prod.js"],
         outfile: path.join(outputPath, packagePath, `index.${outfileExt}`),
         banner: {
@@ -180,6 +175,7 @@ async function generateBundle(name, config, options, fnOptions) {
     if (isMonorepo) {
         addMonorepoEntrypoint(outputPath, packagePath);
     }
+    installDependencies(outputPath, fnOptions.install);
     if (fnOptions.minify) {
         await minifyServerBundle(outputPath);
     }

package/dist/build/createWarmerBundle.d.ts

@@ -0,0 +1,2 @@
+import * as buildHelper from "./helper.js";
+export declare function createWarmerBundle(options: buildHelper.BuildOptions): Promise<void>;

package/dist/build/createWarmerBundle.js

@@ -0,0 +1,44 @@
+import fs from "node:fs";
+import path from "node:path";
+import logger from "../logger.js";
+import { openNextResolvePlugin } from "../plugins/resolve.js";
+import * as buildHelper from "./helper.js";
+import { installDependencies } from "./installDeps.js";
+export async function createWarmerBundle(options) {
+    logger.info(`Bundling warmer function...`);
+    const { config, outputDir } = options;
+    // Create output folder
+    const outputPath = path.join(outputDir, "warmer-function");
+    fs.mkdirSync(outputPath, { recursive: true });
+    // Copy open-next.config.mjs into the bundle
+    buildHelper.copyOpenNextConfig(options.buildDir, outputPath);
+    // Build Lambda code
+    // note: bundle in OpenNext package b/c the adatper relys on the
+    //       "serverless-http" package which is not a dependency in user's
+    //       Next.js app.
+    await buildHelper.esbuildAsync({
+        entryPoints: [
+            path.join(options.openNextDistDir, "adapters", "warmer-function.js"),
+        ],
+        external: ["next"],
+        outfile: path.join(outputPath, "index.mjs"),
+        plugins: [
+            openNextResolvePlugin({
+                overrides: {
+                    converter: config.warmer?.override?.converter ?? "dummy",
+                    wrapper: config.warmer?.override?.wrapper,
+                },
+                fnName: "warmer",
+            }),
+        ],
+        banner: {
+            js: [
+                "import { createRequire as topLevelCreateRequire } from 'module';",
+                "const require = topLevelCreateRequire(import.meta.url);",
+                "import bannerUrl from 'url';",
+                "const __dirname = bannerUrl.fileURLToPath(new URL('.', import.meta.url));",
+            ].join(""),
+        },
+    }, options);
+    installDependencies(outputPath, config.warmer?.install);
+}

package/dist/build/edge/createEdgeBundle.d.ts

@@ -1,9 +1,8 @@
-import { MiddlewareInfo } from "../../types/next-types";
-import { IncludedConverter, OpenNextConfig, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
-import { BuildOptions } from "../helper.js";
+import type { MiddlewareInfo } from "../../types/next-types";
+import type { IncludedConverter, OverrideOptions, SplittedFunctionOptions } from "../../types/open-next";
+import type { BuildOptions } from "../helper.js";
 interface BuildEdgeBundleOptions {
-    appBuildOutputPath: string;
-    middlewareInfo: MiddlewareInfo;
+    middlewareInfo?: MiddlewareInfo;
     entrypoint: string;
     outfile: string;
     options: BuildOptions;
@@ -14,7 +13,6 @@ interface BuildEdgeBundleOptions {
     additionalExternals?: string[];
     onlyBuildOnce?: boolean;
 }
-export declare function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
-export declare function copyMiddlewareAssetsAndWasm({}: {}): void;
-export declare function generateEdgeBundle(name: string, config: OpenNextConfig, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
+export declare function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }: BuildEdgeBundleOptions): Promise<void>;
+export declare function generateEdgeBundle(name: string, options: BuildOptions, fnOptions: SplittedFunctionOptions): Promise<void>;
 export {};

package/dist/build/edge/createEdgeBundle.js

@@ -1,5 +1,4 @@
 import { mkdirSync } from "node:fs";
-import url from "node:url";
 import { build } from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -8,8 +7,7 @@ import { openNextEdgePlugins } from "../../plugins/edge.js";
 import { openNextReplacementPlugin } from "../../plugins/replacement.js";
 import { openNextResolvePlugin } from "../../plugins/resolve.js";
 import { copyOpenNextConfig, esbuildAsync } from "../helper.js";
-const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
+export async function buildEdgeBundle({ middlewareInfo, entrypoint, outfile, options, defaultConverter, overrides, additionalInject, includeCache, additionalExternals, onlyBuildOnce, }) {
     const isInCloudfare = typeof overrides?.wrapper === "string"
         ? overrides.wrapper === "cloudflare"
         : (await overrides?.wrapper?.())?.edgeRuntime;
@@ -52,8 +50,8 @@ export async function buildEdgeBundle({ appBuildOutputPath, middlewareInfo, entr
             }),
             openNextEdgePlugins({
                 middlewareInfo,
-                nextDir: path.join(appBuildOutputPath, ".next"),
-                edgeFunctionHandlerPath: path.join(__dirname, "../../core", "edgeFunctionHandler.js"),
+                nextDir: path.join(options.appBuildOutputPath, ".next"),
+                edgeFunctionHandlerPath: path.join(options.openNextDistDir, "core", "edgeFunctionHandler.js"),
                 isInCloudfare,
             }),
         ],
@@ -108,15 +106,14 @@ globalThis.AsyncLocalStorage = AsyncLocalStorage;
         });
     }
 }
-export function copyMiddlewareAssetsAndWasm({}) { }
-export async function generateEdgeBundle(name, config, options, fnOptions) {
+export async function generateEdgeBundle(name, options, fnOptions) {
     const { appBuildOutputPath, outputDir } = options;
     logger.info(`Generating edge bundle for: ${name}`);
     // Create output folder
     const outputPath = path.join(outputDir, "server-functions", name);
     fs.mkdirSync(outputPath, { recursive: true });
     // Copy open-next.config.mjs
-    copyOpenNextConfig(path.join(outputDir, ".build"), outputPath, true);
+    copyOpenNextConfig(options.buildDir, outputPath, true);
     // Load middleware manifest
     const middlewareManifest = JSON.parse(fs.readFileSync(path.join(appBuildOutputPath, ".next/server/middleware-manifest.json"), "utf8"));
     // Find functions
@@ -124,26 +121,25 @@ export async function generateEdgeBundle(name, config, options, fnOptions) {
     if (functions.length > 1) {
         throw new Error("Only one function is supported for now");
     }
-    const fn = functions[0];
+    const middlewareInfo = functions[0];
     //Copy wasm files
-    const wasmFiles = fn.wasm;
+    const wasmFiles = middlewareInfo.wasm;
     mkdirSync(path.join(outputPath, "wasm"), { recursive: true });
     for (const wasmFile of wasmFiles) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", wasmFile.filePath), path.join(outputPath, `wasm/${wasmFile.name}.wasm`));
     }
     // Copy assets
-    const assets = fn.assets;
+    const assets = middlewareInfo.assets;
     mkdirSync(path.join(outputPath, "assets"), { recursive: true });
     for (const asset of assets) {
         fs.copyFileSync(path.join(appBuildOutputPath, ".next", asset.filePath), path.join(outputPath, `assets/${asset.name}`));
     }
     await buildEdgeBundle({
-        appBuildOutputPath,
-        middlewareInfo: fn,
-        entrypoint: path.join(__dirname, "../../adapters", "edge-adapter.js"),
+        middlewareInfo,
+        entrypoint: path.join(options.openNextDistDir, "adapters", "edge-adapter.js"),
         outfile: path.join(outputPath, "index.mjs"),
         options,
         overrides: fnOptions.override,
-        additionalExternals: config.edgeExternals,
+        additionalExternals: options.config.edgeExternals,
     });
 }

package/dist/build/helper.d.ts

@@ -1,19 +1,21 @@
-import { BuildOptions as ESBuildOptions } from "esbuild";
-import { OpenNextConfig } from "../types/open-next.js";
+import type { BuildOptions as ESBuildOptions } from "esbuild";
+import type { OpenNextConfig } from "../types/open-next.js";
 export type BuildOptions = ReturnType<typeof normalizeOptions>;
-export declare function normalizeOptions(config: OpenNextConfig): {
+export declare function normalizeOptions(config: OpenNextConfig, distDir: string, tempBuildDir: string): {
     appBuildOutputPath: string;
     appPackageJsonPath: string;
     appPath: string;
     appPublicPath: string;
+    buildDir: string;
     config: OpenNextConfig;
     debug: boolean;
     monorepoRoot: string;
     nextVersion: string;
     openNextVersion: string;
+    openNextDistDir: string;
     outputDir: string;
     packager: "npm" | "yarn" | "pnpm" | "bun";
-    tempDir: string;
+    tempBuildDir: string;
 };
 export declare function esbuildSync(esbuildOptions: ESBuildOptions, options: BuildOptions): void;
 export declare function esbuildAsync(esbuildOptions: ESBuildOptions, options: BuildOptions): Promise<void>;
@@ -31,5 +33,20 @@ export declare function getBuildId(dotNextPath: string): string;
 export declare function getOpenNextVersion(): string;
 export declare function getNextVersion(appPath: string): string;
 export declare function compareSemver(v1: string, v2: string): number;
-export declare function copyOpenNextConfig(tempDir: string, outputPath: string, isEdge?: boolean): void;
+export declare function copyOpenNextConfig(inputDir: string, outputDir: string, isEdge?: boolean): void;
 export declare function copyEnvFile(appPath: string, packagePath: string, outputPath: string): void;
+/**
+ * Check we are in a Nextjs app by looking for the Nextjs config file.
+ */
+export declare function checkRunningInsideNextjsApp(options: BuildOptions): void;
+export declare function printNextjsVersion(options: BuildOptions): void;
+export declare function printOpenNextVersion(options: BuildOptions): void;
+/**
+ * Populates the build directory with the compiled configuration files.
+ *
+ * We need to get the build relative to the cwd to find the compiled config.
+ * This is needed for the case where the app is a single-version monorepo
+ * and the package.json is in the root of the monorepo where the build is in
+ * the app directory, but the compiled config is in the root of the monorepo.
+ */
+export declare function initOutputDir(options: BuildOptions): void;

package/dist/build/helper.js

@@ -1,12 +1,12 @@
 import fs from "node:fs";
-import { createRequire as topLevelCreateRequire } from "node:module";
+import { createRequire } from "node:module";
 import path from "node:path";
 import url from "node:url";
-import { build as buildAsync, buildSync, } from "esbuild";
+import { build as buildAsync, buildSync } from "esbuild";
 import logger from "../logger.js";
-const require = topLevelCreateRequire(import.meta.url);
+const require = createRequire(import.meta.url);
 const __dirname = url.fileURLToPath(new URL(".", import.meta.url));
-export function normalizeOptions(config) {
+export function normalizeOptions(config, distDir, tempBuildDir) {
     const appPath = path.join(process.cwd(), config.appPath || ".");
     const buildOutputPath = path.join(process.cwd(), config.buildOutputPath || ".");
     const outputDir = path.join(buildOutputPath, ".open-next");
@@ -26,14 +26,16 @@ export function normalizeOptions(config) {
         appPackageJsonPath,
         appPath,
         appPublicPath: path.join(appPath, "public"),
+        buildDir: path.join(outputDir, ".build"),
         config,
         debug: Boolean(process.env.OPEN_NEXT_DEBUG) ?? false,
         monorepoRoot,
         nextVersion: getNextVersion(appPath),
         openNextVersion: getOpenNextVersion(),
+        openNextDistDir: distDir,
         outputDir,
         packager,
-        tempDir: path.join(outputDir, ".build"),
+        tempBuildDir,
     };
 }
 function findMonorepoRoot(appPath) {
@@ -56,6 +58,7 @@ function findMonorepoRoot(appPath) {
     // note: a lock file (package-lock.json, yarn.lock, or pnpm-lock.yaml) is
     //       not found in the app's directory or any of its parent directories.
     //       We are going to assume that the app is not part of a monorepo.
+    logger.warn("No lockfile found");
     return { root: appPath, packager: "npm" };
 }
 function findNextPackageJsonPath(appPath, root) {
@@ -158,10 +161,7 @@ export function getHtmlPages(dotNextPath) {
     return Object.entries(JSON.parse(manifest))
         .filter(([_, value]) => value.endsWith(".html"))
         .map(([_, value]) => value.replace(/^pages\//, ""))
-        .reduce((acc, page) => {
-        acc.add(page);
-        return acc;
-    }, new Set());
+        .reduce((acc, page) => acc.add(page), new Set());
 }
 export function getBuildId(dotNextPath) {
     return fs
@@ -200,9 +200,9 @@ export function compareSemver(v1, v2) {
         return minor1 - minor2;
     return patch1 - patch2;
 }
-export function copyOpenNextConfig(tempDir, outputPath, isEdge = false) {
+export function copyOpenNextConfig(inputDir, outputDir, isEdge = false) {
     // Copy open-next.config.mjs
-    fs.copyFileSync(path.join(tempDir, isEdge ? "open-next.config.edge.mjs" : "open-next.config.mjs"), path.join(outputPath, "open-next.config.mjs"));
+    fs.copyFileSync(path.join(inputDir, isEdge ? "open-next.config.edge.mjs" : "open-next.config.mjs"), path.join(outputDir, "open-next.config.mjs"));
 }
 export function copyEnvFile(appPath, packagePath, outputPath) {
     const baseAppPath = path.join(appPath, ".next/standalone", packagePath);
@@ -216,3 +216,34 @@ export function copyEnvFile(appPath, packagePath, outputPath) {
         fs.copyFileSync(envProdPath, path.join(baseOutputPath, ".env.production"));
     }
 }
+/**
+ * Check we are in a Nextjs app by looking for the Nextjs config file.
+ */
+export function checkRunningInsideNextjsApp(options) {
+    const { appPath } = options;
+    const extension = ["js", "cjs", "mjs", "ts"].find((ext) => fs.existsSync(path.join(appPath, `next.config.${ext}`)));
+    if (!extension) {
+        logger.error("Error: next.config.js not found. Please make sure you are running this command inside a Next.js app.");
+        process.exit(1);
+    }
+}
+export function printNextjsVersion(options) {
+    logger.info(`Next.js version : ${options.nextVersion}`);
+}
+export function printOpenNextVersion(options) {
+    logger.info(`OpenNext v${options.openNextVersion}`);
+}
+/**
+ * Populates the build directory with the compiled configuration files.
+ *
+ * We need to get the build relative to the cwd to find the compiled config.
+ * This is needed for the case where the app is a single-version monorepo
+ * and the package.json is in the root of the monorepo where the build is in
+ * the app directory, but the compiled config is in the root of the monorepo.
+ */
+export function initOutputDir(options) {
+    fs.rmSync(options.outputDir, { recursive: true, force: true });
+    const { buildDir } = options;
+    fs.mkdirSync(buildDir, { recursive: true });
+    fs.cpSync(options.tempBuildDir, buildDir, { recursive: true });
+}

package/dist/build/installDeps.d.ts

@@ -0,0 +1,2 @@
+import type { InstallOptions } from "../types/open-next";
+export declare function installDependencies(outputDir: string, installOptions?: InstallOptions): void;

package/dist/build/installDeps.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execSync } from "child_process";
+import logger from "../logger.js";
+export function installDependencies(outputDir, installOptions) {
+    try {
+        if (!installOptions) {
+            return;
+        }
+        const name = outputDir.split("/").pop();
+        // First we create a tempDir
+        const tempInstallDir = fs.mkdtempSync(path.join(os.tmpdir(), `open-next-install-${name}`));
+        logger.info(`Installing dependencies for ${name}...`);
+        // We then need to run install in the tempDir
+        // We don't install in the output dir directly because it could contain a package.json, and npm would then try to reinstall not complete deps from tracing the files
+        const archOption = installOptions.arch
+            ? `--arch=${installOptions.arch}`
+            : "";
+        const targetOption = installOptions.nodeVersion
+            ? `--target=${installOptions.nodeVersion}`
+            : "";
+        const libcOption = installOptions.libc
+            ? `--libc=${installOptions.libc}`
+            : "";
+        const additionalArgs = installOptions.additionalArgs ?? "";
+        const installCommand = `npm install --platform=linux ${archOption} ${targetOption} ${libcOption} ${additionalArgs} ${installOptions.packages.join(" ")}`;
+        execSync(installCommand, {
+            stdio: "pipe",
+            cwd: tempInstallDir,
+            env: {
+                ...process.env,
+                SHARP_IGNORE_GLOBAL_LIBVIPS: "1",
+            },
+        });
+        // Copy the node_modules to the outputDir
+        fs.cpSync(path.join(tempInstallDir, "node_modules"), path.join(outputDir, "node_modules"), { recursive: true, force: true, dereference: true });
+        // Cleanup tempDir
+        fs.rmSync(tempInstallDir, { recursive: true, force: true });
+        logger.info(`Dependencies installed for ${name}`);
+    }
+    catch (e) {
+        logger.error(e.stdout.toString());
+        logger.error("Could not install dependencies");
+    }
+}

package/dist/build/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function printHeader(header: string): void;
+/**
+ * Displays a warning on windows platform.
+ */
+export declare function showWarningOnWindows(): void;

package/dist/build/utils.js

@@ -0,0 +1,22 @@
+import os from "node:os";
+import logger from "../logger.js";
+export function printHeader(header) {
+    header = `OpenNext — ${header}`;
+    logger.info([
+        "",
+        "┌" + "─".repeat(header.length + 2) + "┐",
+        `│ ${header} │`,
+        "└" + "─".repeat(header.length + 2) + "┘",
+        "",
+    ].join("\n"));
+}
+/**
+ * Displays a warning on windows platform.
+ */
+export function showWarningOnWindows() {
+    if (os.platform() !== "win32")
+        return;
+    logger.warn("OpenNext is not fully compatible with Windows.");
+    logger.warn("For optimal performance, it is recommended to use Windows Subsystem for Linux (WSL).");
+    logger.warn("While OpenNext may function on Windows, it could encounter unpredictable failures during runtime.");
+}

package/dist/build/validateConfig.d.ts

@@ -1,2 +1,2 @@
-import { OpenNextConfig } from "../types/open-next";
+import type { OpenNextConfig } from "../types/open-next";
 export declare function validateConfig(config: OpenNextConfig): void;

package/dist/build.d.ts

@@ -1,8 +1,4 @@
-import { BuildOptions } from "./build/helper.js";
 export type PublicFiles = {
     files: string[];
 };
 export declare function build(openNextConfigPath?: string, nodeExternals?: string): Promise<void>;
-/***************************/
-/***************************/
-export declare function compileCache(options: BuildOptions, format?: "cjs" | "esm"): string;