1643 lines
84 KiB
JavaScript
1643 lines
84 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
Object.defineProperty(exports, "setupDevBundler", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return setupDevBundler;
|
|
}
|
|
});
|
|
const _ws = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/ws"));
|
|
const _swc = require("../../../build/swc");
|
|
const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
|
|
const _url = /*#__PURE__*/ _interop_require_default(require("url"));
|
|
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
|
const _querystring = /*#__PURE__*/ _interop_require_default(require("querystring"));
|
|
const _watchpack = /*#__PURE__*/ _interop_require_default(require("watchpack"));
|
|
const _env = require("@next/env");
|
|
const _iserror = /*#__PURE__*/ _interop_require_default(require("../../../lib/is-error"));
|
|
const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
|
|
const _filesystem = require("./filesystem");
|
|
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../../build/output/log"));
|
|
const _hotreloaderwebpack = /*#__PURE__*/ _interop_require_wildcard(require("../../dev/hot-reloader-webpack"));
|
|
const _shared = require("../../../trace/shared");
|
|
const _loadjsconfig = /*#__PURE__*/ _interop_require_default(require("../../../build/load-jsconfig"));
|
|
const _findpagefile = require("../find-page-file");
|
|
const _events = require("../../../telemetry/events");
|
|
const _defineenvplugin = require("../../../build/webpack/plugins/define-env-plugin");
|
|
const _logappdirerror = require("../../dev/log-app-dir-error");
|
|
const _utils = require("../../../shared/lib/router/utils");
|
|
const _entries = require("../../../build/entries");
|
|
const _verifytypescriptsetup = require("../../../lib/verify-typescript-setup");
|
|
const _verifypartytownsetup = require("../../../lib/verify-partytown-setup");
|
|
const _routeregex = require("../../../shared/lib/router/utils/route-regex");
|
|
const _apppaths = require("../../../shared/lib/router/utils/app-paths");
|
|
const _builddataroute = require("./build-data-route");
|
|
const _routematcher = require("../../../shared/lib/router/utils/route-matcher");
|
|
const _normalizepathsep = require("../../../shared/lib/page-path/normalize-path-sep");
|
|
const _createclientrouterfilter = require("../../../lib/create-client-router-filter");
|
|
const _absolutepathtopage = require("../../../shared/lib/page-path/absolute-path-to-page");
|
|
const _generateinterceptionroutesrewrites = require("../../../lib/generate-interception-routes-rewrites");
|
|
const _store = require("../../../build/output/store");
|
|
const _constants = require("../../../shared/lib/constants");
|
|
const _middlewareroutematcher = require("../../../shared/lib/router/utils/middleware-route-matcher");
|
|
const _buildcontext = require("../../../build/build-context");
|
|
const _worker = require("../../../build/worker");
|
|
const _middleware = require("next/dist/compiled/@next/react-dev-overlay/dist/middleware");
|
|
const _promises = require("fs/promises");
|
|
const _utils1 = require("../../../shared/lib/utils");
|
|
const _buildmanifestplugin = require("../../../build/webpack/plugins/build-manifest-plugin");
|
|
const _shared1 = require("../../../build/webpack/plugins/next-types-plugin/shared");
|
|
const _pathtoregexp = require("next/dist/compiled/path-to-regexp");
|
|
const _hotreloadertypes = require("../../dev/hot-reloader-types");
|
|
const _utils2 = require("../../utils");
|
|
const _nextjsrequirecachehotreloader = require("../../../build/webpack/plugins/nextjs-require-cache-hot-reloader");
|
|
const _getmetadataroute = require("../../../lib/metadata/get-metadata-route");
|
|
const _renderserver = require("../render-server");
|
|
const _denormalizepagepath = require("../../../shared/lib/page-path/denormalize-page-path");
|
|
function _interop_require_default(obj) {
|
|
return obj && obj.__esModule ? obj : {
|
|
default: obj
|
|
};
|
|
}
|
|
function _getRequireWildcardCache(nodeInterop) {
|
|
if (typeof WeakMap !== "function") return null;
|
|
var cacheBabelInterop = new WeakMap();
|
|
var cacheNodeInterop = new WeakMap();
|
|
return (_getRequireWildcardCache = function(nodeInterop) {
|
|
return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
|
|
})(nodeInterop);
|
|
}
|
|
function _interop_require_wildcard(obj, nodeInterop) {
|
|
if (!nodeInterop && obj && obj.__esModule) {
|
|
return obj;
|
|
}
|
|
if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
|
|
return {
|
|
default: obj
|
|
};
|
|
}
|
|
var cache = _getRequireWildcardCache(nodeInterop);
|
|
if (cache && cache.has(obj)) {
|
|
return cache.get(obj);
|
|
}
|
|
var newObj = {};
|
|
var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for(var key in obj){
|
|
if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
|
|
var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
|
|
if (desc && (desc.get || desc.set)) {
|
|
Object.defineProperty(newObj, key, desc);
|
|
} else {
|
|
newObj[key] = obj[key];
|
|
}
|
|
}
|
|
}
|
|
newObj.default = obj;
|
|
if (cache) {
|
|
cache.set(obj, newObj);
|
|
}
|
|
return newObj;
|
|
}
|
|
const wsServer = new _ws.default.Server({
|
|
noServer: true
|
|
});
|
|
async function verifyTypeScript(opts) {
|
|
let usingTypeScript = false;
|
|
const verifyResult = await (0, _verifytypescriptsetup.verifyTypeScriptSetup)({
|
|
dir: opts.dir,
|
|
distDir: opts.nextConfig.distDir,
|
|
intentDirs: [
|
|
opts.pagesDir,
|
|
opts.appDir
|
|
].filter(Boolean),
|
|
typeCheckPreflight: false,
|
|
tsconfigPath: opts.nextConfig.typescript.tsconfigPath,
|
|
disableStaticImages: opts.nextConfig.images.disableStaticImages,
|
|
hasAppDir: !!opts.appDir,
|
|
hasPagesDir: !!opts.pagesDir
|
|
});
|
|
if (verifyResult.version) {
|
|
usingTypeScript = true;
|
|
}
|
|
return usingTypeScript;
|
|
}
|
|
async function startWatcher(opts) {
|
|
const { nextConfig, appDir, pagesDir, dir } = opts;
|
|
const { useFileSystemPublicRoutes } = nextConfig;
|
|
const usingTypeScript = await verifyTypeScript(opts);
|
|
const distDir = _path.default.join(opts.dir, opts.nextConfig.distDir);
|
|
(0, _shared.setGlobal)("distDir", distDir);
|
|
(0, _shared.setGlobal)("phase", _constants.PHASE_DEVELOPMENT_SERVER);
|
|
const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(nextConfig.pageExtensions, appDir);
|
|
async function propagateServerField(field, args) {
|
|
var _opts_renderServer_instance, _opts_renderServer;
|
|
await ((_opts_renderServer = opts.renderServer) == null ? void 0 : (_opts_renderServer_instance = _opts_renderServer.instance) == null ? void 0 : _opts_renderServer_instance.propagateServerField(opts.dir, field, args));
|
|
}
|
|
const serverFields = {};
|
|
let hotReloader;
|
|
if (opts.turbo) {
|
|
const { loadBindings } = require("../../../build/swc");
|
|
let bindings = await loadBindings();
|
|
const { jsConfig } = await (0, _loadjsconfig.default)(dir, opts.nextConfig);
|
|
// For the debugging purpose, check if createNext or equivalent next instance setup in test cases
|
|
// works correctly. Normally `run-test` hides output so only will be visible when `--debug` flag is used.
|
|
if (process.env.TURBOPACK && process.env.NEXT_TEST_MODE) {
|
|
require("console").log("Creating turbopack project", {
|
|
dir,
|
|
testMode: process.env.NEXT_TEST_MODE
|
|
});
|
|
}
|
|
const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
|
|
const project = await bindings.turbo.createProject({
|
|
projectPath: dir,
|
|
rootPath: opts.nextConfig.experimental.outputFileTracingRoot || dir,
|
|
nextConfig: opts.nextConfig,
|
|
jsConfig: jsConfig ?? {
|
|
compilerOptions: {}
|
|
},
|
|
watch: true,
|
|
env: process.env,
|
|
defineEnv: (0, _swc.createDefineEnv)({
|
|
allowedRevalidateHeaderKeys: undefined,
|
|
clientRouterFilters: undefined,
|
|
config: nextConfig,
|
|
dev: true,
|
|
distDir,
|
|
fetchCacheKeyPrefix: undefined,
|
|
hasRewrites,
|
|
middlewareMatchers: undefined,
|
|
previewModeId: undefined
|
|
}),
|
|
serverAddr: `127.0.0.1:${opts.port}`
|
|
});
|
|
const iter = project.entrypointsSubscribe();
|
|
const curEntries = new Map();
|
|
const changeSubscriptions = new Map();
|
|
let prevMiddleware = undefined;
|
|
const globalEntries = {
|
|
app: undefined,
|
|
document: undefined,
|
|
error: undefined
|
|
};
|
|
let currentEntriesHandlingResolve;
|
|
let currentEntriesHandling = new Promise((resolve)=>currentEntriesHandlingResolve = resolve);
|
|
const hmrPayloads = new Map();
|
|
const turbopackUpdates = [];
|
|
let hmrBuilding = false;
|
|
const issues = new Map();
|
|
function issueKey(issue) {
|
|
return `${issue.severity} - ${issue.filePath} - ${issue.title}\n${issue.description}\n\n`;
|
|
}
|
|
function formatIssue(issue) {
|
|
const { filePath, title, description, source, detail } = issue;
|
|
let formattedTitle = title.replace(/\n/g, "\n ");
|
|
let message = "";
|
|
let formattedFilePath = filePath.replace("[project]/", "").replaceAll("/./", "/").replace("\\\\?\\", "");
|
|
if (source) {
|
|
const { start, end } = source;
|
|
message = `${issue.severity} - ${formattedFilePath}:${start.line + 1}:${start.column} ${formattedTitle}`;
|
|
if (source.source.content) {
|
|
const { codeFrameColumns } = require("next/dist/compiled/babel/code-frame");
|
|
message += "\n\n" + codeFrameColumns(source.source.content, {
|
|
start: {
|
|
line: start.line + 1,
|
|
column: start.column + 1
|
|
},
|
|
end: {
|
|
line: end.line + 1,
|
|
column: end.column + 1
|
|
}
|
|
}, {
|
|
forceColor: true
|
|
});
|
|
}
|
|
} else {
|
|
message = `${formattedTitle}`;
|
|
}
|
|
if (description) {
|
|
message += `\n${description.replace(/\n/g, "\n ")}`;
|
|
}
|
|
if (detail) {
|
|
message += `\n${detail.replace(/\n/g, "\n ")}`;
|
|
}
|
|
return message;
|
|
}
|
|
class ModuleBuildError extends Error {
|
|
}
|
|
function processIssues(displayName, name, result, throwIssue = false) {
|
|
const oldSet = issues.get(name) ?? new Map();
|
|
const newSet = new Map();
|
|
issues.set(name, newSet);
|
|
const relevantIssues = new Set();
|
|
for (const issue of result.issues){
|
|
// TODO better formatting
|
|
if (issue.severity !== "error" && issue.severity !== "fatal") continue;
|
|
const key = issueKey(issue);
|
|
const formatted = formatIssue(issue);
|
|
if (!oldSet.has(key) && !newSet.has(key)) {
|
|
console.error(` ⚠ ${displayName} ${key} ${formatted}\n\n`);
|
|
}
|
|
newSet.set(key, issue);
|
|
relevantIssues.add(formatted);
|
|
}
|
|
for (const issue of oldSet.keys()){
|
|
if (!newSet.has(issue)) {
|
|
console.error(`✅ ${displayName} fixed ${issue}`);
|
|
}
|
|
}
|
|
if (relevantIssues.size && throwIssue) {
|
|
throw new ModuleBuildError([
|
|
...relevantIssues
|
|
].join("\n\n"));
|
|
}
|
|
}
|
|
const serverPathState = new Map();
|
|
async function processResult(id, result) {
|
|
// Figure out if the server files have changed
|
|
let hasChange = false;
|
|
for (const { path: p, contentHash } of result.serverPaths){
|
|
// We ignore source maps
|
|
if (p.endsWith(".map")) continue;
|
|
let key = `${id}:${p}`;
|
|
const previousHash = serverPathState.get(key);
|
|
if (previousHash !== contentHash) {
|
|
hasChange = true;
|
|
serverPathState.set(key, contentHash);
|
|
}
|
|
}
|
|
if (!hasChange) {
|
|
return result;
|
|
}
|
|
const hasAppPaths = result.serverPaths.some(({ path: p })=>p.startsWith("server/app"));
|
|
if (hasAppPaths) {
|
|
(0, _nextjsrequirecachehotreloader.deleteAppClientCache)();
|
|
}
|
|
const serverPaths = result.serverPaths.map(({ path: p })=>_path.default.join(distDir, p));
|
|
for (const file of serverPaths){
|
|
(0, _renderserver.clearModuleContext)(file);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(file);
|
|
}
|
|
return result;
|
|
}
|
|
let hmrHash = 0;
|
|
const sendHmrDebounce = (0, _utils2.debounce)(()=>{
|
|
const errors = new Map();
|
|
for (const [, issueMap] of issues){
|
|
for (const [key, issue] of issueMap){
|
|
if (errors.has(key)) continue;
|
|
const message = formatIssue(issue);
|
|
errors.set(key, {
|
|
message,
|
|
details: issue.detail
|
|
});
|
|
}
|
|
}
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.SYNC,
|
|
hash: String(++hmrHash),
|
|
errors: [
|
|
...errors.values()
|
|
],
|
|
warnings: [],
|
|
versionInfo: {
|
|
installed: "0.0.0",
|
|
staleness: "unknown"
|
|
}
|
|
});
|
|
hmrBuilding = false;
|
|
if (errors.size === 0) {
|
|
for (const payload of hmrPayloads.values()){
|
|
hotReloader.send(payload);
|
|
}
|
|
hmrPayloads.clear();
|
|
if (turbopackUpdates.length > 0) {
|
|
hotReloader.send({
|
|
type: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE,
|
|
data: turbopackUpdates
|
|
});
|
|
turbopackUpdates.length = 0;
|
|
}
|
|
}
|
|
}, 2);
|
|
function sendHmr(key, id, payload) {
|
|
// We've detected a change in some part of the graph. If nothing has
|
|
// been inserted into building yet, then this is the first change
|
|
// emitted, but their may be many more coming.
|
|
if (!hmrBuilding) {
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.BUILDING
|
|
});
|
|
hmrBuilding = true;
|
|
}
|
|
hmrPayloads.set(`${key}:${id}`, payload);
|
|
sendHmrDebounce();
|
|
}
|
|
function sendTurbopackMessage(payload) {
|
|
// We've detected a change in some part of the graph. If nothing has
|
|
// been inserted into building yet, then this is the first change
|
|
// emitted, but their may be many more coming.
|
|
if (!hmrBuilding) {
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.BUILDING
|
|
});
|
|
hmrBuilding = true;
|
|
}
|
|
turbopackUpdates.push(payload);
|
|
sendHmrDebounce();
|
|
}
|
|
async function loadPartialManifest(name, pageName, type = "pages") {
|
|
const manifestPath = _path.default.posix.join(distDir, `server`, type === "app-route" ? "app" : type, type === "middleware" ? "" : pageName === "/" ? "index" : pageName === "/index" || pageName.startsWith("/index/") ? `/index${pageName}` : pageName, type === "app" ? "page" : type === "app-route" ? "route" : "", name);
|
|
return JSON.parse(await (0, _promises.readFile)(_path.default.posix.join(manifestPath), "utf-8"));
|
|
}
|
|
const buildManifests = new Map();
|
|
const appBuildManifests = new Map();
|
|
const pagesManifests = new Map();
|
|
const appPathsManifests = new Map();
|
|
const middlewareManifests = new Map();
|
|
const actionManifests = new Map();
|
|
const clientToHmrSubscription = new Map();
|
|
const clients = new Set();
|
|
async function loadMiddlewareManifest(pageName, type) {
|
|
middlewareManifests.set(pageName, await loadPartialManifest(_constants.MIDDLEWARE_MANIFEST, pageName, type));
|
|
}
|
|
async function loadBuildManifest(pageName, type = "pages") {
|
|
buildManifests.set(pageName, await loadPartialManifest(_constants.BUILD_MANIFEST, pageName, type));
|
|
}
|
|
async function loadAppBuildManifest(pageName) {
|
|
appBuildManifests.set(pageName, await loadPartialManifest(_constants.APP_BUILD_MANIFEST, pageName, "app"));
|
|
}
|
|
async function loadPagesManifest(pageName) {
|
|
pagesManifests.set(pageName, await loadPartialManifest(_constants.PAGES_MANIFEST, pageName));
|
|
}
|
|
async function loadAppPathManifest(pageName, type = "app") {
|
|
appPathsManifests.set(pageName, await loadPartialManifest(_constants.APP_PATHS_MANIFEST, pageName, type));
|
|
}
|
|
async function loadActionManifest(pageName) {
|
|
actionManifests.set(pageName, await loadPartialManifest(`${_constants.SERVER_REFERENCE_MANIFEST}.json`, pageName, "app"));
|
|
}
|
|
const buildingReported = new Set();
|
|
async function changeSubscription(page, endpoint, makePayload) {
|
|
if (!endpoint || changeSubscriptions.has(page)) return;
|
|
const changedPromise = endpoint.changed();
|
|
changeSubscriptions.set(page, changedPromise);
|
|
const changed = await changedPromise;
|
|
for await (const change of changed){
|
|
_store.store.setState({
|
|
loading: true,
|
|
trigger: page
|
|
}, true);
|
|
processIssues(page, page, change);
|
|
const payload = await makePayload(page, change);
|
|
if (payload) sendHmr("endpoint-change", page, payload);
|
|
}
|
|
}
|
|
async function clearChangeSubscription(page) {
|
|
const subscription = await changeSubscriptions.get(page);
|
|
if (subscription) {
|
|
subscription.return == null ? void 0 : subscription.return.call(subscription);
|
|
changeSubscriptions.delete(page);
|
|
}
|
|
issues.delete(page);
|
|
}
|
|
function mergeBuildManifests(manifests) {
|
|
const manifest = {
|
|
pages: {
|
|
"/_app": []
|
|
},
|
|
// Something in next.js depends on these to exist even for app dir rendering
|
|
devFiles: [],
|
|
ampDevFiles: [],
|
|
polyfillFiles: [],
|
|
lowPriorityFiles: [
|
|
"static/development/_ssgManifest.js",
|
|
"static/development/_buildManifest.js"
|
|
],
|
|
rootMainFiles: [],
|
|
ampFirstPages: []
|
|
};
|
|
for (const m of manifests){
|
|
Object.assign(manifest.pages, m.pages);
|
|
if (m.rootMainFiles.length) manifest.rootMainFiles = m.rootMainFiles;
|
|
}
|
|
return manifest;
|
|
}
|
|
function mergeAppBuildManifests(manifests) {
|
|
const manifest = {
|
|
pages: {}
|
|
};
|
|
for (const m of manifests){
|
|
Object.assign(manifest.pages, m.pages);
|
|
}
|
|
return manifest;
|
|
}
|
|
function mergePagesManifests(manifests) {
|
|
const manifest = {};
|
|
for (const m of manifests){
|
|
Object.assign(manifest, m);
|
|
}
|
|
return manifest;
|
|
}
|
|
function mergeMiddlewareManifests(manifests) {
|
|
const manifest = {
|
|
version: 2,
|
|
middleware: {},
|
|
sortedMiddleware: [],
|
|
functions: {}
|
|
};
|
|
for (const m of manifests){
|
|
Object.assign(manifest.functions, m.functions);
|
|
Object.assign(manifest.middleware, m.middleware);
|
|
}
|
|
for (const fun of Object.values(manifest.functions).concat(Object.values(manifest.middleware))){
|
|
for (const matcher of fun.matchers){
|
|
if (!matcher.regexp) {
|
|
matcher.regexp = (0, _pathtoregexp.pathToRegexp)(matcher.originalSource, [], {
|
|
delimiter: "/",
|
|
sensitive: false,
|
|
strict: true
|
|
}).source.replaceAll("\\/", "/");
|
|
}
|
|
}
|
|
}
|
|
manifest.sortedMiddleware = Object.keys(manifest.middleware);
|
|
return manifest;
|
|
}
|
|
function mergeActionManifests(manifests) {
|
|
const manifest = {
|
|
node: {},
|
|
edge: {}
|
|
};
|
|
function mergeActionIds(actionEntries, other) {
|
|
for(const key in other){
|
|
const action = actionEntries[key] ??= {
|
|
workers: {},
|
|
layer: {}
|
|
};
|
|
Object.assign(action.workers, other[key].workers);
|
|
Object.assign(action.layer, other[key].layer);
|
|
}
|
|
}
|
|
for (const m of manifests){
|
|
mergeActionIds(manifest.node, m.node);
|
|
mergeActionIds(manifest.edge, m.edge);
|
|
}
|
|
return manifest;
|
|
}
|
|
async function writeFileAtomic(filePath, content) {
|
|
const tempPath = filePath + ".tmp." + Math.random().toString(36).slice(2);
|
|
try {
|
|
await (0, _promises.writeFile)(tempPath, content, "utf-8");
|
|
await (0, _promises.rename)(tempPath, filePath);
|
|
} catch (e) {
|
|
try {
|
|
await (0, _promises.unlink)(tempPath);
|
|
} catch {
|
|
// ignore
|
|
}
|
|
throw e;
|
|
}
|
|
}
|
|
async function writeBuildManifest(rewrites) {
|
|
const buildManifest = mergeBuildManifests(buildManifests.values());
|
|
const buildManifestPath = _path.default.join(distDir, _constants.BUILD_MANIFEST);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(buildManifestPath);
|
|
await writeFileAtomic(buildManifestPath, JSON.stringify(buildManifest, null, 2));
|
|
const content = {
|
|
__rewrites: rewrites ? (0, _buildmanifestplugin.normalizeRewritesForBuildManifest)(rewrites) : {
|
|
afterFiles: [],
|
|
beforeFiles: [],
|
|
fallback: []
|
|
},
|
|
...Object.fromEntries([
|
|
...curEntries.keys()
|
|
].map((pathname)=>[
|
|
pathname,
|
|
`static/chunks/pages${pathname === "/" ? "/index" : pathname}.js`
|
|
])),
|
|
sortedPages: [
|
|
...curEntries.keys()
|
|
]
|
|
};
|
|
const buildManifestJs = `self.__BUILD_MANIFEST = ${JSON.stringify(content)};self.__BUILD_MANIFEST_CB && self.__BUILD_MANIFEST_CB()`;
|
|
await writeFileAtomic(_path.default.join(distDir, "static", "development", "_buildManifest.js"), buildManifestJs);
|
|
await writeFileAtomic(_path.default.join(distDir, "static", "development", "_ssgManifest.js"), _buildmanifestplugin.srcEmptySsgManifest);
|
|
}
|
|
async function writeFallbackBuildManifest() {
|
|
const fallbackBuildManifest = mergeBuildManifests([
|
|
buildManifests.get("_app"),
|
|
buildManifests.get("_error")
|
|
].filter(Boolean));
|
|
const fallbackBuildManifestPath = _path.default.join(distDir, `fallback-${_constants.BUILD_MANIFEST}`);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(fallbackBuildManifestPath);
|
|
await writeFileAtomic(fallbackBuildManifestPath, JSON.stringify(fallbackBuildManifest, null, 2));
|
|
}
|
|
async function writeAppBuildManifest() {
|
|
const appBuildManifest = mergeAppBuildManifests(appBuildManifests.values());
|
|
const appBuildManifestPath = _path.default.join(distDir, _constants.APP_BUILD_MANIFEST);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(appBuildManifestPath);
|
|
await writeFileAtomic(appBuildManifestPath, JSON.stringify(appBuildManifest, null, 2));
|
|
}
|
|
async function writePagesManifest() {
|
|
const pagesManifest = mergePagesManifests(pagesManifests.values());
|
|
const pagesManifestPath = _path.default.join(distDir, "server", _constants.PAGES_MANIFEST);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(pagesManifestPath);
|
|
await writeFileAtomic(pagesManifestPath, JSON.stringify(pagesManifest, null, 2));
|
|
}
|
|
async function writeAppPathsManifest() {
|
|
const appPathsManifest = mergePagesManifests(appPathsManifests.values());
|
|
const appPathsManifestPath = _path.default.join(distDir, "server", _constants.APP_PATHS_MANIFEST);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(appPathsManifestPath);
|
|
await writeFileAtomic(appPathsManifestPath, JSON.stringify(appPathsManifest, null, 2));
|
|
}
|
|
async function writeMiddlewareManifest() {
|
|
const middlewareManifest = mergeMiddlewareManifests(middlewareManifests.values());
|
|
const middlewareManifestPath = _path.default.join(distDir, "server/middleware-manifest.json");
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(middlewareManifestPath);
|
|
await writeFileAtomic(middlewareManifestPath, JSON.stringify(middlewareManifest, null, 2));
|
|
}
|
|
async function writeActionManifest() {
|
|
const actionManifest = mergeActionManifests(actionManifests.values());
|
|
const actionManifestJsonPath = _path.default.join(distDir, "server", `${_constants.SERVER_REFERENCE_MANIFEST}.json`);
|
|
const actionManifestJsPath = _path.default.join(distDir, "server", `${_constants.SERVER_REFERENCE_MANIFEST}.js`);
|
|
const json = JSON.stringify(actionManifest, null, 2);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(actionManifestJsonPath);
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(actionManifestJsPath);
|
|
await (0, _promises.writeFile)(actionManifestJsonPath, json, "utf-8");
|
|
await (0, _promises.writeFile)(actionManifestJsPath, `self.__RSC_SERVER_MANIFEST=${JSON.stringify(json)}`, "utf-8");
|
|
}
|
|
async function writeFontManifest() {
|
|
// TODO: turbopack should write the correct
|
|
// version of this
|
|
const fontManifestPath = _path.default.join(distDir, "server", _constants.NEXT_FONT_MANIFEST + ".json");
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(fontManifestPath);
|
|
await writeFileAtomic(fontManifestPath, JSON.stringify({
|
|
pages: {},
|
|
app: {},
|
|
appUsingSizeAdjust: false,
|
|
pagesUsingSizeAdjust: false
|
|
}, null, 2));
|
|
}
|
|
async function writeOtherManifests() {
|
|
const loadableManifestPath = _path.default.join(distDir, "react-loadable-manifest.json");
|
|
(0, _nextjsrequirecachehotreloader.deleteCache)(loadableManifestPath);
|
|
await writeFileAtomic(loadableManifestPath, JSON.stringify({}, null, 2));
|
|
}
|
|
async function subscribeToHmrEvents(id, client) {
|
|
let mapping = clientToHmrSubscription.get(client);
|
|
if (mapping === undefined) {
|
|
mapping = new Map();
|
|
clientToHmrSubscription.set(client, mapping);
|
|
}
|
|
if (mapping.has(id)) return;
|
|
const subscription = project.hmrEvents(id);
|
|
mapping.set(id, subscription);
|
|
// The subscription will always emit once, which is the initial
|
|
// computation. This is not a change, so swallow it.
|
|
try {
|
|
await subscription.next();
|
|
for await (const data of subscription){
|
|
processIssues("hmr", id, data);
|
|
sendTurbopackMessage(data);
|
|
}
|
|
} catch (e) {
|
|
// The client might be using an HMR session from a previous server, tell them
|
|
// to fully reload the page to resolve the issue. We can't use
|
|
// `hotReloader.send` since that would force very connected client to
|
|
// reload, only this client is out of date.
|
|
const reloadAction = {
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.RELOAD_PAGE
|
|
};
|
|
client.send(JSON.stringify(reloadAction));
|
|
client.close();
|
|
return;
|
|
}
|
|
}
|
|
function unsubscribeToHmrEvents(id, client) {
|
|
const mapping = clientToHmrSubscription.get(client);
|
|
const subscription = mapping == null ? void 0 : mapping.get(id);
|
|
subscription == null ? void 0 : subscription.return();
|
|
}
|
|
try {
|
|
async function handleEntries() {
|
|
for await (const entrypoints of iter){
|
|
if (!currentEntriesHandlingResolve) {
|
|
currentEntriesHandling = new Promise(// eslint-disable-next-line no-loop-func
|
|
(resolve)=>currentEntriesHandlingResolve = resolve);
|
|
}
|
|
globalEntries.app = entrypoints.pagesAppEndpoint;
|
|
globalEntries.document = entrypoints.pagesDocumentEndpoint;
|
|
globalEntries.error = entrypoints.pagesErrorEndpoint;
|
|
curEntries.clear();
|
|
for (const [pathname, route] of entrypoints.routes){
|
|
switch(route.type){
|
|
case "page":
|
|
case "page-api":
|
|
case "app-page":
|
|
case "app-route":
|
|
{
|
|
curEntries.set(pathname, route);
|
|
break;
|
|
}
|
|
default:
|
|
_log.info(`skipping ${pathname} (${route.type})`);
|
|
break;
|
|
}
|
|
}
|
|
for (const [pathname, subscriptionPromise] of changeSubscriptions){
|
|
if (pathname === "") {
|
|
continue;
|
|
}
|
|
if (!curEntries.has(pathname)) {
|
|
const subscription = await subscriptionPromise;
|
|
subscription.return == null ? void 0 : subscription.return.call(subscription);
|
|
changeSubscriptions.delete(pathname);
|
|
}
|
|
}
|
|
const { middleware } = entrypoints;
|
|
// We check for explicit true/false, since it's initialized to
|
|
// undefined during the first loop (middlewareChanges event is
|
|
// unnecessary during the first serve)
|
|
if (prevMiddleware === true && !middleware) {
|
|
// Went from middleware to no middleware
|
|
await clearChangeSubscription("middleware");
|
|
sendHmr("entrypoint-change", "middleware", {
|
|
event: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.MIDDLEWARE_CHANGES
|
|
});
|
|
} else if (prevMiddleware === false && middleware) {
|
|
// Went from no middleware to middleware
|
|
sendHmr("endpoint-change", "middleware", {
|
|
event: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.MIDDLEWARE_CHANGES
|
|
});
|
|
}
|
|
if (middleware) {
|
|
const processMiddleware = async ()=>{
|
|
var _middlewareManifests_get;
|
|
const writtenEndpoint = await processResult("middleware", await middleware.endpoint.writeToDisk());
|
|
processIssues("middleware", "middleware", writtenEndpoint);
|
|
await loadMiddlewareManifest("middleware", "middleware");
|
|
serverFields.actualMiddlewareFile = "middleware";
|
|
serverFields.middleware = {
|
|
match: null,
|
|
page: "/",
|
|
matchers: (_middlewareManifests_get = middlewareManifests.get("middleware")) == null ? void 0 : _middlewareManifests_get.middleware["/"].matchers
|
|
};
|
|
};
|
|
await processMiddleware();
|
|
changeSubscription("middleware", middleware.endpoint, async ()=>{
|
|
await processMiddleware();
|
|
await propagateServerField("actualMiddlewareFile", serverFields.actualMiddlewareFile);
|
|
await propagateServerField("middleware", serverFields.middleware);
|
|
await writeMiddlewareManifest();
|
|
console.log("middleware changes");
|
|
return {
|
|
event: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.MIDDLEWARE_CHANGES
|
|
};
|
|
});
|
|
prevMiddleware = true;
|
|
} else {
|
|
middlewareManifests.delete("middleware");
|
|
serverFields.actualMiddlewareFile = undefined;
|
|
serverFields.middleware = undefined;
|
|
prevMiddleware = false;
|
|
}
|
|
await propagateServerField("actualMiddlewareFile", serverFields.actualMiddlewareFile);
|
|
await propagateServerField("middleware", serverFields.middleware);
|
|
currentEntriesHandlingResolve();
|
|
currentEntriesHandlingResolve = undefined;
|
|
}
|
|
}
|
|
handleEntries().catch((err)=>{
|
|
console.error(err);
|
|
process.exit(1);
|
|
});
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
// Write empty manifests
|
|
await (0, _promises.mkdir)(_path.default.join(distDir, "server"), {
|
|
recursive: true
|
|
});
|
|
await (0, _promises.mkdir)(_path.default.join(distDir, "static/development"), {
|
|
recursive: true
|
|
});
|
|
await (0, _promises.writeFile)(_path.default.join(distDir, "package.json"), JSON.stringify({
|
|
type: "commonjs"
|
|
}, null, 2));
|
|
await currentEntriesHandling;
|
|
await writeBuildManifest(opts.fsChecker.rewrites);
|
|
await writeAppBuildManifest();
|
|
await writeFallbackBuildManifest();
|
|
await writePagesManifest();
|
|
await writeAppPathsManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeActionManifest();
|
|
await writeOtherManifests();
|
|
await writeFontManifest();
|
|
const turbopackHotReloader = {
|
|
turbopackProject: project,
|
|
activeWebpackConfigs: undefined,
|
|
serverStats: null,
|
|
edgeServerStats: null,
|
|
async run (req, _res, _parsedUrl) {
|
|
var _req_url;
|
|
// intercept page chunks request and ensure them with turbopack
|
|
if ((_req_url = req.url) == null ? void 0 : _req_url.startsWith("/_next/static/chunks/pages/")) {
|
|
const params = (0, _hotreloaderwebpack.matchNextPageBundleRequest)(req.url);
|
|
if (params) {
|
|
const decodedPagePath = `/${params.path.map((param)=>decodeURIComponent(param)).join("/")}`;
|
|
const denormalizedPagePath = (0, _denormalizepagepath.denormalizePagePath)(decodedPagePath);
|
|
await hotReloader.ensurePage({
|
|
page: denormalizedPagePath,
|
|
clientOnly: false,
|
|
definition: undefined
|
|
}).catch(console.error);
|
|
}
|
|
}
|
|
// Request was not finished.
|
|
return {
|
|
finished: undefined
|
|
};
|
|
},
|
|
// TODO: Figure out if socket type can match the NextJsHotReloaderInterface
|
|
onHMR (req, socket, head) {
|
|
wsServer.handleUpgrade(req, socket, head, (client)=>{
|
|
clients.add(client);
|
|
client.on("close", ()=>clients.delete(client));
|
|
client.addEventListener("message", ({ data })=>{
|
|
const parsedData = JSON.parse(typeof data !== "string" ? data.toString() : data);
|
|
// Next.js messages
|
|
switch(parsedData.event){
|
|
case "ping":
|
|
break;
|
|
case "span-end":
|
|
case "client-error":
|
|
case "client-warning":
|
|
case "client-success":
|
|
case "server-component-reload-page":
|
|
case "client-reload-page":
|
|
case "client-removed-page":
|
|
case "client-full-reload":
|
|
break;
|
|
default:
|
|
// Might be a Turbopack message...
|
|
if (!parsedData.type) {
|
|
throw new Error(`unrecognized HMR message "${data}"`);
|
|
}
|
|
}
|
|
// Turbopack messages
|
|
switch(parsedData.type){
|
|
case "turbopack-subscribe":
|
|
subscribeToHmrEvents(parsedData.path, client);
|
|
break;
|
|
case "turbopack-unsubscribe":
|
|
unsubscribeToHmrEvents(parsedData.path, client);
|
|
break;
|
|
default:
|
|
if (!parsedData.event) {
|
|
throw new Error(`unrecognized Turbopack HMR message "${data}"`);
|
|
}
|
|
}
|
|
});
|
|
const turbopackConnected = {
|
|
type: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED
|
|
};
|
|
client.send(JSON.stringify(turbopackConnected));
|
|
});
|
|
},
|
|
send (action) {
|
|
const payload = JSON.stringify(action);
|
|
for (const client of clients){
|
|
client.send(payload);
|
|
}
|
|
},
|
|
setHmrServerError (_error) {
|
|
// Not implemented yet.
|
|
},
|
|
clearHmrServerError () {
|
|
// Not implemented yet.
|
|
},
|
|
async start () {
|
|
// Not implemented yet.
|
|
},
|
|
async stop () {
|
|
// Not implemented yet.
|
|
},
|
|
async getCompilationErrors (_page) {
|
|
return [];
|
|
},
|
|
invalidate () {
|
|
// Not implemented yet.
|
|
},
|
|
async buildFallbackError () {
|
|
// Not implemented yet.
|
|
},
|
|
async ensurePage ({ page: inputPage, // Unused parameters
|
|
// clientOnly,
|
|
// appPaths,
|
|
definition, isApp }) {
|
|
let page = (definition == null ? void 0 : definition.pathname) ?? inputPage;
|
|
if (page === "/_error") {
|
|
if (globalEntries.app) {
|
|
const writtenEndpoint = await processResult("_app", await globalEntries.app.writeToDisk());
|
|
processIssues("_app", "_app", writtenEndpoint);
|
|
}
|
|
await loadBuildManifest("_app");
|
|
await loadPagesManifest("_app");
|
|
if (globalEntries.document) {
|
|
const writtenEndpoint = await processResult("_document", await globalEntries.document.writeToDisk());
|
|
changeSubscription("_document", globalEntries.document, ()=>{
|
|
return {
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.RELOAD_PAGE
|
|
};
|
|
});
|
|
processIssues("_document", "_document", writtenEndpoint);
|
|
}
|
|
await loadPagesManifest("_document");
|
|
if (globalEntries.error) {
|
|
const writtenEndpoint = await processResult("_error", await globalEntries.error.writeToDisk());
|
|
processIssues(page, page, writtenEndpoint);
|
|
}
|
|
await loadBuildManifest("_error");
|
|
await loadPagesManifest("_error");
|
|
await writeBuildManifest(opts.fsChecker.rewrites);
|
|
await writeFallbackBuildManifest();
|
|
await writePagesManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeOtherManifests();
|
|
return;
|
|
}
|
|
await currentEntriesHandling;
|
|
const route = curEntries.get(page) ?? curEntries.get((0, _apppaths.normalizeAppPath)((0, _getmetadataroute.normalizeMetadataRoute)((definition == null ? void 0 : definition.page) ?? inputPage)));
|
|
if (!route) {
|
|
// TODO: why is this entry missing in turbopack?
|
|
if (page === "/_app") return;
|
|
if (page === "/_document") return;
|
|
if (page === "/middleware") return;
|
|
throw new _utils1.PageNotFoundError(`route not found ${page}`);
|
|
}
|
|
if (!buildingReported.has(page)) {
|
|
buildingReported.add(page);
|
|
let suffix;
|
|
switch(route.type){
|
|
case "app-page":
|
|
suffix = "page";
|
|
break;
|
|
case "app-route":
|
|
suffix = "route";
|
|
break;
|
|
case "page":
|
|
case "page-api":
|
|
suffix = "";
|
|
break;
|
|
default:
|
|
throw new Error("Unexpected route type " + route.type);
|
|
}
|
|
_store.store.setState({
|
|
loading: true,
|
|
trigger: `${page}${!page.endsWith("/") && suffix.length > 0 ? "/" : ""}${suffix}`
|
|
}, true);
|
|
}
|
|
switch(route.type){
|
|
case "page":
|
|
{
|
|
if (isApp) {
|
|
throw new Error(`mis-matched route type: isApp && page for ${page}`);
|
|
}
|
|
if (globalEntries.app) {
|
|
const writtenEndpoint = await processResult("_app", await globalEntries.app.writeToDisk());
|
|
processIssues("_app", "_app", writtenEndpoint);
|
|
}
|
|
await loadBuildManifest("_app");
|
|
await loadPagesManifest("_app");
|
|
if (globalEntries.document) {
|
|
const writtenEndpoint = await processResult("_document", await globalEntries.document.writeToDisk());
|
|
changeSubscription("_document", globalEntries.document, ()=>{
|
|
return {
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.RELOAD_PAGE
|
|
};
|
|
});
|
|
processIssues("_document", "_document", writtenEndpoint);
|
|
}
|
|
await loadPagesManifest("_document");
|
|
const writtenEndpoint = await processResult(page, await route.htmlEndpoint.writeToDisk());
|
|
changeSubscription(page, route.dataEndpoint, (pageName, change)=>{
|
|
switch(change.type){
|
|
case _swc.ServerClientChangeType.Server:
|
|
case _swc.ServerClientChangeType.Both:
|
|
return {
|
|
event: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.SERVER_ONLY_CHANGES,
|
|
pages: [
|
|
pageName
|
|
]
|
|
};
|
|
default:
|
|
}
|
|
});
|
|
const type = writtenEndpoint == null ? void 0 : writtenEndpoint.type;
|
|
await loadBuildManifest(page);
|
|
await loadPagesManifest(page);
|
|
if (type === "edge") {
|
|
await loadMiddlewareManifest(page, "pages");
|
|
} else {
|
|
middlewareManifests.delete(page);
|
|
}
|
|
await writeBuildManifest(opts.fsChecker.rewrites);
|
|
await writeFallbackBuildManifest();
|
|
await writePagesManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeOtherManifests();
|
|
processIssues(page, page, writtenEndpoint);
|
|
break;
|
|
}
|
|
case "page-api":
|
|
{
|
|
// We don't throw on ensureOpts.isApp === true here
|
|
// since this can happen when app pages make
|
|
// api requests to page API routes.
|
|
const writtenEndpoint = await processResult(page, await route.endpoint.writeToDisk());
|
|
const type = writtenEndpoint == null ? void 0 : writtenEndpoint.type;
|
|
await loadPagesManifest(page);
|
|
if (type === "edge") {
|
|
await loadMiddlewareManifest(page, "pages");
|
|
} else {
|
|
middlewareManifests.delete(page);
|
|
}
|
|
await writePagesManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeOtherManifests();
|
|
processIssues(page, page, writtenEndpoint);
|
|
break;
|
|
}
|
|
case "app-page":
|
|
{
|
|
const writtenEndpoint = await processResult(page, await route.htmlEndpoint.writeToDisk());
|
|
changeSubscription(page, route.rscEndpoint, (_page, change)=>{
|
|
switch(change.type){
|
|
case _swc.ServerClientChangeType.Server:
|
|
case _swc.ServerClientChangeType.Both:
|
|
return {
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.SERVER_COMPONENT_CHANGES
|
|
};
|
|
default:
|
|
}
|
|
});
|
|
await loadAppBuildManifest(page);
|
|
await loadBuildManifest(page, "app");
|
|
await loadAppPathManifest(page, "app");
|
|
await loadActionManifest(page);
|
|
await writeAppBuildManifest();
|
|
await writeBuildManifest(opts.fsChecker.rewrites);
|
|
await writeAppPathsManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeActionManifest();
|
|
await writeOtherManifests();
|
|
processIssues(page, page, writtenEndpoint, true);
|
|
break;
|
|
}
|
|
case "app-route":
|
|
{
|
|
const writtenEndpoint = await processResult(page, await route.endpoint.writeToDisk());
|
|
const type = writtenEndpoint == null ? void 0 : writtenEndpoint.type;
|
|
await loadAppPathManifest(page, "app-route");
|
|
if (type === "edge") {
|
|
await loadMiddlewareManifest(page, "app-route");
|
|
} else {
|
|
middlewareManifests.delete(page);
|
|
}
|
|
await writeAppBuildManifest();
|
|
await writeAppPathsManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeMiddlewareManifest();
|
|
await writeOtherManifests();
|
|
processIssues(page, page, writtenEndpoint, true);
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
throw new Error(`unknown route type ${route.type} for ${page}`);
|
|
}
|
|
}
|
|
_store.store.setState({
|
|
loading: false
|
|
}, true);
|
|
}
|
|
};
|
|
hotReloader = turbopackHotReloader;
|
|
} else {
|
|
hotReloader = new _hotreloaderwebpack.default(opts.dir, {
|
|
appDir,
|
|
pagesDir,
|
|
distDir: distDir,
|
|
config: opts.nextConfig,
|
|
buildId: "development",
|
|
telemetry: opts.telemetry,
|
|
rewrites: opts.fsChecker.rewrites,
|
|
previewProps: opts.fsChecker.prerenderManifest.preview
|
|
});
|
|
}
|
|
await hotReloader.start();
|
|
if (opts.nextConfig.experimental.nextScriptWorkers) {
|
|
await (0, _verifypartytownsetup.verifyPartytownSetup)(opts.dir, _path.default.join(distDir, _constants.CLIENT_STATIC_FILES_PATH));
|
|
}
|
|
opts.fsChecker.ensureCallback(async function ensure(item) {
|
|
if (item.type === "appFile" || item.type === "pageFile") {
|
|
await hotReloader.ensurePage({
|
|
clientOnly: false,
|
|
page: item.itemPath,
|
|
isApp: item.type === "appFile",
|
|
definition: undefined
|
|
});
|
|
}
|
|
});
|
|
let resolved = false;
|
|
let prevSortedRoutes = [];
|
|
await new Promise(async (resolve, reject)=>{
|
|
if (pagesDir) {
|
|
// Watchpack doesn't emit an event for an empty directory
|
|
_fs.default.readdir(pagesDir, (_, files)=>{
|
|
if (files == null ? void 0 : files.length) {
|
|
return;
|
|
}
|
|
if (!resolved) {
|
|
resolve();
|
|
resolved = true;
|
|
}
|
|
});
|
|
}
|
|
const pages = pagesDir ? [
|
|
pagesDir
|
|
] : [];
|
|
const app = appDir ? [
|
|
appDir
|
|
] : [];
|
|
const directories = [
|
|
...pages,
|
|
...app
|
|
];
|
|
const rootDir = pagesDir || appDir;
|
|
const files = [
|
|
...(0, _worker.getPossibleMiddlewareFilenames)(_path.default.join(rootDir, ".."), nextConfig.pageExtensions),
|
|
...(0, _worker.getPossibleInstrumentationHookFilenames)(_path.default.join(rootDir, ".."), nextConfig.pageExtensions)
|
|
];
|
|
let nestedMiddleware = [];
|
|
const envFiles = [
|
|
".env.development.local",
|
|
".env.local",
|
|
".env.development",
|
|
".env"
|
|
].map((file)=>_path.default.join(dir, file));
|
|
files.push(...envFiles);
|
|
// tsconfig/jsconfig paths hot-reloading
|
|
const tsconfigPaths = [
|
|
_path.default.join(dir, "tsconfig.json"),
|
|
_path.default.join(dir, "jsconfig.json")
|
|
];
|
|
files.push(...tsconfigPaths);
|
|
const wp = new _watchpack.default({
|
|
ignored: (pathname)=>{
|
|
return !files.some((file)=>file.startsWith(pathname)) && !directories.some((d)=>pathname.startsWith(d) || d.startsWith(pathname));
|
|
}
|
|
});
|
|
const fileWatchTimes = new Map();
|
|
let enabledTypeScript = usingTypeScript;
|
|
let previousClientRouterFilters;
|
|
let previousConflictingPagePaths = new Set();
|
|
wp.on("aggregated", async ()=>{
|
|
var _serverFields_middleware, _serverFields_middleware1, _generateInterceptionRoutesRewrites;
|
|
let middlewareMatchers;
|
|
const routedPages = [];
|
|
const knownFiles = wp.getTimeInfoEntries();
|
|
const appPaths = {};
|
|
const pageNameSet = new Set();
|
|
const conflictingAppPagePaths = new Set();
|
|
const appPageFilePaths = new Map();
|
|
const pagesPageFilePaths = new Map();
|
|
let envChange = false;
|
|
let tsconfigChange = false;
|
|
let conflictingPageChange = 0;
|
|
let hasRootAppNotFound = false;
|
|
const { appFiles, pageFiles } = opts.fsChecker;
|
|
appFiles.clear();
|
|
pageFiles.clear();
|
|
_shared1.devPageFiles.clear();
|
|
const sortedKnownFiles = [
|
|
...knownFiles.keys()
|
|
].sort((0, _entries.sortByPageExts)(nextConfig.pageExtensions));
|
|
for (const fileName of sortedKnownFiles){
|
|
if (!files.includes(fileName) && !directories.some((d)=>fileName.startsWith(d))) {
|
|
continue;
|
|
}
|
|
const meta = knownFiles.get(fileName);
|
|
const watchTime = fileWatchTimes.get(fileName);
|
|
// If the file is showing up for the first time or the meta.timestamp is changed since last time
|
|
const watchTimeChange = watchTime === undefined || watchTime && watchTime !== (meta == null ? void 0 : meta.timestamp);
|
|
fileWatchTimes.set(fileName, meta.timestamp);
|
|
if (envFiles.includes(fileName)) {
|
|
if (watchTimeChange) {
|
|
envChange = true;
|
|
}
|
|
continue;
|
|
}
|
|
if (tsconfigPaths.includes(fileName)) {
|
|
if (fileName.endsWith("tsconfig.json")) {
|
|
enabledTypeScript = true;
|
|
}
|
|
if (watchTimeChange) {
|
|
tsconfigChange = true;
|
|
}
|
|
continue;
|
|
}
|
|
if ((meta == null ? void 0 : meta.accuracy) === undefined || !validFileMatcher.isPageFile(fileName)) {
|
|
continue;
|
|
}
|
|
const isAppPath = Boolean(appDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(appDir) + "/"));
|
|
const isPagePath = Boolean(pagesDir && (0, _normalizepathsep.normalizePathSep)(fileName).startsWith((0, _normalizepathsep.normalizePathSep)(pagesDir) + "/"));
|
|
const rootFile = (0, _absolutepathtopage.absolutePathToPage)(fileName, {
|
|
dir: dir,
|
|
extensions: nextConfig.pageExtensions,
|
|
keepIndex: false,
|
|
pagesType: "root"
|
|
});
|
|
if ((0, _worker.isMiddlewareFile)(rootFile)) {
|
|
var _staticInfo_middleware;
|
|
const staticInfo = await (0, _entries.getStaticInfoIncludingLayouts)({
|
|
pageFilePath: fileName,
|
|
config: nextConfig,
|
|
appDir: appDir,
|
|
page: rootFile,
|
|
isDev: true,
|
|
isInsideAppDir: isAppPath,
|
|
pageExtensions: nextConfig.pageExtensions
|
|
});
|
|
if (nextConfig.output === "export") {
|
|
_log.error('Middleware cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export');
|
|
continue;
|
|
}
|
|
serverFields.actualMiddlewareFile = rootFile;
|
|
await propagateServerField("actualMiddlewareFile", serverFields.actualMiddlewareFile);
|
|
middlewareMatchers = ((_staticInfo_middleware = staticInfo.middleware) == null ? void 0 : _staticInfo_middleware.matchers) || [
|
|
{
|
|
regexp: ".*",
|
|
originalSource: "/:path*"
|
|
}
|
|
];
|
|
continue;
|
|
}
|
|
if ((0, _worker.isInstrumentationHookFile)(rootFile) && nextConfig.experimental.instrumentationHook) {
|
|
_buildcontext.NextBuildContext.hasInstrumentationHook = true;
|
|
serverFields.actualInstrumentationHookFile = rootFile;
|
|
await propagateServerField("actualInstrumentationHookFile", serverFields.actualInstrumentationHookFile);
|
|
continue;
|
|
}
|
|
if (fileName.endsWith(".ts") || fileName.endsWith(".tsx")) {
|
|
enabledTypeScript = true;
|
|
}
|
|
if (!(isAppPath || isPagePath)) {
|
|
continue;
|
|
}
|
|
// Collect all current filenames for the TS plugin to use
|
|
_shared1.devPageFiles.add(fileName);
|
|
let pageName = (0, _absolutepathtopage.absolutePathToPage)(fileName, {
|
|
dir: isAppPath ? appDir : pagesDir,
|
|
extensions: nextConfig.pageExtensions,
|
|
keepIndex: isAppPath,
|
|
pagesType: isAppPath ? "app" : "pages"
|
|
});
|
|
if (!isAppPath && pageName.startsWith("/api/") && nextConfig.output === "export") {
|
|
_log.error('API Routes cannot be used with "output: export". See more info here: https://nextjs.org/docs/advanced-features/static-html-export');
|
|
continue;
|
|
}
|
|
if (isAppPath) {
|
|
const isRootNotFound = validFileMatcher.isRootNotFound(fileName);
|
|
hasRootAppNotFound = true;
|
|
if (isRootNotFound) {
|
|
continue;
|
|
}
|
|
if (!isRootNotFound && !validFileMatcher.isAppRouterPage(fileName)) {
|
|
continue;
|
|
}
|
|
// Ignore files/directories starting with `_` in the app directory
|
|
if ((0, _normalizepathsep.normalizePathSep)(pageName).includes("/_")) {
|
|
continue;
|
|
}
|
|
const originalPageName = pageName;
|
|
pageName = (0, _apppaths.normalizeAppPath)(pageName).replace(/%5F/g, "_");
|
|
if (!appPaths[pageName]) {
|
|
appPaths[pageName] = [];
|
|
}
|
|
appPaths[pageName].push(originalPageName);
|
|
if (useFileSystemPublicRoutes) {
|
|
appFiles.add(pageName);
|
|
}
|
|
if (routedPages.includes(pageName)) {
|
|
continue;
|
|
}
|
|
} else {
|
|
if (useFileSystemPublicRoutes) {
|
|
pageFiles.add(pageName);
|
|
// always add to nextDataRoutes for now but in future only add
|
|
// entries that actually use getStaticProps/getServerSideProps
|
|
opts.fsChecker.nextDataRoutes.add(pageName);
|
|
}
|
|
}
|
|
(isAppPath ? appPageFilePaths : pagesPageFilePaths).set(pageName, fileName);
|
|
if (appDir && pageNameSet.has(pageName)) {
|
|
conflictingAppPagePaths.add(pageName);
|
|
} else {
|
|
pageNameSet.add(pageName);
|
|
}
|
|
/**
|
|
* If there is a middleware that is not declared in the root we will
|
|
* warn without adding it so it doesn't make its way into the system.
|
|
*/ if (/[\\\\/]_middleware$/.test(pageName)) {
|
|
nestedMiddleware.push(pageName);
|
|
continue;
|
|
}
|
|
routedPages.push(pageName);
|
|
}
|
|
const numConflicting = conflictingAppPagePaths.size;
|
|
conflictingPageChange = numConflicting - previousConflictingPagePaths.size;
|
|
if (conflictingPageChange !== 0) {
|
|
if (numConflicting > 0) {
|
|
let errorMessage = `Conflicting app and page file${numConflicting === 1 ? " was" : "s were"} found, please remove the conflicting files to continue:\n`;
|
|
for (const p of conflictingAppPagePaths){
|
|
const appPath = _path.default.relative(dir, appPageFilePaths.get(p));
|
|
const pagesPath = _path.default.relative(dir, pagesPageFilePaths.get(p));
|
|
errorMessage += ` "${pagesPath}" - "${appPath}"\n`;
|
|
}
|
|
hotReloader.setHmrServerError(new Error(errorMessage));
|
|
} else if (numConflicting === 0) {
|
|
hotReloader.clearHmrServerError();
|
|
await propagateServerField("reloadMatchers", undefined);
|
|
}
|
|
}
|
|
previousConflictingPagePaths = conflictingAppPagePaths;
|
|
let clientRouterFilters;
|
|
if (nextConfig.experimental.clientRouterFilter) {
|
|
clientRouterFilters = (0, _createclientrouterfilter.createClientRouterFilter)(Object.keys(appPaths), nextConfig.experimental.clientRouterFilterRedirects ? (nextConfig._originalRedirects || []).filter((r)=>!r.internal) : [], nextConfig.experimental.clientRouterFilterAllowedRate);
|
|
if (!previousClientRouterFilters || JSON.stringify(previousClientRouterFilters) !== JSON.stringify(clientRouterFilters)) {
|
|
envChange = true;
|
|
previousClientRouterFilters = clientRouterFilters;
|
|
}
|
|
}
|
|
if (!usingTypeScript && enabledTypeScript) {
|
|
// we tolerate the error here as this is best effort
|
|
// and the manual install command will be shown
|
|
await verifyTypeScript(opts).then(()=>{
|
|
tsconfigChange = true;
|
|
}).catch(()=>{});
|
|
}
|
|
if (envChange || tsconfigChange) {
|
|
var _hotReloader_activeWebpackConfigs;
|
|
if (envChange) {
|
|
// only log changes in router server
|
|
(0, _env.loadEnvConfig)(dir, true, _log, true, (envFilePath)=>{
|
|
_log.info(`Reload env: ${envFilePath}`);
|
|
});
|
|
await propagateServerField("loadEnvConfig", [
|
|
{
|
|
dev: true,
|
|
forceReload: true,
|
|
silent: true
|
|
}
|
|
]);
|
|
}
|
|
let tsconfigResult;
|
|
if (tsconfigChange) {
|
|
try {
|
|
tsconfigResult = await (0, _loadjsconfig.default)(dir, nextConfig);
|
|
} catch (_) {
|
|
/* do we want to log if there are syntax errors in tsconfig while editing? */ }
|
|
}
|
|
if (hotReloader.turbopackProject) {
|
|
const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
|
|
await hotReloader.turbopackProject.update({
|
|
defineEnv: (0, _swc.createDefineEnv)({
|
|
allowedRevalidateHeaderKeys: undefined,
|
|
clientRouterFilters,
|
|
config: nextConfig,
|
|
dev: true,
|
|
distDir,
|
|
fetchCacheKeyPrefix: undefined,
|
|
hasRewrites,
|
|
middlewareMatchers: undefined,
|
|
previewModeId: undefined
|
|
})
|
|
});
|
|
}
|
|
(_hotReloader_activeWebpackConfigs = hotReloader.activeWebpackConfigs) == null ? void 0 : _hotReloader_activeWebpackConfigs.forEach((config, idx)=>{
|
|
const isClient = idx === 0;
|
|
const isNodeServer = idx === 1;
|
|
const isEdgeServer = idx === 2;
|
|
const hasRewrites = opts.fsChecker.rewrites.afterFiles.length > 0 || opts.fsChecker.rewrites.beforeFiles.length > 0 || opts.fsChecker.rewrites.fallback.length > 0;
|
|
if (tsconfigChange) {
|
|
var _config_resolve_plugins, _config_resolve;
|
|
(_config_resolve = config.resolve) == null ? void 0 : (_config_resolve_plugins = _config_resolve.plugins) == null ? void 0 : _config_resolve_plugins.forEach((plugin)=>{
|
|
// look for the JsConfigPathsPlugin and update with
|
|
// the latest paths/baseUrl config
|
|
if (plugin && plugin.jsConfigPlugin && tsconfigResult) {
|
|
var _config_resolve_modules, _config_resolve, _jsConfig_compilerOptions;
|
|
const { resolvedBaseUrl, jsConfig } = tsconfigResult;
|
|
const currentResolvedBaseUrl = plugin.resolvedBaseUrl;
|
|
const resolvedUrlIndex = (_config_resolve = config.resolve) == null ? void 0 : (_config_resolve_modules = _config_resolve.modules) == null ? void 0 : _config_resolve_modules.findIndex((item)=>item === currentResolvedBaseUrl);
|
|
if (resolvedBaseUrl && resolvedBaseUrl !== currentResolvedBaseUrl) {
|
|
var _config_resolve_modules1, _config_resolve1;
|
|
// remove old baseUrl and add new one
|
|
if (resolvedUrlIndex && resolvedUrlIndex > -1) {
|
|
var _config_resolve_modules2, _config_resolve2;
|
|
(_config_resolve2 = config.resolve) == null ? void 0 : (_config_resolve_modules2 = _config_resolve2.modules) == null ? void 0 : _config_resolve_modules2.splice(resolvedUrlIndex, 1);
|
|
}
|
|
(_config_resolve1 = config.resolve) == null ? void 0 : (_config_resolve_modules1 = _config_resolve1.modules) == null ? void 0 : _config_resolve_modules1.push(resolvedBaseUrl);
|
|
}
|
|
if ((jsConfig == null ? void 0 : (_jsConfig_compilerOptions = jsConfig.compilerOptions) == null ? void 0 : _jsConfig_compilerOptions.paths) && resolvedBaseUrl) {
|
|
Object.keys(plugin.paths).forEach((key)=>{
|
|
delete plugin.paths[key];
|
|
});
|
|
Object.assign(plugin.paths, jsConfig.compilerOptions.paths);
|
|
plugin.resolvedBaseUrl = resolvedBaseUrl;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
if (envChange) {
|
|
var _config_plugins;
|
|
(_config_plugins = config.plugins) == null ? void 0 : _config_plugins.forEach((plugin)=>{
|
|
// we look for the DefinePlugin definitions so we can
|
|
// update them on the active compilers
|
|
if (plugin && typeof plugin.definitions === "object" && plugin.definitions.__NEXT_DEFINE_ENV) {
|
|
const newDefine = (0, _defineenvplugin.getDefineEnv)({
|
|
allowedRevalidateHeaderKeys: undefined,
|
|
clientRouterFilters,
|
|
config: nextConfig,
|
|
dev: true,
|
|
distDir,
|
|
fetchCacheKeyPrefix: undefined,
|
|
hasRewrites,
|
|
isClient,
|
|
isEdgeServer,
|
|
isNodeOrEdgeCompilation: isNodeServer || isEdgeServer,
|
|
isNodeServer,
|
|
middlewareMatchers: undefined,
|
|
previewModeId: undefined
|
|
});
|
|
Object.keys(plugin.definitions).forEach((key)=>{
|
|
if (!(key in newDefine)) {
|
|
delete plugin.definitions[key];
|
|
}
|
|
});
|
|
Object.assign(plugin.definitions, newDefine);
|
|
}
|
|
});
|
|
}
|
|
});
|
|
hotReloader.invalidate({
|
|
reloadAfterInvalidation: envChange
|
|
});
|
|
}
|
|
if (nestedMiddleware.length > 0) {
|
|
_log.error(new _worker.NestedMiddlewareError(nestedMiddleware, dir, pagesDir || appDir).message);
|
|
nestedMiddleware = [];
|
|
}
|
|
// Make sure to sort parallel routes to make the result deterministic.
|
|
serverFields.appPathRoutes = Object.fromEntries(Object.entries(appPaths).map(([k, v])=>[
|
|
k,
|
|
v.sort()
|
|
]));
|
|
await propagateServerField("appPathRoutes", serverFields.appPathRoutes);
|
|
// TODO: pass this to fsChecker/next-dev-server?
|
|
serverFields.middleware = middlewareMatchers ? {
|
|
match: null,
|
|
page: "/",
|
|
matchers: middlewareMatchers
|
|
} : undefined;
|
|
await propagateServerField("middleware", serverFields.middleware);
|
|
serverFields.hasAppNotFound = hasRootAppNotFound;
|
|
opts.fsChecker.middlewareMatcher = ((_serverFields_middleware = serverFields.middleware) == null ? void 0 : _serverFields_middleware.matchers) ? (0, _middlewareroutematcher.getMiddlewareRouteMatcher)((_serverFields_middleware1 = serverFields.middleware) == null ? void 0 : _serverFields_middleware1.matchers) : undefined;
|
|
opts.fsChecker.interceptionRoutes = ((_generateInterceptionRoutesRewrites = (0, _generateinterceptionroutesrewrites.generateInterceptionRoutesRewrites)(Object.keys(appPaths))) == null ? void 0 : _generateInterceptionRoutesRewrites.map((item)=>(0, _filesystem.buildCustomRoute)("before_files_rewrite", item, opts.nextConfig.basePath, opts.nextConfig.experimental.caseSensitiveRoutes))) || [];
|
|
const exportPathMap = typeof nextConfig.exportPathMap === "function" && await (nextConfig.exportPathMap == null ? void 0 : nextConfig.exportPathMap.call(nextConfig, {}, {
|
|
dev: true,
|
|
dir: opts.dir,
|
|
outDir: null,
|
|
distDir: distDir,
|
|
buildId: "development"
|
|
})) || {};
|
|
for (const [key, value] of Object.entries(exportPathMap || {})){
|
|
opts.fsChecker.interceptionRoutes.push((0, _filesystem.buildCustomRoute)("before_files_rewrite", {
|
|
source: key,
|
|
destination: `${value.page}${value.query ? "?" : ""}${_querystring.default.stringify(value.query)}`
|
|
}, opts.nextConfig.basePath, opts.nextConfig.experimental.caseSensitiveRoutes));
|
|
}
|
|
try {
|
|
// we serve a separate manifest with all pages for the client in
|
|
// dev mode so that we can match a page after a rewrite on the client
|
|
// before it has been built and is populated in the _buildManifest
|
|
const sortedRoutes = (0, _utils.getSortedRoutes)(routedPages);
|
|
opts.fsChecker.dynamicRoutes = sortedRoutes.map((page)=>{
|
|
const regex = (0, _routeregex.getRouteRegex)(page);
|
|
return {
|
|
regex: regex.re.toString(),
|
|
match: (0, _routematcher.getRouteMatcher)(regex),
|
|
page
|
|
};
|
|
});
|
|
const dataRoutes = [];
|
|
for (const page of sortedRoutes){
|
|
const route = (0, _builddataroute.buildDataRoute)(page, "development");
|
|
const routeRegex = (0, _routeregex.getRouteRegex)(route.page);
|
|
dataRoutes.push({
|
|
...route,
|
|
regex: routeRegex.re.toString(),
|
|
match: (0, _routematcher.getRouteMatcher)({
|
|
// TODO: fix this in the manifest itself, must also be fixed in
|
|
// upstream builder that relies on this
|
|
re: opts.nextConfig.i18n ? new RegExp(route.dataRouteRegex.replace(`/development/`, `/development/(?<nextLocale>[^/]+?)/`)) : new RegExp(route.dataRouteRegex),
|
|
groups: routeRegex.groups
|
|
})
|
|
});
|
|
}
|
|
opts.fsChecker.dynamicRoutes.unshift(...dataRoutes);
|
|
if (!(prevSortedRoutes == null ? void 0 : prevSortedRoutes.every((val, idx)=>val === sortedRoutes[idx]))) {
|
|
const addedRoutes = sortedRoutes.filter((route)=>!prevSortedRoutes.includes(route));
|
|
const removedRoutes = prevSortedRoutes.filter((route)=>!sortedRoutes.includes(route));
|
|
// emit the change so clients fetch the update
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.DEV_PAGES_MANIFEST_UPDATE,
|
|
data: [
|
|
{
|
|
devPagesManifest: true
|
|
}
|
|
]
|
|
});
|
|
addedRoutes.forEach((route)=>{
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.ADDED_PAGE,
|
|
data: [
|
|
route
|
|
]
|
|
});
|
|
});
|
|
removedRoutes.forEach((route)=>{
|
|
hotReloader.send({
|
|
action: _hotreloadertypes.HMR_ACTIONS_SENT_TO_BROWSER.REMOVED_PAGE,
|
|
data: [
|
|
route
|
|
]
|
|
});
|
|
});
|
|
}
|
|
prevSortedRoutes = sortedRoutes;
|
|
if (!resolved) {
|
|
resolve();
|
|
resolved = true;
|
|
}
|
|
} catch (e) {
|
|
if (!resolved) {
|
|
reject(e);
|
|
resolved = true;
|
|
} else {
|
|
_log.warn("Failed to reload dynamic routes:", e);
|
|
}
|
|
} finally{
|
|
// Reload the matchers. The filesystem would have been written to,
|
|
// and the matchers need to re-scan it to update the router.
|
|
await propagateServerField("reloadMatchers", undefined);
|
|
}
|
|
});
|
|
wp.watch({
|
|
directories: [
|
|
dir
|
|
],
|
|
startTime: 0
|
|
});
|
|
});
|
|
const clientPagesManifestPath = `/_next/${_constants.CLIENT_STATIC_FILES_PATH}/development/${_constants.DEV_CLIENT_PAGES_MANIFEST}`;
|
|
opts.fsChecker.devVirtualFsItems.add(clientPagesManifestPath);
|
|
const devMiddlewareManifestPath = `/_next/${_constants.CLIENT_STATIC_FILES_PATH}/development/${_constants.DEV_MIDDLEWARE_MANIFEST}`;
|
|
opts.fsChecker.devVirtualFsItems.add(devMiddlewareManifestPath);
|
|
async function requestHandler(req, res) {
|
|
var _parsedUrl_pathname, _parsedUrl_pathname1;
|
|
const parsedUrl = _url.default.parse(req.url || "/");
|
|
if ((_parsedUrl_pathname = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname.includes(clientPagesManifestPath)) {
|
|
res.statusCode = 200;
|
|
res.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
res.end(JSON.stringify({
|
|
pages: prevSortedRoutes.filter((route)=>!opts.fsChecker.appFiles.has(route))
|
|
}));
|
|
return {
|
|
finished: true
|
|
};
|
|
}
|
|
if ((_parsedUrl_pathname1 = parsedUrl.pathname) == null ? void 0 : _parsedUrl_pathname1.includes(devMiddlewareManifestPath)) {
|
|
var _serverFields_middleware;
|
|
res.statusCode = 200;
|
|
res.setHeader("Content-Type", "application/json; charset=utf-8");
|
|
res.end(JSON.stringify(((_serverFields_middleware = serverFields.middleware) == null ? void 0 : _serverFields_middleware.matchers) || []));
|
|
return {
|
|
finished: true
|
|
};
|
|
}
|
|
return {
|
|
finished: false
|
|
};
|
|
}
|
|
async function logErrorWithOriginalStack(err, type) {
|
|
let usedOriginalStack = false;
|
|
if ((0, _iserror.default)(err) && err.stack) {
|
|
try {
|
|
const frames = (0, _middleware.parseStack)(err.stack);
|
|
// Filter out internal edge related runtime stack
|
|
const frame = frames.find(({ file })=>!(file == null ? void 0 : file.startsWith("eval")) && !(file == null ? void 0 : file.includes("web/adapter")) && !(file == null ? void 0 : file.includes("web/globals")) && !(file == null ? void 0 : file.includes("sandbox/context")) && !(file == null ? void 0 : file.includes("<anonymous>")));
|
|
if ((frame == null ? void 0 : frame.lineNumber) && (frame == null ? void 0 : frame.file)) {
|
|
var _hotReloader_edgeServerStats, _hotReloader_serverStats, _frame_file, _frame_file1, _hotReloader_serverStats1, _hotReloader_edgeServerStats1;
|
|
const moduleId = frame.file.replace(/^(webpack-internal:\/\/\/|file:\/\/)/, "");
|
|
const modulePath = frame.file.replace(/^(webpack-internal:\/\/\/|file:\/\/)(\(.*\)\/)?/, "");
|
|
const src = (0, _middleware.getErrorSource)(err);
|
|
const isEdgeCompiler = src === _constants.COMPILER_NAMES.edgeServer;
|
|
const compilation = isEdgeCompiler ? (_hotReloader_edgeServerStats = hotReloader.edgeServerStats) == null ? void 0 : _hotReloader_edgeServerStats.compilation : (_hotReloader_serverStats = hotReloader.serverStats) == null ? void 0 : _hotReloader_serverStats.compilation;
|
|
const source = await (0, _middleware.getSourceById)(!!((_frame_file = frame.file) == null ? void 0 : _frame_file.startsWith(_path.default.sep)) || !!((_frame_file1 = frame.file) == null ? void 0 : _frame_file1.startsWith("file:")), moduleId, compilation);
|
|
const originalFrame = await (0, _middleware.createOriginalStackFrame)({
|
|
line: frame.lineNumber,
|
|
column: frame.column,
|
|
source,
|
|
frame,
|
|
moduleId,
|
|
modulePath,
|
|
rootDirectory: opts.dir,
|
|
errorMessage: err.message,
|
|
serverCompilation: isEdgeCompiler ? undefined : (_hotReloader_serverStats1 = hotReloader.serverStats) == null ? void 0 : _hotReloader_serverStats1.compilation,
|
|
edgeCompilation: isEdgeCompiler ? (_hotReloader_edgeServerStats1 = hotReloader.edgeServerStats) == null ? void 0 : _hotReloader_edgeServerStats1.compilation : undefined
|
|
}).catch(()=>{});
|
|
if (originalFrame) {
|
|
const { originalCodeFrame, originalStackFrame } = originalFrame;
|
|
const { file, lineNumber, column, methodName } = originalStackFrame;
|
|
_log[type === "warning" ? "warn" : "error"](`${file} (${lineNumber}:${column}) @ ${methodName}`);
|
|
if (isEdgeCompiler) {
|
|
err = err.message;
|
|
}
|
|
if (type === "warning") {
|
|
_log.warn(err);
|
|
} else if (type === "app-dir") {
|
|
(0, _logappdirerror.logAppDirError)(err);
|
|
} else if (type) {
|
|
_log.error(`${type}:`, err);
|
|
} else {
|
|
_log.error(err);
|
|
}
|
|
console[type === "warning" ? "warn" : "error"](originalCodeFrame);
|
|
usedOriginalStack = true;
|
|
}
|
|
}
|
|
} catch (_) {
|
|
// failed to load original stack using source maps
|
|
// this un-actionable by users so we don't show the
|
|
// internal error and only show the provided stack
|
|
}
|
|
}
|
|
if (!usedOriginalStack) {
|
|
if (type === "warning") {
|
|
_log.warn(err);
|
|
} else if (type === "app-dir") {
|
|
(0, _logappdirerror.logAppDirError)(err);
|
|
} else if (type) {
|
|
_log.error(`${type}:`, err);
|
|
} else {
|
|
_log.error(err);
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
serverFields,
|
|
hotReloader,
|
|
requestHandler,
|
|
logErrorWithOriginalStack,
|
|
async ensureMiddleware () {
|
|
if (!serverFields.actualMiddlewareFile) return;
|
|
return hotReloader.ensurePage({
|
|
page: serverFields.actualMiddlewareFile,
|
|
clientOnly: false,
|
|
definition: undefined
|
|
});
|
|
}
|
|
};
|
|
}
|
|
async function setupDevBundler(opts) {
|
|
const isSrcDir = _path.default.relative(opts.dir, opts.pagesDir || opts.appDir || "").startsWith("src");
|
|
const result = await startWatcher(opts);
|
|
opts.telemetry.record((0, _events.eventCliSession)(_path.default.join(opts.dir, opts.nextConfig.distDir), opts.nextConfig, {
|
|
webpackVersion: 5,
|
|
isSrcDir,
|
|
turboFlag: false,
|
|
cliCommand: "dev",
|
|
appDir: !!opts.appDir,
|
|
pagesDir: !!opts.pagesDir,
|
|
isCustomServer: !!opts.isCustomServer,
|
|
hasNowJson: !!await (0, _findup.default)("now.json", {
|
|
cwd: opts.dir
|
|
})
|
|
}));
|
|
return result;
|
|
}
|
|
|
|
//# sourceMappingURL=setup-dev-bundler.js.map
|