Initial boiler plate project

node_modules/next/dist/esm/build/webpack-build/impl.js

@@ -0,0 +1,286 @@
+import { red } from "../../lib/picocolors";
+import formatWebpackMessages from "../../client/components/react-dev-overlay/internal/helpers/format-webpack-messages";
+import { nonNullable } from "../../lib/non-nullable";
+import { COMPILER_NAMES, CLIENT_STATIC_FILES_RUNTIME_MAIN_APP, APP_CLIENT_INTERNALS, PHASE_PRODUCTION_BUILD } from "../../shared/lib/constants";
+import { runCompiler } from "../compiler";
+import * as Log from "../output/log";
+import getBaseWebpackConfig, { loadProjectInfo } from "../webpack-config";
+import { TelemetryPlugin } from "../webpack/plugins/telemetry-plugin";
+import { NextBuildContext, resumePluginState, getPluginState } from "../build-context";
+import { createEntrypoints } from "../entries";
+import loadConfig from "../../server/config";
+import { getTraceEvents, initializeTraceState, setGlobal, trace } from "../../trace";
+import { WEBPACK_LAYERS } from "../../lib/constants";
+import { TraceEntryPointsPlugin } from "../webpack/plugins/next-trace-entrypoints-plugin";
+import origDebug from "next/dist/compiled/debug";
+import { Telemetry } from "../../telemetry/storage";
+const debug = origDebug("next:build:webpack-build");
+function isTelemetryPlugin(plugin) {
+    return plugin instanceof TelemetryPlugin;
+}
+function isTraceEntryPointsPlugin(plugin) {
+    return plugin instanceof TraceEntryPointsPlugin;
+}
+export async function webpackBuildImpl(compilerName) {
+    var _clientConfig_plugins, _serverConfig_plugins;
+    let result = {
+        warnings: [],
+        errors: [],
+        stats: []
+    };
+    let webpackBuildStart;
+    const nextBuildSpan = NextBuildContext.nextBuildSpan;
+    const dir = NextBuildContext.dir;
+    const config = NextBuildContext.config;
+    const runWebpackSpan = nextBuildSpan.traceChild("run-webpack-compiler");
+    const entrypoints = await nextBuildSpan.traceChild("create-entrypoints").traceAsyncFn(()=>createEntrypoints({
+            buildId: NextBuildContext.buildId,
+            config: config,
+            envFiles: NextBuildContext.loadedEnvFiles,
+            isDev: false,
+            rootDir: dir,
+            pageExtensions: config.pageExtensions,
+            pagesDir: NextBuildContext.pagesDir,
+            appDir: NextBuildContext.appDir,
+            pages: NextBuildContext.mappedPages,
+            appPaths: NextBuildContext.mappedAppPages,
+            previewMode: NextBuildContext.previewProps,
+            rootPaths: NextBuildContext.mappedRootPaths,
+            hasInstrumentationHook: NextBuildContext.hasInstrumentationHook
+        }));
+    const commonWebpackOptions = {
+        isServer: false,
+        buildId: NextBuildContext.buildId,
+        encryptionKey: NextBuildContext.encryptionKey,
+        config: config,
+        appDir: NextBuildContext.appDir,
+        pagesDir: NextBuildContext.pagesDir,
+        rewrites: NextBuildContext.rewrites,
+        originalRewrites: NextBuildContext.originalRewrites,
+        originalRedirects: NextBuildContext.originalRedirects,
+        reactProductionProfiling: NextBuildContext.reactProductionProfiling,
+        noMangling: NextBuildContext.noMangling,
+        clientRouterFilters: NextBuildContext.clientRouterFilters,
+        previewModeId: NextBuildContext.previewModeId,
+        allowedRevalidateHeaderKeys: NextBuildContext.allowedRevalidateHeaderKeys,
+        fetchCacheKeyPrefix: NextBuildContext.fetchCacheKeyPrefix
+    };
+    const configs = await runWebpackSpan.traceChild("generate-webpack-config").traceAsyncFn(async ()=>{
+        const info = await loadProjectInfo({
+            dir,
+            config: commonWebpackOptions.config,
+            dev: false
+        });
+        return Promise.all([
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                runWebpackSpan,
+                compilerType: COMPILER_NAMES.client,
+                entrypoints: entrypoints.client,
+                ...info
+            }),
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                runWebpackSpan,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                compilerType: COMPILER_NAMES.server,
+                entrypoints: entrypoints.server,
+                ...info
+            }),
+            getBaseWebpackConfig(dir, {
+                ...commonWebpackOptions,
+                runWebpackSpan,
+                middlewareMatchers: entrypoints.middlewareMatchers,
+                compilerType: COMPILER_NAMES.edgeServer,
+                entrypoints: entrypoints.edgeServer,
+                edgePreviewProps: {
+                    __NEXT_PREVIEW_MODE_ID: NextBuildContext.previewProps.previewModeId,
+                    __NEXT_PREVIEW_MODE_ENCRYPTION_KEY: NextBuildContext.previewProps.previewModeEncryptionKey,
+                    __NEXT_PREVIEW_MODE_SIGNING_KEY: NextBuildContext.previewProps.previewModeSigningKey
+                },
+                ...info
+            })
+        ]);
+    });
+    const clientConfig = configs[0];
+    const serverConfig = configs[1];
+    const edgeConfig = configs[2];
+    if (clientConfig.optimization && (clientConfig.optimization.minimize !== true || clientConfig.optimization.minimizer && clientConfig.optimization.minimizer.length === 0)) {
+        Log.warn(`Production code optimization has been disabled in your project. Read more: https://nextjs.org/docs/messages/minification-disabled`);
+    }
+    webpackBuildStart = process.hrtime();
+    debug(`starting compiler`, compilerName);
+    // We run client and server compilation separately to optimize for memory usage
+    await runWebpackSpan.traceAsyncFn(async ()=>{
+        var _inputFileSystem_purge;
+        // Run the server compilers first and then the client
+        // compiler to track the boundary of server/client components.
+        let clientResult = null;
+        // During the server compilations, entries of client components will be
+        // injected to this set and then will be consumed by the client compiler.
+        let serverResult = null;
+        let edgeServerResult = null;
+        let inputFileSystem;
+        if (!compilerName || compilerName === "server") {
+            debug("starting server compiler");
+            const start = Date.now();
+            [serverResult, inputFileSystem] = await runCompiler(serverConfig, {
+                runWebpackSpan,
+                inputFileSystem
+            });
+            debug(`server compiler finished ${Date.now() - start}ms`);
+        }
+        if (!compilerName || compilerName === "edge-server") {
+            debug("starting edge-server compiler");
+            const start = Date.now();
+            [edgeServerResult, inputFileSystem] = edgeConfig ? await runCompiler(edgeConfig, {
+                runWebpackSpan,
+                inputFileSystem
+            }) : [
+                null
+            ];
+            debug(`edge-server compiler finished ${Date.now() - start}ms`);
+        }
+        // Only continue if there were no errors
+        if (!(serverResult == null ? void 0 : serverResult.errors.length) && !(edgeServerResult == null ? void 0 : edgeServerResult.errors.length)) {
+            const pluginState = getPluginState();
+            for(const key in pluginState.injectedClientEntries){
+                const value = pluginState.injectedClientEntries[key];
+                const clientEntry = clientConfig.entry;
+                if (key === APP_CLIENT_INTERNALS) {
+                    clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP] = {
+                        import: [
+                            // TODO-APP: cast clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP] to type EntryDescription once it's available from webpack
+                            // @ts-expect-error clientEntry['main-app'] is type EntryDescription { import: ... }
+                            ...clientEntry[CLIENT_STATIC_FILES_RUNTIME_MAIN_APP].import,
+                            value
+                        ],
+                        layer: WEBPACK_LAYERS.appPagesBrowser
+                    };
+                } else {
+                    clientEntry[key] = {
+                        dependOn: [
+                            CLIENT_STATIC_FILES_RUNTIME_MAIN_APP
+                        ],
+                        import: value,
+                        layer: WEBPACK_LAYERS.appPagesBrowser
+                    };
+                }
+            }
+            if (!compilerName || compilerName === "client") {
+                debug("starting client compiler");
+                const start = Date.now();
+                [clientResult, inputFileSystem] = await runCompiler(clientConfig, {
+                    runWebpackSpan,
+                    inputFileSystem
+                });
+                debug(`client compiler finished ${Date.now() - start}ms`);
+            }
+        }
+        inputFileSystem == null ? void 0 : (_inputFileSystem_purge = inputFileSystem.purge) == null ? void 0 : _inputFileSystem_purge.call(inputFileSystem);
+        result = {
+            warnings: [
+                ...(clientResult == null ? void 0 : clientResult.warnings) ?? [],
+                ...(serverResult == null ? void 0 : serverResult.warnings) ?? [],
+                ...(edgeServerResult == null ? void 0 : edgeServerResult.warnings) ?? []
+            ].filter(nonNullable),
+            errors: [
+                ...(clientResult == null ? void 0 : clientResult.errors) ?? [],
+                ...(serverResult == null ? void 0 : serverResult.errors) ?? [],
+                ...(edgeServerResult == null ? void 0 : edgeServerResult.errors) ?? []
+            ].filter(nonNullable),
+            stats: [
+                clientResult == null ? void 0 : clientResult.stats,
+                serverResult == null ? void 0 : serverResult.stats,
+                edgeServerResult == null ? void 0 : edgeServerResult.stats
+            ]
+        };
+    });
+    result = nextBuildSpan.traceChild("format-webpack-messages").traceFn(()=>formatWebpackMessages(result, true));
+    const telemetryPlugin = (_clientConfig_plugins = clientConfig.plugins) == null ? void 0 : _clientConfig_plugins.find(isTelemetryPlugin);
+    const traceEntryPointsPlugin = (_serverConfig_plugins = serverConfig.plugins) == null ? void 0 : _serverConfig_plugins.find(isTraceEntryPointsPlugin);
+    const webpackBuildEnd = process.hrtime(webpackBuildStart);
+    if (result.errors.length > 0) {
+        // Only keep the first few errors. Others are often indicative
+        // of the same problem, but confuse the reader with noise.
+        if (result.errors.length > 5) {
+            result.errors.length = 5;
+        }
+        let error = result.errors.filter(Boolean).join("\n\n");
+        console.error(red("Failed to compile.\n"));
+        if (error.indexOf("private-next-pages") > -1 && error.indexOf("does not contain a default export") > -1) {
+            const page_name_regex = /'private-next-pages\/(?<page_name>[^']*)'/;
+            const parsed = page_name_regex.exec(error);
+            const page_name = parsed && parsed.groups && parsed.groups.page_name;
+            throw new Error(`webpack build failed: found page without a React Component as default export in pages/${page_name}\n\nSee https://nextjs.org/docs/messages/page-without-valid-component for more info.`);
+        }
+        console.error(error);
+        console.error();
+        if (error.indexOf("private-next-pages") > -1 || error.indexOf("__next_polyfill__") > -1) {
+            const err = new Error("webpack config.resolve.alias was incorrectly overridden. https://nextjs.org/docs/messages/invalid-resolve-alias");
+            err.code = "INVALID_RESOLVE_ALIAS";
+            throw err;
+        }
+        const err = new Error("Build failed because of webpack errors");
+        err.code = "WEBPACK_ERRORS";
+        throw err;
+    } else {
+        if (result.warnings.length > 0) {
+            Log.warn("Compiled with warnings\n");
+            console.warn(result.warnings.filter(Boolean).join("\n\n"));
+            console.warn();
+        } else if (!compilerName) {
+            Log.event("Compiled successfully");
+        }
+        return {
+            duration: webpackBuildEnd[0],
+            buildTraceContext: traceEntryPointsPlugin == null ? void 0 : traceEntryPointsPlugin.buildTraceContext,
+            pluginState: getPluginState(),
+            telemetryState: {
+                usages: (telemetryPlugin == null ? void 0 : telemetryPlugin.usages()) || [],
+                packagesUsedInServerSideProps: (telemetryPlugin == null ? void 0 : telemetryPlugin.packagesUsedInServerSideProps()) || []
+            }
+        };
+    }
+}
+// the main function when this file is run as a worker
+export async function workerMain(workerData) {
+    // Clone the telemetry for worker
+    const telemetry = new Telemetry({
+        distDir: workerData.buildContext.config.distDir
+    });
+    setGlobal("telemetry", telemetry);
+    // setup new build context from the serialized data passed from the parent
+    Object.assign(NextBuildContext, workerData.buildContext);
+    // Initialize tracer state from the parent
+    initializeTraceState(workerData.traceState);
+    // Resume plugin state
+    resumePluginState(NextBuildContext.pluginState);
+    /// load the config because it's not serializable
+    NextBuildContext.config = await loadConfig(PHASE_PRODUCTION_BUILD, NextBuildContext.dir);
+    NextBuildContext.nextBuildSpan = trace(`worker-main-${workerData.compilerName}`);
+    const result = await webpackBuildImpl(workerData.compilerName);
+    const { entriesTrace, chunksTrace } = result.buildTraceContext ?? {};
+    if (entriesTrace) {
+        const { entryNameMap, depModArray } = entriesTrace;
+        if (depModArray) {
+            result.buildTraceContext.entriesTrace.depModArray = depModArray;
+        }
+        if (entryNameMap) {
+            const entryEntries = entryNameMap;
+            result.buildTraceContext.entriesTrace.entryNameMap = entryEntries;
+        }
+    }
+    if (chunksTrace == null ? void 0 : chunksTrace.entryNameFilesMap) {
+        const entryNameFilesMap = chunksTrace.entryNameFilesMap;
+        result.buildTraceContext.chunksTrace.entryNameFilesMap = entryNameFilesMap;
+    }
+    NextBuildContext.nextBuildSpan.stop();
+    return {
+        ...result,
+        debugTraceEvents: getTraceEvents()
+    };
+}
+
+//# sourceMappingURL=impl.js.map

node_modules/next/dist/esm/build/webpack-build/index.js

@@ -0,0 +1,117 @@
+import * as Log from "../output/log";
+import { NextBuildContext } from "../build-context";
+import { Worker } from "next/dist/compiled/jest-worker";
+import origDebug from "next/dist/compiled/debug";
+import path from "path";
+import { exportTraceState, recordTraceEvents } from "../../trace";
+const debug = origDebug("next:build:webpack-build");
+const ORDERED_COMPILER_NAMES = [
+    "server",
+    "edge-server",
+    "client"
+];
+let pluginState = {};
+function deepMerge(target, source) {
+    const result = {
+        ...target,
+        ...source
+    };
+    for (const key of Object.keys(result)){
+        result[key] = Array.isArray(target[key]) ? target[key] = [
+            ...target[key],
+            ...source[key] || []
+        ] : typeof target[key] == "object" && typeof source[key] == "object" ? deepMerge(target[key], source[key]) : result[key];
+    }
+    return result;
+}
+async function webpackBuildWithWorker(compilerNamesArg) {
+    const compilerNames = compilerNamesArg || ORDERED_COMPILER_NAMES;
+    const { nextBuildSpan, ...prunedBuildContext } = NextBuildContext;
+    prunedBuildContext.pluginState = pluginState;
+    const getWorker = (compilerName)=>{
+        var _worker__workerPool;
+        const _worker = new Worker(path.join(__dirname, "impl.js"), {
+            exposedMethods: [
+                "workerMain"
+            ],
+            numWorkers: 1,
+            maxRetries: 0,
+            forkOptions: {
+                env: {
+                    ...process.env,
+                    NEXT_PRIVATE_BUILD_WORKER: "1"
+                }
+            }
+        });
+        _worker.getStderr().pipe(process.stderr);
+        _worker.getStdout().pipe(process.stdout);
+        for (const worker of ((_worker__workerPool = _worker._workerPool) == null ? void 0 : _worker__workerPool._workers) || []){
+            worker._child.on("exit", (code, signal)=>{
+                if (code || signal && signal !== "SIGINT") {
+                    debug(`Compiler ${compilerName} unexpectedly exited with code: ${code} and signal: ${signal}`);
+                }
+            });
+        }
+        return _worker;
+    };
+    const combinedResult = {
+        duration: 0,
+        buildTraceContext: {}
+    };
+    for (const compilerName of compilerNames){
+        var _curResult_buildTraceContext;
+        const worker = getWorker(compilerName);
+        const curResult = await worker.workerMain({
+            buildContext: prunedBuildContext,
+            compilerName,
+            traceState: {
+                ...exportTraceState(),
+                defaultParentSpanId: nextBuildSpan == null ? void 0 : nextBuildSpan.getId(),
+                shouldSaveTraceEvents: true
+            }
+        });
+        if (nextBuildSpan && curResult.debugTraceEvents) {
+            recordTraceEvents(curResult.debugTraceEvents);
+        }
+        // destroy worker so it's not sticking around using memory
+        await worker.end();
+        // Update plugin state
+        pluginState = deepMerge(pluginState, curResult.pluginState);
+        prunedBuildContext.pluginState = pluginState;
+        if (curResult.telemetryState) {
+            NextBuildContext.telemetryState = curResult.telemetryState;
+        }
+        combinedResult.duration += curResult.duration;
+        if ((_curResult_buildTraceContext = curResult.buildTraceContext) == null ? void 0 : _curResult_buildTraceContext.entriesTrace) {
+            var _curResult_buildTraceContext1;
+            const { entryNameMap } = curResult.buildTraceContext.entriesTrace;
+            if (entryNameMap) {
+                combinedResult.buildTraceContext.entriesTrace = curResult.buildTraceContext.entriesTrace;
+                combinedResult.buildTraceContext.entriesTrace.entryNameMap = entryNameMap;
+            }
+            if ((_curResult_buildTraceContext1 = curResult.buildTraceContext) == null ? void 0 : _curResult_buildTraceContext1.chunksTrace) {
+                const { entryNameFilesMap } = curResult.buildTraceContext.chunksTrace;
+                if (entryNameFilesMap) {
+                    combinedResult.buildTraceContext.chunksTrace = curResult.buildTraceContext.chunksTrace;
+                    combinedResult.buildTraceContext.chunksTrace.entryNameFilesMap = entryNameFilesMap;
+                }
+            }
+        }
+    }
+    if (compilerNames.length === 3) {
+        Log.event("Compiled successfully");
+    }
+    return combinedResult;
+}
+export function webpackBuild(withWorker, compilerNames) {
+    if (withWorker) {
+        debug("using separate compiler workers");
+        return webpackBuildWithWorker(compilerNames);
+    } else {
+        debug("building all compilers in same process");
+        const webpackBuildImpl = require("./impl").webpackBuildImpl;
+        return webpackBuildImpl(null, null);
+    }
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack-build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/build/webpack-build/index.ts"],"names":["Log","NextBuildContext","Worker","origDebug","path","exportTraceState","recordTraceEvents","debug","ORDERED_COMPILER_NAMES","pluginState","deepMerge","target","source","result","key","Object","keys","Array","isArray","webpackBuildWithWorker","compilerNamesArg","compilerNames","nextBuildSpan","prunedBuildContext","getWorker","compilerName","_worker","join","__dirname","exposedMethods","numWorkers","maxRetries","forkOptions","env","process","NEXT_PRIVATE_BUILD_WORKER","getStderr","pipe","stderr","getStdout","stdout","worker","_workerPool","_workers","_child","on","code","signal","combinedResult","duration","buildTraceContext","curResult","workerMain","buildContext","traceState","defaultParentSpanId","getId","shouldSaveTraceEvents","debugTraceEvents","end","telemetryState","entriesTrace","entryNameMap","chunksTrace","entryNameFilesMap","length","event","webpackBuild","withWorker","webpackBuildImpl","require"],"mappings":"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"}