feat(blog): add file-based blog with dynamic slugs, MDX content and layout shell
- Introduced blog routing using Next.js App Router - Implemented dynamic [slug] pages for blog posts - Added MDX-based content loading via lib/posts - Integrated shared TopBar layout with navigation - Established clear content, lib and component separation
This commit is contained in:
PascalSchattenburg
326
apps/public-web/node_modules/next/dist/build/adapter/build-complete.d.ts
generated
vendored
Normal file
326
apps/public-web/node_modules/next/dist/build/adapter/build-complete.d.ts
generated
vendored
Normal file
@@ -0,0 +1,326 @@
|
||||
import { RenderingMode } from '../rendering-mode';
|
||||
import type { RouteHas } from '../../lib/load-custom-routes';
|
||||
import type { Revalidate } from '../../server/lib/cache-control';
|
||||
import type { NextConfigComplete } from '../../server/config-shared';
|
||||
import { AdapterOutputType, type PHASE_TYPE } from '../../shared/lib/constants';
|
||||
import type { MiddlewareManifest } from '../webpack/plugins/middleware-plugin';
|
||||
import type { RoutesManifest, PrerenderManifest, FunctionsConfigManifest, DynamicPrerenderManifestRoute } from '..';
|
||||
interface SharedRouteFields {
|
||||
/**
|
||||
* id is the unique identifier of the output
|
||||
*/
|
||||
id: string;
|
||||
/**
|
||||
* filePath is the location on disk of the built entrypoint asset
|
||||
*/
|
||||
filePath: string;
|
||||
/**
|
||||
* pathname is the URL pathname the asset should be served at
|
||||
*/
|
||||
pathname: string;
|
||||
/**
|
||||
* sourcePage is the original source in the app or pages folder
|
||||
*/
|
||||
sourcePage: string;
|
||||
/**
|
||||
* runtime is which runtime the entrypoint is built for
|
||||
*/
|
||||
runtime: 'nodejs' | 'edge';
|
||||
/**
|
||||
* assets are all necessary traced assets that could be
|
||||
* loaded by the output to handle a request e.g. traced
|
||||
* node_modules or necessary manifests for Next.js.
|
||||
* The key is the relative path from the repo root and the value
|
||||
* is the absolute path to the file
|
||||
*/
|
||||
assets: Record<string, string>;
|
||||
/**
|
||||
* wasmAssets are bundled wasm files with mapping of name
|
||||
* to filePath on disk
|
||||
*/
|
||||
wasmAssets?: Record<string, string>;
|
||||
/**
|
||||
* config related to the route
|
||||
*/
|
||||
config: {
|
||||
/**
|
||||
* maxDuration is a segment config to signal the max
|
||||
* execution duration a route should be allowed before
|
||||
* it's timed out
|
||||
*/
|
||||
maxDuration?: number;
|
||||
/**
|
||||
* preferredRegion is a segment config to signal deployment
|
||||
* region preferences to the provider being used
|
||||
*/
|
||||
preferredRegion?: string | string[];
|
||||
/**
|
||||
* env is the environment variables to expose, this is only
|
||||
* populated for edge runtime currently
|
||||
*/
|
||||
env?: Record<string, string>;
|
||||
};
|
||||
}
|
||||
export interface AdapterOutput {
|
||||
/**
|
||||
* `PAGES` represents all the React pages that are under `pages/`.
|
||||
*/
|
||||
PAGES: SharedRouteFields & {
|
||||
type: AdapterOutputType.PAGES;
|
||||
};
|
||||
/**
|
||||
* `PAGES_API` represents all the API routes under `pages/api/`.
|
||||
*/
|
||||
PAGES_API: SharedRouteFields & {
|
||||
type: AdapterOutputType.PAGES_API;
|
||||
};
|
||||
/**
|
||||
* `APP_PAGE` represents all the React pages that are under `app/` with the
|
||||
* filename of `page.{j,t}s{,x}`.
|
||||
*/
|
||||
APP_PAGE: SharedRouteFields & {
|
||||
type: AdapterOutputType.APP_PAGE;
|
||||
};
|
||||
/**
|
||||
* `APP_ROUTE` represents all the API routes and metadata routes that are under `app/` with the
|
||||
* filename of `route.{j,t}s{,x}`.
|
||||
*/
|
||||
APP_ROUTE: SharedRouteFields & {
|
||||
type: AdapterOutputType.APP_ROUTE;
|
||||
};
|
||||
/**
|
||||
* `PRERENDER` represents an ISR enabled route that might
|
||||
* have a seeded cache entry or fallback generated during build
|
||||
*/
|
||||
PRERENDER: {
|
||||
id: string;
|
||||
pathname: string;
|
||||
type: AdapterOutputType.PRERENDER;
|
||||
/**
|
||||
* For prerenders the parent output is the originating
|
||||
* page that the prerender is created from
|
||||
*/
|
||||
parentOutputId: string;
|
||||
/**
|
||||
* groupId is the identifier for a group of prerenders that should be
|
||||
* revalidated together
|
||||
*/
|
||||
groupId: number;
|
||||
pprChain?: {
|
||||
headers: Record<string, string>;
|
||||
};
|
||||
/**
|
||||
* parentFallbackMode signals whether additional routes can be generated
|
||||
* e.g. fallback: false or 'blocking' in getStaticPaths in pages router
|
||||
*/
|
||||
parentFallbackMode?: DynamicPrerenderManifestRoute['fallback'];
|
||||
/**
|
||||
* fallback is initial cache data generated during build for a prerender
|
||||
*/
|
||||
fallback?: {
|
||||
/**
|
||||
* path to the fallback file can be HTML/JSON/RSC
|
||||
*/
|
||||
filePath: string;
|
||||
/**
|
||||
* initialStatus is the status code that should be applied
|
||||
* when serving the fallback
|
||||
*/
|
||||
initialStatus?: number;
|
||||
/**
|
||||
* initialHeaders are the headers that should be sent when
|
||||
* serving the fallback
|
||||
*/
|
||||
initialHeaders?: Record<string, string | string[]>;
|
||||
/**
|
||||
* initial expiration is how long until the fallback entry
|
||||
* is considered expired and no longer valid to serve
|
||||
*/
|
||||
initialExpiration?: number;
|
||||
/**
|
||||
* initial revalidate is how long until the fallback is
|
||||
* considered stale and should be revalidated
|
||||
*/
|
||||
initialRevalidate?: Revalidate;
|
||||
/**
|
||||
* postponedState is the PPR state when it postponed and is used for resuming
|
||||
*/
|
||||
postponedState?: string;
|
||||
};
|
||||
/**
|
||||
* config related to the route
|
||||
*/
|
||||
config: {
|
||||
/**
|
||||
* allowQuery is the allowed query values to be passed
|
||||
* to an ISR function and what should be considered for the cacheKey
|
||||
* e.g. for /blog/[slug], "slug" is the only allowQuery
|
||||
*/
|
||||
allowQuery?: string[];
|
||||
/**
|
||||
* allowHeader is the allowed headers to be passed to an
|
||||
* ISR function to prevent accidentally poisoning the cache
|
||||
* from leaking additional information that can impact the render
|
||||
*/
|
||||
allowHeader?: string[];
|
||||
/**
|
||||
* bypass for is a list of has conditions the cache
|
||||
* should be bypassed and invoked directly e.g. action header
|
||||
*/
|
||||
bypassFor?: RouteHas[];
|
||||
/**
|
||||
* renderingMode signals PPR or not for a prerender
|
||||
*/
|
||||
renderingMode?: RenderingMode;
|
||||
/**
|
||||
* bypassToken is the generated token that signals a prerender cache
|
||||
* should be bypassed
|
||||
*/
|
||||
bypassToken?: string;
|
||||
};
|
||||
};
|
||||
/**
|
||||
* `STATIC_FILE` represents a static file (ie /_next/static) or a purely
|
||||
* static HTML asset e.g. an automatically statically optimized page
|
||||
* that does not use ISR
|
||||
*/
|
||||
STATIC_FILE: {
|
||||
id: string;
|
||||
filePath: string;
|
||||
pathname: string;
|
||||
type: AdapterOutputType.STATIC_FILE;
|
||||
};
|
||||
/**
|
||||
* `MIDDLEWARE` represents the middleware output if present
|
||||
*/
|
||||
MIDDLEWARE: SharedRouteFields & {
|
||||
type: AdapterOutputType.MIDDLEWARE;
|
||||
/**
|
||||
* config related to the route
|
||||
*/
|
||||
config: SharedRouteFields['config'] & {
|
||||
/**
|
||||
* matchers are the configured matchers for middleware
|
||||
*/
|
||||
matchers?: Array<{
|
||||
source: string;
|
||||
sourceRegex: string;
|
||||
has: RouteHas[] | undefined;
|
||||
missing: RouteHas[] | undefined;
|
||||
}>;
|
||||
};
|
||||
};
|
||||
}
|
||||
export interface AdapterOutputs {
|
||||
pages: Array<AdapterOutput['PAGES']>;
|
||||
middleware?: AdapterOutput['MIDDLEWARE'];
|
||||
appPages: Array<AdapterOutput['APP_PAGE']>;
|
||||
pagesApi: Array<AdapterOutput['PAGES_API']>;
|
||||
appRoutes: Array<AdapterOutput['APP_ROUTE']>;
|
||||
prerenders: Array<AdapterOutput['PRERENDER']>;
|
||||
staticFiles: Array<AdapterOutput['STATIC_FILE']>;
|
||||
}
|
||||
type RewriteItem = {
|
||||
source: string;
|
||||
sourceRegex: string;
|
||||
destination: string;
|
||||
has: RouteHas[] | undefined;
|
||||
missing: RouteHas[] | undefined;
|
||||
};
|
||||
type DynamicRouteItem = {
|
||||
source: string;
|
||||
sourceRegex: string;
|
||||
destination: string;
|
||||
has: RouteHas[] | undefined;
|
||||
missing: RouteHas[] | undefined;
|
||||
};
|
||||
export interface NextAdapter {
|
||||
name: string;
|
||||
/**
|
||||
* modifyConfig is called for any CLI command that loads the next.config
|
||||
* to only apply for specific commands the "phase" should be used
|
||||
* @param config
|
||||
* @param ctx
|
||||
* @returns
|
||||
*/
|
||||
modifyConfig?: (config: NextConfigComplete, ctx: {
|
||||
phase: PHASE_TYPE;
|
||||
}) => Promise<NextConfigComplete> | NextConfigComplete;
|
||||
onBuildComplete?: (ctx: {
|
||||
routes: {
|
||||
headers: Array<{
|
||||
source: string;
|
||||
sourceRegex: string;
|
||||
headers: Record<string, string>;
|
||||
has: RouteHas[] | undefined;
|
||||
missing: RouteHas[] | undefined;
|
||||
priority?: boolean;
|
||||
}>;
|
||||
redirects: Array<{
|
||||
source: string;
|
||||
sourceRegex: string;
|
||||
destination: string;
|
||||
statusCode: number;
|
||||
has: RouteHas[] | undefined;
|
||||
missing: RouteHas[] | undefined;
|
||||
priority?: boolean;
|
||||
}>;
|
||||
rewrites: {
|
||||
beforeFiles: RewriteItem[];
|
||||
afterFiles: RewriteItem[];
|
||||
fallback: RewriteItem[];
|
||||
};
|
||||
dynamicRoutes: Array<DynamicRouteItem>;
|
||||
};
|
||||
outputs: AdapterOutputs;
|
||||
/**
|
||||
* projectDir is the absolute directory the Next.js application is in
|
||||
*/
|
||||
projectDir: string;
|
||||
/**
|
||||
* repoRoot is the absolute path of the detected root of the repo
|
||||
*/
|
||||
repoRoot: string;
|
||||
/**
|
||||
* distDir is the absolute path to the dist directory
|
||||
*/
|
||||
distDir: string;
|
||||
/**
|
||||
* config is the loaded next.config (has modifyConfig applied)
|
||||
*/
|
||||
config: NextConfigComplete;
|
||||
/**
|
||||
* nextVersion is the current version of Next.js being used
|
||||
*/
|
||||
nextVersion: string;
|
||||
/**
|
||||
* buildId is the current unique ID for the build, this can be
|
||||
* influenced by NextConfig.generateBuildId
|
||||
*/
|
||||
buildId: string;
|
||||
}) => Promise<void> | void;
|
||||
}
|
||||
export declare function handleBuildComplete({ dir, config, buildId, configOutDir, distDir, pageKeys, tracingRoot, adapterPath, appPageKeys, staticPages, nextVersion, hasStatic404, hasStatic500, routesManifest, serverPropsPages, hasNodeMiddleware, prerenderManifest, middlewareManifest, requiredServerFiles, hasInstrumentationHook, functionsConfigManifest, }: {
|
||||
dir: string;
|
||||
distDir: string;
|
||||
buildId: string;
|
||||
configOutDir: string;
|
||||
adapterPath: string;
|
||||
tracingRoot: string;
|
||||
nextVersion: string;
|
||||
hasStatic404: boolean;
|
||||
hasStatic500: boolean;
|
||||
staticPages: Set<string>;
|
||||
hasNodeMiddleware: boolean;
|
||||
config: NextConfigComplete;
|
||||
pageKeys: readonly string[];
|
||||
serverPropsPages: Set<string>;
|
||||
requiredServerFiles: string[];
|
||||
routesManifest: RoutesManifest;
|
||||
hasInstrumentationHook: boolean;
|
||||
prerenderManifest: PrerenderManifest;
|
||||
middlewareManifest: MiddlewareManifest;
|
||||
appPageKeys?: readonly string[] | undefined;
|
||||
functionsConfigManifest: FunctionsConfigManifest;
|
||||
}): Promise<void>;
|
||||
export {};
|
||||
993
apps/public-web/node_modules/next/dist/build/adapter/build-complete.js
generated
vendored
Normal file
993
apps/public-web/node_modules/next/dist/build/adapter/build-complete.js
generated
vendored
Normal file
@@ -0,0 +1,993 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "handleBuildComplete", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return handleBuildComplete;
|
||||
}
|
||||
});
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
||||
const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
|
||||
const _url = require("url");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
|
||||
const _utils = require("../utils");
|
||||
const _renderingmode = require("../rendering-mode");
|
||||
const _interopdefault = require("../../lib/interop-default");
|
||||
const _recursivereaddir = require("../../lib/recursive-readdir");
|
||||
const _utils1 = require("../../shared/lib/router/utils");
|
||||
const _apppaths = require("../../shared/lib/router/utils/app-paths");
|
||||
const _constants = require("../../shared/lib/constants");
|
||||
const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
|
||||
const _routingutils = require("next/dist/compiled/@vercel/routing-utils");
|
||||
const _constants1 = require("../../lib/constants");
|
||||
const _normalizelocalepath = require("../../shared/lib/i18n/normalize-locale-path");
|
||||
const _addpathprefix = require("../../shared/lib/router/utils/add-path-prefix");
|
||||
const _redirectstatus = require("../../lib/redirect-status");
|
||||
const _routeregex = require("../../shared/lib/router/utils/route-regex");
|
||||
const _escaperegexp = require("../../shared/lib/escape-regexp");
|
||||
const _sortableroutes = require("../../shared/lib/router/utils/sortable-routes");
|
||||
const _nft = require("next/dist/compiled/@vercel/nft");
|
||||
const _requirehook = require("../../server/require-hook");
|
||||
const _collectbuildtraces = require("../collect-build-traces");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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;
|
||||
}
|
||||
function normalizePathnames(config, outputs) {
|
||||
// normalize pathname field with basePath
|
||||
if (config.basePath) {
|
||||
for (const output of [
|
||||
...outputs.pages,
|
||||
...outputs.pagesApi,
|
||||
...outputs.appPages,
|
||||
...outputs.appRoutes,
|
||||
...outputs.prerenders,
|
||||
...outputs.staticFiles
|
||||
]){
|
||||
output.pathname = (0, _addpathprefix.addPathPrefix)(output.pathname, config.basePath).replace(/\/$/, '') || '/';
|
||||
}
|
||||
}
|
||||
}
|
||||
async function handleBuildComplete({ dir, config, buildId, configOutDir, distDir, pageKeys, tracingRoot, adapterPath, appPageKeys, staticPages, nextVersion, hasStatic404, hasStatic500, routesManifest, serverPropsPages, hasNodeMiddleware, prerenderManifest, middlewareManifest, requiredServerFiles, hasInstrumentationHook, functionsConfigManifest }) {
|
||||
const adapterMod = (0, _interopdefault.interopDefault)(await import((0, _url.pathToFileURL)(require.resolve(adapterPath)).href));
|
||||
if (typeof adapterMod.onBuildComplete === 'function') {
|
||||
const outputs = {
|
||||
pages: [],
|
||||
pagesApi: [],
|
||||
appPages: [],
|
||||
appRoutes: [],
|
||||
prerenders: [],
|
||||
staticFiles: []
|
||||
};
|
||||
if (config.output === 'export') {
|
||||
// collect export assets and provide as static files
|
||||
const exportFiles = await (0, _recursivereaddir.recursiveReadDir)(configOutDir);
|
||||
for (const file of exportFiles){
|
||||
let pathname = (file.endsWith('.html') ? file.replace(/\.html$/, '') : file).replace(/\\/g, '/');
|
||||
pathname = pathname.startsWith('/') ? pathname : `/${pathname}`;
|
||||
outputs.staticFiles.push({
|
||||
id: file,
|
||||
pathname,
|
||||
filePath: _path.default.join(configOutDir, file),
|
||||
type: _constants.AdapterOutputType.STATIC_FILE
|
||||
});
|
||||
}
|
||||
} else {
|
||||
const staticFiles = await (0, _recursivereaddir.recursiveReadDir)(_path.default.join(distDir, 'static'));
|
||||
for (const file of staticFiles){
|
||||
const pathname = _path.default.posix.join('/_next/static', file);
|
||||
const filePath = _path.default.join(distDir, 'static', file);
|
||||
outputs.staticFiles.push({
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
id: _path.default.join('static', file),
|
||||
pathname,
|
||||
filePath
|
||||
});
|
||||
}
|
||||
const sharedNodeAssets = {};
|
||||
const pagesSharedNodeAssets = {};
|
||||
const appPagesSharedNodeAssets = {};
|
||||
const sharedTraceIgnores = [
|
||||
'**/next/dist/compiled/next-server/**/*.dev.js',
|
||||
'**/next/dist/compiled/webpack/*',
|
||||
'**/node_modules/webpack5/**/*',
|
||||
'**/next/dist/server/lib/route-resolver*',
|
||||
'next/dist/compiled/semver/semver/**/*.js',
|
||||
'**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js',
|
||||
'**/*.d.ts',
|
||||
'**/*.map',
|
||||
'**/next/dist/pages/**/*',
|
||||
'**/node_modules/sharp/**/*',
|
||||
'**/@img/sharp-libvips*/**/*',
|
||||
'**/next/dist/compiled/edge-runtime/**/*',
|
||||
'**/next/dist/server/web/sandbox/**/*',
|
||||
'**/next/dist/server/post-process.js'
|
||||
];
|
||||
const sharedIgnoreFn = (0, _collectbuildtraces.makeIgnoreFn)(tracingRoot, sharedTraceIgnores);
|
||||
for (const file of requiredServerFiles){
|
||||
// add to shared node assets
|
||||
const filePath = _path.default.join(dir, file);
|
||||
const fileOutputPath = _path.default.relative(tracingRoot, filePath);
|
||||
sharedNodeAssets[fileOutputPath] = filePath;
|
||||
}
|
||||
const moduleTypes = [
|
||||
'app-page',
|
||||
'pages'
|
||||
];
|
||||
for (const type of moduleTypes){
|
||||
const currentDependencies = [];
|
||||
const modulePath = require.resolve(`next/dist/server/route-modules/${type}/module.compiled`);
|
||||
const contextDir = _path.default.join(_path.default.dirname(modulePath), 'vendored', 'contexts');
|
||||
for (const item of (await _promises.default.readdir(contextDir))){
|
||||
if (item.match(/\.(mjs|cjs|js)$/)) {
|
||||
currentDependencies.push(_path.default.join(contextDir, item));
|
||||
}
|
||||
}
|
||||
const { fileList, esmFileList } = await (0, _nft.nodeFileTrace)(currentDependencies, {
|
||||
base: tracingRoot,
|
||||
ignore: sharedIgnoreFn
|
||||
});
|
||||
esmFileList.forEach((item)=>fileList.add(item));
|
||||
for (const rootRelativeFilePath of fileList){
|
||||
if (type === 'pages') {
|
||||
pagesSharedNodeAssets[rootRelativeFilePath] = _path.default.join(tracingRoot, rootRelativeFilePath);
|
||||
} else {
|
||||
appPagesSharedNodeAssets[rootRelativeFilePath] = _path.default.join(tracingRoot, rootRelativeFilePath);
|
||||
}
|
||||
}
|
||||
}
|
||||
// These are modules that are necessary for bootstrapping node env
|
||||
const necessaryNodeDependencies = [
|
||||
require.resolve('next/dist/server/node-environment'),
|
||||
require.resolve('next/dist/server/require-hook'),
|
||||
require.resolve('next/dist/server/node-polyfill-crypto'),
|
||||
...Object.values(_requirehook.defaultOverrides).filter((item)=>_path.default.extname(item))
|
||||
];
|
||||
const { fileList, esmFileList } = await (0, _nft.nodeFileTrace)(necessaryNodeDependencies, {
|
||||
base: tracingRoot,
|
||||
ignore: sharedIgnoreFn
|
||||
});
|
||||
esmFileList.forEach((item)=>fileList.add(item));
|
||||
for (const rootRelativeFilePath of fileList){
|
||||
sharedNodeAssets[rootRelativeFilePath] = _path.default.join(tracingRoot, rootRelativeFilePath);
|
||||
}
|
||||
if (hasInstrumentationHook) {
|
||||
const assets = await handleTraceFiles(_path.default.join(distDir, 'server', 'instrumentation.js.nft.json'), 'neutral');
|
||||
const fileOutputPath = _path.default.relative(tracingRoot, _path.default.join(distDir, 'server', 'instrumentation.js'));
|
||||
sharedNodeAssets[fileOutputPath] = _path.default.join(distDir, 'server', 'instrumentation.js');
|
||||
Object.assign(sharedNodeAssets, assets);
|
||||
}
|
||||
async function handleTraceFiles(traceFilePath, type) {
|
||||
const assets = Object.assign({}, sharedNodeAssets, type === 'pages' ? pagesSharedNodeAssets : {}, type === 'app' ? appPagesSharedNodeAssets : {});
|
||||
const traceData = JSON.parse(await _promises.default.readFile(traceFilePath, 'utf8'));
|
||||
const traceFileDir = _path.default.dirname(traceFilePath);
|
||||
for (const relativeFile of traceData.files){
|
||||
const tracedFilePath = _path.default.join(traceFileDir, relativeFile);
|
||||
const fileOutputPath = _path.default.relative(tracingRoot, tracedFilePath);
|
||||
assets[fileOutputPath] = tracedFilePath;
|
||||
}
|
||||
return assets;
|
||||
}
|
||||
async function handleEdgeFunction(page, isMiddleware = false) {
|
||||
let type = _constants.AdapterOutputType.PAGES;
|
||||
const isAppPrefix = page.name.startsWith('app/');
|
||||
const isAppPage = isAppPrefix && page.name.endsWith('/page');
|
||||
const isAppRoute = isAppPrefix && page.name.endsWith('/route');
|
||||
let currentOutputs = outputs.pages;
|
||||
if (isMiddleware) {
|
||||
type = _constants.AdapterOutputType.MIDDLEWARE;
|
||||
} else if (isAppPage) {
|
||||
currentOutputs = outputs.appPages;
|
||||
type = _constants.AdapterOutputType.APP_PAGE;
|
||||
} else if (isAppRoute) {
|
||||
currentOutputs = outputs.appRoutes;
|
||||
type = _constants.AdapterOutputType.APP_ROUTE;
|
||||
} else if (page.page.startsWith('/api')) {
|
||||
currentOutputs = outputs.pagesApi;
|
||||
type = _constants.AdapterOutputType.PAGES_API;
|
||||
}
|
||||
const route = page.page.replace(/^(app|pages)\//, '');
|
||||
const output = {
|
||||
type,
|
||||
id: page.name,
|
||||
runtime: 'edge',
|
||||
sourcePage: route,
|
||||
pathname: isAppPrefix ? (0, _apppaths.normalizeAppPath)(route) : route,
|
||||
filePath: _path.default.join(distDir, page.files.find((item)=>item.startsWith('server/app') || item.startsWith('server/pages')) || // TODO: turbopack build doesn't name the main entry chunk
|
||||
// identifiably so we don't know which to mark here but
|
||||
// technically edge needs all chunks to load always so
|
||||
// should this field even be provided?
|
||||
page.files[0] || ''),
|
||||
assets: {},
|
||||
wasmAssets: {},
|
||||
config: {
|
||||
env: page.env
|
||||
}
|
||||
};
|
||||
function handleFile(file) {
|
||||
const originalPath = _path.default.join(distDir, file);
|
||||
const fileOutputPath = _path.default.join(_path.default.relative(tracingRoot, distDir), file);
|
||||
if (!output.assets) {
|
||||
output.assets = {};
|
||||
}
|
||||
output.assets[fileOutputPath] = originalPath;
|
||||
}
|
||||
for (const file of page.files){
|
||||
handleFile(file);
|
||||
}
|
||||
for (const item of [
|
||||
...page.assets || []
|
||||
]){
|
||||
handleFile(item.filePath);
|
||||
}
|
||||
for (const item of page.wasm || []){
|
||||
if (!output.wasmAssets) {
|
||||
output.wasmAssets = {};
|
||||
}
|
||||
output.wasmAssets[item.name] = _path.default.join(distDir, item.filePath);
|
||||
}
|
||||
if (type === _constants.AdapterOutputType.MIDDLEWARE) {
|
||||
;
|
||||
output.config.matchers = page.matchers.map((item)=>{
|
||||
return {
|
||||
source: item.originalSource,
|
||||
sourceRegex: item.regexp,
|
||||
has: item.has,
|
||||
missing: [
|
||||
...item.missing || [],
|
||||
// always skip middleware for on-demand revalidate
|
||||
{
|
||||
type: 'header',
|
||||
key: 'x-prerender-revalidate',
|
||||
value: prerenderManifest.preview.previewModeId
|
||||
}
|
||||
]
|
||||
};
|
||||
});
|
||||
output.pathname = '/_middleware';
|
||||
output.id = page.name;
|
||||
outputs.middleware = output;
|
||||
} else {
|
||||
currentOutputs.push(output);
|
||||
}
|
||||
// need to add matching .rsc output
|
||||
if (isAppPage) {
|
||||
const rscPathname = (0, _normalizepagepath.normalizePagePath)(output.pathname) + '.rsc';
|
||||
outputs.appPages.push({
|
||||
...output,
|
||||
pathname: rscPathname,
|
||||
id: page.name + '.rsc'
|
||||
});
|
||||
}
|
||||
}
|
||||
const edgeFunctionHandlers = [];
|
||||
for (const middleware of Object.values(middlewareManifest.middleware)){
|
||||
if ((0, _utils.isMiddlewareFilename)(middleware.name)) {
|
||||
edgeFunctionHandlers.push(handleEdgeFunction(middleware, true));
|
||||
}
|
||||
}
|
||||
for (const page of Object.values(middlewareManifest.functions)){
|
||||
edgeFunctionHandlers.push(handleEdgeFunction(page));
|
||||
}
|
||||
const pagesDistDir = _path.default.join(distDir, 'server', 'pages');
|
||||
const pageOutputMap = {};
|
||||
const rscFallbackPath = _path.default.join(distDir, 'server', 'rsc-fallback.json');
|
||||
if (appPageKeys && appPageKeys.length > 0 && pageKeys.length > 0) {
|
||||
await _promises.default.writeFile(rscFallbackPath, '{}');
|
||||
}
|
||||
for (const page of pageKeys){
|
||||
if (page === '/_app' || page === '/_document') {
|
||||
continue;
|
||||
}
|
||||
if (middlewareManifest.functions.hasOwnProperty(page)) {
|
||||
continue;
|
||||
}
|
||||
const route = (0, _normalizepagepath.normalizePagePath)(page);
|
||||
const pageFile = _path.default.join(pagesDistDir, `${route}.js`);
|
||||
// if it's an auto static optimized page it's just
|
||||
// a static file
|
||||
if (staticPages.has(page)) {
|
||||
if (config.i18n) {
|
||||
for (const locale of config.i18n.locales || []){
|
||||
const localePage = page === '/' ? `/${locale}` : (0, _addpathprefix.addPathPrefix)(page, `/${locale}`);
|
||||
const localeOutput = {
|
||||
id: localePage,
|
||||
pathname: localePage,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: _path.default.join(pagesDistDir, `${(0, _normalizepagepath.normalizePagePath)(localePage)}.html`)
|
||||
};
|
||||
outputs.staticFiles.push(localeOutput);
|
||||
if (appPageKeys && appPageKeys.length > 0) {
|
||||
outputs.staticFiles.push({
|
||||
id: `${localePage}.rsc`,
|
||||
pathname: `${localePage}.rsc`,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: rscFallbackPath
|
||||
});
|
||||
}
|
||||
}
|
||||
} else {
|
||||
const staticOutput = {
|
||||
id: page,
|
||||
pathname: route,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: pageFile.replace(/\.js$/, '.html')
|
||||
};
|
||||
outputs.staticFiles.push(staticOutput);
|
||||
if (appPageKeys && appPageKeys.length > 0) {
|
||||
outputs.staticFiles.push({
|
||||
id: `${page}.rsc`,
|
||||
pathname: `${route}.rsc`,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: rscFallbackPath
|
||||
});
|
||||
}
|
||||
}
|
||||
continue;
|
||||
}
|
||||
const pageTraceFile = `${pageFile}.nft.json`;
|
||||
const assets = await handleTraceFiles(pageTraceFile, 'pages').catch((err)=>{
|
||||
if (err.code !== 'ENOENT' || page !== '/404' && page !== '/500') {
|
||||
_log.warn(`Failed to locate traced assets for ${pageFile}`, err);
|
||||
}
|
||||
return {};
|
||||
});
|
||||
const functionConfig = functionsConfigManifest.functions[route] || {};
|
||||
let sourcePage = route.replace(/^\//, '');
|
||||
sourcePage = sourcePage === 'api' ? 'api/index' : sourcePage;
|
||||
const output = {
|
||||
id: route,
|
||||
type: page.startsWith('/api') ? _constants.AdapterOutputType.PAGES_API : _constants.AdapterOutputType.PAGES,
|
||||
filePath: pageTraceFile.replace(/\.nft\.json$/, ''),
|
||||
pathname: route,
|
||||
sourcePage,
|
||||
assets,
|
||||
runtime: 'nodejs',
|
||||
config: {
|
||||
maxDuration: functionConfig.maxDuration,
|
||||
preferredRegion: functionConfig.regions
|
||||
}
|
||||
};
|
||||
pageOutputMap[page] = output;
|
||||
if (output.type === _constants.AdapterOutputType.PAGES) {
|
||||
var _config_i18n;
|
||||
outputs.pages.push(output);
|
||||
// if page is get server side props we need to create
|
||||
// the _next/data output as well
|
||||
if (serverPropsPages.has(page)) {
|
||||
const dataPathname = _path.default.posix.join('/_next/data', buildId, (0, _normalizepagepath.normalizePagePath)(page) + '.json');
|
||||
outputs.pages.push({
|
||||
...output,
|
||||
pathname: dataPathname,
|
||||
id: dataPathname
|
||||
});
|
||||
}
|
||||
for (const locale of ((_config_i18n = config.i18n) == null ? void 0 : _config_i18n.locales) || []){
|
||||
const localePage = page === '/' ? `/${locale}` : (0, _addpathprefix.addPathPrefix)(page, `/${locale}`);
|
||||
outputs.pages.push({
|
||||
...output,
|
||||
id: localePage,
|
||||
pathname: localePage
|
||||
});
|
||||
if (serverPropsPages.has(page)) {
|
||||
const dataPathname = _path.default.posix.join('/_next/data', buildId, localePage + '.json');
|
||||
outputs.pages.push({
|
||||
...output,
|
||||
pathname: dataPathname,
|
||||
id: dataPathname
|
||||
});
|
||||
}
|
||||
}
|
||||
} else {
|
||||
outputs.pagesApi.push(output);
|
||||
}
|
||||
if (appPageKeys && appPageKeys.length > 0) {
|
||||
outputs.staticFiles.push({
|
||||
id: `${output.id}.rsc`,
|
||||
pathname: `${output.pathname}.rsc`,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: rscFallbackPath
|
||||
});
|
||||
}
|
||||
}
|
||||
if (hasNodeMiddleware) {
|
||||
var _functionConfig_matchers;
|
||||
const middlewareFile = _path.default.join(distDir, 'server', 'middleware.js');
|
||||
const middlewareTrace = `${middlewareFile}.nft.json`;
|
||||
const assets = await handleTraceFiles(middlewareTrace, 'neutral');
|
||||
const functionConfig = functionsConfigManifest.functions['/_middleware'] || {};
|
||||
outputs.middleware = {
|
||||
pathname: '/_middleware',
|
||||
id: '/_middleware',
|
||||
sourcePage: 'middleware',
|
||||
assets,
|
||||
type: _constants.AdapterOutputType.MIDDLEWARE,
|
||||
runtime: 'nodejs',
|
||||
filePath: middlewareFile,
|
||||
config: {
|
||||
matchers: ((_functionConfig_matchers = functionConfig.matchers) == null ? void 0 : _functionConfig_matchers.map((item)=>{
|
||||
return {
|
||||
source: item.originalSource,
|
||||
sourceRegex: item.regexp,
|
||||
has: item.has,
|
||||
missing: [
|
||||
...item.missing || [],
|
||||
// always skip middleware for on-demand revalidate
|
||||
{
|
||||
type: 'header',
|
||||
key: 'x-prerender-revalidate',
|
||||
value: prerenderManifest.preview.previewModeId
|
||||
}
|
||||
]
|
||||
};
|
||||
})) || []
|
||||
}
|
||||
};
|
||||
}
|
||||
const appOutputMap = {};
|
||||
const appDistDir = _path.default.join(distDir, 'server', 'app');
|
||||
if (appPageKeys) {
|
||||
for (const page of appPageKeys){
|
||||
if (middlewareManifest.functions.hasOwnProperty(page)) {
|
||||
continue;
|
||||
}
|
||||
const normalizedPage = (0, _apppaths.normalizeAppPath)(page);
|
||||
const pageFile = _path.default.join(appDistDir, `${page}.js`);
|
||||
const pageTraceFile = `${pageFile}.nft.json`;
|
||||
const assets = await handleTraceFiles(pageTraceFile, 'app').catch((err)=>{
|
||||
_log.warn(`Failed to copy traced files for ${pageFile}`, err);
|
||||
return {};
|
||||
});
|
||||
// If this is a parallel route we just need to merge
|
||||
// the assets as they share the same pathname
|
||||
const existingOutput = appOutputMap[normalizedPage];
|
||||
if (existingOutput) {
|
||||
Object.assign(existingOutput.assets, assets);
|
||||
existingOutput.assets[_path.default.relative(tracingRoot, pageFile)] = pageFile;
|
||||
continue;
|
||||
}
|
||||
const functionConfig = functionsConfigManifest.functions[normalizedPage] || {};
|
||||
const output = {
|
||||
pathname: normalizedPage,
|
||||
id: normalizedPage,
|
||||
sourcePage: page,
|
||||
assets,
|
||||
type: page.endsWith('/route') ? _constants.AdapterOutputType.APP_ROUTE : _constants.AdapterOutputType.APP_PAGE,
|
||||
runtime: 'nodejs',
|
||||
filePath: pageFile,
|
||||
config: {
|
||||
maxDuration: functionConfig.maxDuration,
|
||||
preferredRegion: functionConfig.regions
|
||||
}
|
||||
};
|
||||
appOutputMap[normalizedPage] = output;
|
||||
if (output.type === _constants.AdapterOutputType.APP_PAGE) {
|
||||
outputs.appPages.push({
|
||||
...output,
|
||||
pathname: (0, _normalizepagepath.normalizePagePath)(output.pathname) + '.rsc',
|
||||
id: (0, _normalizepagepath.normalizePagePath)(output.pathname) + '.rsc'
|
||||
});
|
||||
outputs.appPages.push(output);
|
||||
} else {
|
||||
outputs.appRoutes.push(output);
|
||||
}
|
||||
}
|
||||
}
|
||||
const getParentOutput = (srcRoute, childRoute, allowMissing)=>{
|
||||
var _config_i18n;
|
||||
const normalizedSrcRoute = (0, _normalizelocalepath.normalizeLocalePath)(srcRoute, ((_config_i18n = config.i18n) == null ? void 0 : _config_i18n.locales) || []).pathname;
|
||||
const parentOutput = pageOutputMap[normalizedSrcRoute] || appOutputMap[normalizedSrcRoute];
|
||||
if (!parentOutput && !allowMissing) {
|
||||
console.error({
|
||||
appOutputs: Object.keys(appOutputMap),
|
||||
pageOutputs: Object.keys(pageOutputMap)
|
||||
});
|
||||
throw Object.defineProperty(new Error(`Invariant: failed to find source route ${srcRoute} for prerender ${childRoute}`), "__NEXT_ERROR_CODE", {
|
||||
value: "E777",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return parentOutput;
|
||||
};
|
||||
const { prefetchSegmentDirSuffix, prefetchSegmentSuffix, varyHeader, didPostponeHeader, contentTypeHeader: rscContentTypeHeader } = routesManifest.rsc;
|
||||
const handleAppMeta = async (route, initialOutput, meta)=>{
|
||||
if (meta.postponed && initialOutput.fallback) {
|
||||
initialOutput.fallback.postponedState = meta.postponed;
|
||||
}
|
||||
if (meta == null ? void 0 : meta.segmentPaths) {
|
||||
const normalizedRoute = (0, _normalizepagepath.normalizePagePath)(route);
|
||||
const segmentsDir = _path.default.join(appDistDir, `${normalizedRoute}${prefetchSegmentDirSuffix}`);
|
||||
for (const segmentPath of meta.segmentPaths){
|
||||
var _initialOutput_fallback, _initialOutput_fallback1, _initialOutput_fallback2;
|
||||
const outputSegmentPath = _path.default.join(normalizedRoute + prefetchSegmentDirSuffix, segmentPath) + prefetchSegmentSuffix;
|
||||
const fallbackPathname = _path.default.join(segmentsDir, segmentPath + prefetchSegmentSuffix);
|
||||
outputs.prerenders.push({
|
||||
id: outputSegmentPath,
|
||||
pathname: outputSegmentPath,
|
||||
type: _constants.AdapterOutputType.PRERENDER,
|
||||
parentOutputId: initialOutput.parentOutputId,
|
||||
groupId: initialOutput.groupId,
|
||||
config: {
|
||||
...initialOutput.config
|
||||
},
|
||||
fallback: {
|
||||
filePath: fallbackPathname,
|
||||
initialExpiration: (_initialOutput_fallback = initialOutput.fallback) == null ? void 0 : _initialOutput_fallback.initialExpiration,
|
||||
initialRevalidate: (_initialOutput_fallback1 = initialOutput.fallback) == null ? void 0 : _initialOutput_fallback1.initialRevalidate,
|
||||
initialHeaders: {
|
||||
...(_initialOutput_fallback2 = initialOutput.fallback) == null ? void 0 : _initialOutput_fallback2.initialHeaders,
|
||||
vary: varyHeader,
|
||||
'content-type': rscContentTypeHeader,
|
||||
[didPostponeHeader]: '2'
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
let prerenderGroupId = 1;
|
||||
const getAppRouteMeta = async (route, isAppPage)=>{
|
||||
const basename = route.endsWith('/') ? `${route}index` : route;
|
||||
const meta = isAppPage ? JSON.parse(await _promises.default.readFile(_path.default.join(appDistDir, `${basename}.meta`), 'utf8').catch(()=>'{}')) : {};
|
||||
if (meta.headers) {
|
||||
// normalize these for consistency
|
||||
for (const key of Object.keys(meta.headers)){
|
||||
const keyLower = key.toLowerCase();
|
||||
if (keyLower !== key) {
|
||||
const value = meta.headers[key];
|
||||
delete meta.headers[key];
|
||||
meta.headers[keyLower] = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return meta;
|
||||
};
|
||||
const filePathCache = new Map();
|
||||
const cachedFilePathCheck = async (filePath)=>{
|
||||
if (filePathCache.has(filePath)) {
|
||||
return filePathCache.get(filePath);
|
||||
}
|
||||
const newCheck = _promises.default.access(filePath).then(()=>true).catch(()=>false);
|
||||
filePathCache.set(filePath, newCheck);
|
||||
return newCheck;
|
||||
};
|
||||
for(const route in prerenderManifest.routes){
|
||||
var _routesManifest_dynamicRoutes_find;
|
||||
const { initialExpireSeconds: initialExpiration, initialRevalidateSeconds: initialRevalidate, initialHeaders, initialStatus, prefetchDataRoute, dataRoute, renderingMode, allowHeader, experimentalBypassFor } = prerenderManifest.routes[route];
|
||||
const srcRoute = prerenderManifest.routes[route].srcRoute || route;
|
||||
const srcRouteInfo = prerenderManifest.dynamicRoutes[srcRoute];
|
||||
const isAppPage = Boolean(appOutputMap[srcRoute]) || srcRoute === '/_not-found';
|
||||
const isNotFoundTrue = prerenderManifest.notFoundRoutes.includes(route);
|
||||
let allowQuery;
|
||||
const routeKeys = (_routesManifest_dynamicRoutes_find = routesManifest.dynamicRoutes.find((item)=>item.page === srcRoute)) == null ? void 0 : _routesManifest_dynamicRoutes_find.routeKeys;
|
||||
if (!(0, _utils1.isDynamicRoute)(srcRoute)) {
|
||||
// for non-dynamic routes we use an empty array since
|
||||
// no query values bust the cache for non-dynamic prerenders
|
||||
// prerendered paths also do not pass allowQuery as they match
|
||||
// during handle: 'filesystem' so should not cache differently
|
||||
// by query values
|
||||
allowQuery = [];
|
||||
} else if (routeKeys) {
|
||||
// if we have routeKeys in the routes-manifest we use those
|
||||
// for allowQuery for dynamic routes
|
||||
allowQuery = Object.values(routeKeys);
|
||||
}
|
||||
let filePath = _path.default.join(isAppPage ? appDistDir : pagesDistDir, `${(0, _normalizepagepath.normalizePagePath)(route)}.${isAppPage && !dataRoute ? 'body' : 'html'}`);
|
||||
// we use the static 404 for notFound: true if available
|
||||
// if not we do a blocking invoke on first request
|
||||
if (isNotFoundTrue && hasStatic404) {
|
||||
var _config_i18n1;
|
||||
const locale = config.i18n && (0, _normalizelocalepath.normalizeLocalePath)(route, (_config_i18n1 = config.i18n) == null ? void 0 : _config_i18n1.locales).detectedLocale;
|
||||
for (const currentFilePath of [
|
||||
_path.default.join(pagesDistDir, locale || '', '404.html'),
|
||||
_path.default.join(pagesDistDir, '404.html')
|
||||
]){
|
||||
if (await cachedFilePathCheck(currentFilePath)) {
|
||||
filePath = currentFilePath;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
const meta = await getAppRouteMeta(route, isAppPage);
|
||||
const initialOutput = {
|
||||
id: route,
|
||||
type: _constants.AdapterOutputType.PRERENDER,
|
||||
pathname: route,
|
||||
parentOutputId: srcRoute === '/_not-found' ? srcRoute : getParentOutput(srcRoute, route).id,
|
||||
groupId: prerenderGroupId,
|
||||
pprChain: isAppPage && config.experimental.ppr ? {
|
||||
headers: {
|
||||
[_constants1.NEXT_RESUME_HEADER]: '1'
|
||||
}
|
||||
} : undefined,
|
||||
parentFallbackMode: srcRouteInfo == null ? void 0 : srcRouteInfo.fallback,
|
||||
fallback: !isNotFoundTrue || isNotFoundTrue && hasStatic404 ? {
|
||||
filePath,
|
||||
initialStatus: initialStatus ?? isNotFoundTrue ? 404 : undefined,
|
||||
initialHeaders: {
|
||||
...initialHeaders,
|
||||
vary: varyHeader,
|
||||
'content-type': _constants1.HTML_CONTENT_TYPE_HEADER,
|
||||
...meta.headers
|
||||
},
|
||||
initialExpiration,
|
||||
initialRevalidate: typeof initialRevalidate === 'undefined' ? 1 : initialRevalidate
|
||||
} : undefined,
|
||||
config: {
|
||||
allowQuery,
|
||||
allowHeader,
|
||||
renderingMode,
|
||||
bypassFor: experimentalBypassFor,
|
||||
bypassToken: prerenderManifest.preview.previewModeId
|
||||
}
|
||||
};
|
||||
outputs.prerenders.push(initialOutput);
|
||||
if (dataRoute) {
|
||||
var _initialOutput_fallback;
|
||||
let dataFilePath = _path.default.join(pagesDistDir, `${(0, _normalizepagepath.normalizePagePath)(route)}.json`);
|
||||
if (isAppPage) {
|
||||
// When experimental PPR is enabled, we expect that the data
|
||||
// that should be served as a part of the prerender should
|
||||
// be from the prefetch data route. If this isn't enabled
|
||||
// for ppr, the only way to get the data is from the data
|
||||
// route.
|
||||
dataFilePath = _path.default.join(appDistDir, prefetchDataRoute && renderingMode === _renderingmode.RenderingMode.PARTIALLY_STATIC ? prefetchDataRoute : dataRoute);
|
||||
}
|
||||
outputs.prerenders.push({
|
||||
...initialOutput,
|
||||
id: dataRoute,
|
||||
pathname: dataRoute,
|
||||
fallback: isNotFoundTrue ? undefined : {
|
||||
...initialOutput.fallback,
|
||||
initialHeaders: {
|
||||
...(_initialOutput_fallback = initialOutput.fallback) == null ? void 0 : _initialOutput_fallback.initialHeaders,
|
||||
'content-type': isAppPage ? rscContentTypeHeader : _constants1.JSON_CONTENT_TYPE_HEADER
|
||||
},
|
||||
filePath: dataFilePath
|
||||
}
|
||||
});
|
||||
}
|
||||
if (isAppPage) {
|
||||
await handleAppMeta(route, initialOutput, meta);
|
||||
}
|
||||
prerenderGroupId += 1;
|
||||
}
|
||||
for(const dynamicRoute in prerenderManifest.dynamicRoutes){
|
||||
var _routesManifest_dynamicRoutes_find1;
|
||||
const { fallback, fallbackExpire, fallbackRevalidate, fallbackHeaders, fallbackStatus, allowHeader, dataRoute, renderingMode, experimentalBypassFor } = prerenderManifest.dynamicRoutes[dynamicRoute];
|
||||
const isAppPage = Boolean(appOutputMap[dynamicRoute]);
|
||||
const allowQuery = Object.values(((_routesManifest_dynamicRoutes_find1 = routesManifest.dynamicRoutes.find((item)=>item.page === dynamicRoute)) == null ? void 0 : _routesManifest_dynamicRoutes_find1.routeKeys) || {});
|
||||
const meta = await getAppRouteMeta(dynamicRoute, isAppPage);
|
||||
const initialOutput = {
|
||||
id: dynamicRoute,
|
||||
type: _constants.AdapterOutputType.PRERENDER,
|
||||
pathname: dynamicRoute,
|
||||
parentOutputId: getParentOutput(dynamicRoute, dynamicRoute).id,
|
||||
groupId: prerenderGroupId,
|
||||
config: {
|
||||
allowQuery,
|
||||
allowHeader,
|
||||
renderingMode,
|
||||
bypassFor: experimentalBypassFor,
|
||||
bypassToken: prerenderManifest.preview.previewModeId
|
||||
},
|
||||
fallback: typeof fallback === 'string' ? {
|
||||
filePath: _path.default.join(isAppPage ? appDistDir : pagesDistDir, // app router dynamic route fallbacks don't have the
|
||||
// extension so ensure it's added here
|
||||
fallback.endsWith('.html') ? fallback : `${fallback}.html`),
|
||||
initialStatus: fallbackStatus,
|
||||
initialHeaders: {
|
||||
...fallbackHeaders,
|
||||
'content-type': _constants1.HTML_CONTENT_TYPE_HEADER
|
||||
},
|
||||
initialExpiration: fallbackExpire,
|
||||
initialRevalidate: fallbackRevalidate || 1
|
||||
} : undefined
|
||||
};
|
||||
if (!config.i18n || isAppPage) {
|
||||
outputs.prerenders.push(initialOutput);
|
||||
if (isAppPage) {
|
||||
await handleAppMeta(dynamicRoute, initialOutput, meta);
|
||||
}
|
||||
if (dataRoute) {
|
||||
outputs.prerenders.push({
|
||||
...initialOutput,
|
||||
id: dataRoute,
|
||||
pathname: dataRoute,
|
||||
fallback: undefined
|
||||
});
|
||||
}
|
||||
prerenderGroupId += 1;
|
||||
} else {
|
||||
for (const locale of config.i18n.locales){
|
||||
const currentOutput = {
|
||||
...initialOutput,
|
||||
pathname: _path.default.posix.join(`/${locale}`, initialOutput.pathname),
|
||||
id: _path.default.posix.join(`/${locale}`, initialOutput.id),
|
||||
fallback: typeof fallback === 'string' ? {
|
||||
...initialOutput.fallback,
|
||||
filePath: _path.default.join(pagesDistDir, locale, // app router dynamic route fallbacks don't have the
|
||||
// extension so ensure it's added here
|
||||
fallback.endsWith('.html') ? fallback : `${fallback}.html`)
|
||||
} : undefined,
|
||||
groupId: prerenderGroupId
|
||||
};
|
||||
outputs.prerenders.push(currentOutput);
|
||||
if (dataRoute) {
|
||||
const dataPathname = _path.default.posix.join(`/_next/data`, buildId, locale, dynamicRoute + '.json');
|
||||
outputs.prerenders.push({
|
||||
...initialOutput,
|
||||
id: dataPathname,
|
||||
pathname: dataPathname,
|
||||
// data route doesn't have skeleton fallback
|
||||
fallback: undefined,
|
||||
groupId: prerenderGroupId
|
||||
});
|
||||
}
|
||||
prerenderGroupId += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
// ensure 404
|
||||
const staticErrorDocs = [
|
||||
...hasStatic404 ? [
|
||||
'/404'
|
||||
] : [],
|
||||
...hasStatic500 ? [
|
||||
'/500'
|
||||
] : []
|
||||
];
|
||||
for (const errorDoc of staticErrorDocs){
|
||||
var _config_i18n2;
|
||||
const errorDocPath = _path.default.posix.join('/', ((_config_i18n2 = config.i18n) == null ? void 0 : _config_i18n2.defaultLocale) || '', errorDoc);
|
||||
if (!prerenderManifest.routes[errorDocPath]) {
|
||||
var _config_i18n_locales, _config_i18n3;
|
||||
for (const currentDocPath of [
|
||||
errorDocPath,
|
||||
...((_config_i18n3 = config.i18n) == null ? void 0 : (_config_i18n_locales = _config_i18n3.locales) == null ? void 0 : _config_i18n_locales.map((locale)=>_path.default.posix.join('/', locale, errorDoc))) || []
|
||||
]){
|
||||
const currentFilePath = _path.default.join(pagesDistDir, `${currentDocPath}.html`);
|
||||
if (await cachedFilePathCheck(currentFilePath)) {
|
||||
outputs.staticFiles.push({
|
||||
pathname: currentDocPath,
|
||||
id: currentDocPath,
|
||||
type: _constants.AdapterOutputType.STATIC_FILE,
|
||||
filePath: currentFilePath
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
normalizePathnames(config, outputs);
|
||||
const dynamicRoutes = [];
|
||||
const dynamicDataRoutes = [];
|
||||
const dynamicSegmentRoutes = [];
|
||||
const getDestinationQuery = (routeKeys)=>{
|
||||
const items = Object.entries(routeKeys ?? {});
|
||||
if (items.length === 0) return '';
|
||||
return '?' + items.map(([key, value])=>`${value}=$${key}`).join('&');
|
||||
};
|
||||
const fallbackFalseHasCondition = [
|
||||
{
|
||||
type: 'cookie',
|
||||
key: '__prerender_bypass',
|
||||
value: prerenderManifest.preview.previewModeId
|
||||
},
|
||||
{
|
||||
type: 'cookie',
|
||||
key: '__next_preview_data'
|
||||
}
|
||||
];
|
||||
for (const route of routesManifest.dynamicRoutes){
|
||||
var _prerenderManifest_dynamicRoutes_route_page;
|
||||
const shouldLocalize = config.i18n;
|
||||
const routeRegex = (0, _routeregex.getNamedRouteRegex)(route.page, {
|
||||
prefixRouteKeys: true
|
||||
});
|
||||
const isFallbackFalse = ((_prerenderManifest_dynamicRoutes_route_page = prerenderManifest.dynamicRoutes[route.page]) == null ? void 0 : _prerenderManifest_dynamicRoutes_route_page.fallback) === false;
|
||||
const { hasFallbackRootParams } = route;
|
||||
const sourceRegex = routeRegex.namedRegex.replace('^', `^${config.basePath && config.basePath !== '/' ? _path.default.posix.join('/', config.basePath || '') : ''}[/]?${shouldLocalize ? '(?<nextLocale>[^/]{1,})?' : ''}`);
|
||||
const destination = _path.default.posix.join('/', config.basePath, shouldLocalize ? '/$nextLocale' : '', route.page) + getDestinationQuery(route.routeKeys);
|
||||
if (appPageKeys && appPageKeys.length > 0 && config.cacheComponents) {
|
||||
// If we have fallback root params (implying we've already
|
||||
// emitted a rewrite for the /_tree request), or if the route
|
||||
// has PPR enabled and client param parsing is enabled, then
|
||||
// we don't need to include any other suffixes.
|
||||
const shouldSkipSuffixes = hasFallbackRootParams;
|
||||
dynamicRoutes.push({
|
||||
source: route.page + '.rsc',
|
||||
sourceRegex: sourceRegex.replace(new RegExp((0, _escaperegexp.escapeStringRegexp)('(?:/)?$')), // Now than the upstream issues has been resolved, we can safely
|
||||
// add the suffix back, this resolves a bug related to segment
|
||||
// rewrites not capturing the correct suffix values when
|
||||
// enabled.
|
||||
shouldSkipSuffixes ? '(?<rscSuffix>\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$' : '(?<rscSuffix>\\.rsc|\\.prefetch\\.rsc|\\.segments/.+\\.segment\\.rsc)(?:/)?$'),
|
||||
destination: destination == null ? void 0 : destination.replace(/($|\?)/, '$rscSuffix$1'),
|
||||
has: isFallbackFalse ? fallbackFalseHasCondition : undefined,
|
||||
missing: undefined
|
||||
});
|
||||
}
|
||||
// needs basePath and locale handling if pages router
|
||||
dynamicRoutes.push({
|
||||
source: route.page,
|
||||
sourceRegex,
|
||||
destination,
|
||||
has: isFallbackFalse ? fallbackFalseHasCondition : undefined,
|
||||
missing: undefined
|
||||
});
|
||||
for (const segmentRoute of route.prefetchSegmentDataRoutes || []){
|
||||
dynamicSegmentRoutes.push({
|
||||
source: route.page,
|
||||
sourceRegex: segmentRoute.source.replace('^', `^${config.basePath && config.basePath !== '/' ? _path.default.posix.join('/', config.basePath || '') : ''}[/]?`),
|
||||
destination: _path.default.posix.join('/', config.basePath, segmentRoute.destination + getDestinationQuery(segmentRoute.routeKeys)),
|
||||
has: undefined,
|
||||
missing: undefined
|
||||
});
|
||||
}
|
||||
}
|
||||
const needsMiddlewareResolveRoutes = outputs.middleware && outputs.pages.length > 0;
|
||||
const dataRoutePages = new Set([
|
||||
...routesManifest.dataRoutes.map((item)=>item.page)
|
||||
]);
|
||||
const sortedDataPages = (0, _sortableroutes.sortSortableRoutes)([
|
||||
...needsMiddlewareResolveRoutes ? [
|
||||
...staticPages
|
||||
].map((page)=>({
|
||||
sourcePage: page,
|
||||
page
|
||||
})) : [],
|
||||
...routesManifest.dataRoutes.map((item)=>({
|
||||
sourcePage: item.page,
|
||||
page: item.page
|
||||
}))
|
||||
]);
|
||||
for (const { page } of sortedDataPages){
|
||||
if (needsMiddlewareResolveRoutes || (0, _utils1.isDynamicRoute)(page)) {
|
||||
var _prerenderManifest_dynamicRoutes_page;
|
||||
const shouldLocalize = config.i18n;
|
||||
const isFallbackFalse = ((_prerenderManifest_dynamicRoutes_page = prerenderManifest.dynamicRoutes[page]) == null ? void 0 : _prerenderManifest_dynamicRoutes_page.fallback) === false;
|
||||
const routeRegex = (0, _routeregex.getNamedRouteRegex)(page + '.json', {
|
||||
prefixRouteKeys: true,
|
||||
includeSuffix: true
|
||||
});
|
||||
const isDataRoute = dataRoutePages.has(page);
|
||||
const destination = _path.default.posix.join('/', config.basePath, ...isDataRoute ? [
|
||||
`_next/data`,
|
||||
buildId
|
||||
] : '', ...page === '/' ? [
|
||||
shouldLocalize ? '$nextLocale.json' : 'index.json'
|
||||
] : [
|
||||
shouldLocalize ? '$nextLocale' : '',
|
||||
page + (isDataRoute ? '.json' : '') + getDestinationQuery(routeRegex.routeKeys || {})
|
||||
]);
|
||||
dynamicDataRoutes.push({
|
||||
source: page,
|
||||
sourceRegex: shouldLocalize && page === '/' ? '^' + _path.default.posix.join('/', config.basePath, '_next/data', (0, _escaperegexp.escapeStringRegexp)(buildId), '(?<nextLocale>[^/]{1,}).json') : routeRegex.namedRegex.replace('^', `^${_path.default.posix.join('/', config.basePath, `_next/data`, (0, _escaperegexp.escapeStringRegexp)(buildId))}[/]?${shouldLocalize ? '(?<nextLocale>[^/]{1,})?' : ''}`),
|
||||
destination,
|
||||
has: isFallbackFalse ? fallbackFalseHasCondition : undefined,
|
||||
missing: undefined
|
||||
});
|
||||
}
|
||||
}
|
||||
const buildRewriteItem = (route)=>{
|
||||
const converted = (0, _routingutils.convertRewrites)([
|
||||
route
|
||||
], [
|
||||
'nextInternalLocale'
|
||||
])[0];
|
||||
const regex = converted.src || route.regex;
|
||||
return {
|
||||
source: route.source,
|
||||
sourceRegex: route.internal ? regex : (0, _redirectstatus.modifyRouteRegex)(regex),
|
||||
destination: converted.dest || route.destination,
|
||||
has: route.has,
|
||||
missing: route.missing
|
||||
};
|
||||
};
|
||||
try {
|
||||
_log.info(`Running onBuildComplete from ${adapterMod.name}`);
|
||||
await adapterMod.onBuildComplete({
|
||||
routes: {
|
||||
dynamicRoutes: [
|
||||
...dynamicDataRoutes,
|
||||
...dynamicSegmentRoutes,
|
||||
...dynamicRoutes
|
||||
],
|
||||
rewrites: {
|
||||
beforeFiles: routesManifest.rewrites.beforeFiles.map(buildRewriteItem),
|
||||
afterFiles: routesManifest.rewrites.afterFiles.map(buildRewriteItem),
|
||||
fallback: routesManifest.rewrites.fallback.map(buildRewriteItem)
|
||||
},
|
||||
redirects: routesManifest.redirects.map((route)=>{
|
||||
var _converted_headers;
|
||||
const converted = (0, _routingutils.convertRedirects)([
|
||||
route
|
||||
], 307)[0];
|
||||
let dest = 'headers' in converted && ((_converted_headers = converted.headers) == null ? void 0 : _converted_headers.Location);
|
||||
const regex = converted.src || route.regex;
|
||||
return {
|
||||
source: route.source,
|
||||
sourceRegex: route.internal ? regex : (0, _redirectstatus.modifyRouteRegex)(regex),
|
||||
destination: dest || route.destination,
|
||||
statusCode: converted.status || (0, _redirectstatus.getRedirectStatus)(route),
|
||||
has: route.has,
|
||||
missing: route.missing,
|
||||
priority: route.internal || undefined
|
||||
};
|
||||
}),
|
||||
headers: routesManifest.headers.map((route)=>{
|
||||
const converted = (0, _routingutils.convertHeaders)([
|
||||
route
|
||||
])[0];
|
||||
const regex = converted.src || route.regex;
|
||||
return {
|
||||
source: route.source,
|
||||
sourceRegex: route.internal ? regex : (0, _redirectstatus.modifyRouteRegex)(regex),
|
||||
headers: 'headers' in converted ? converted.headers || {} : {},
|
||||
has: route.has,
|
||||
missing: route.missing,
|
||||
priority: route.internal || undefined
|
||||
};
|
||||
})
|
||||
},
|
||||
outputs,
|
||||
config,
|
||||
distDir,
|
||||
buildId,
|
||||
nextVersion,
|
||||
projectDir: dir,
|
||||
repoRoot: tracingRoot
|
||||
});
|
||||
} catch (err) {
|
||||
_log.error(`Failed to run onBuildComplete from ${adapterMod.name}`);
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=build-complete.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/adapter/build-complete.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/adapter/build-complete.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
12
apps/public-web/node_modules/next/dist/build/after-production-compile.d.ts
generated
vendored
Normal file
12
apps/public-web/node_modules/next/dist/build/after-production-compile.d.ts
generated
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { Span } from '../trace';
|
||||
import type { Telemetry } from '../telemetry/storage';
|
||||
export declare function runAfterProductionCompile({ config, buildSpan, telemetry, metadata, }: {
|
||||
config: NextConfigComplete;
|
||||
buildSpan: Span;
|
||||
telemetry: Telemetry;
|
||||
metadata: {
|
||||
projectDir: string;
|
||||
distDir: string;
|
||||
};
|
||||
}): Promise<void>;
|
||||
95
apps/public-web/node_modules/next/dist/build/after-production-compile.js
generated
vendored
Normal file
95
apps/public-web/node_modules/next/dist/build/after-production-compile.js
generated
vendored
Normal file
@@ -0,0 +1,95 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "runAfterProductionCompile", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return runAfterProductionCompile;
|
||||
}
|
||||
});
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
|
||||
const _spinner = /*#__PURE__*/ _interop_require_default(require("./spinner"));
|
||||
const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
|
||||
const _build = require("../telemetry/events/build");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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;
|
||||
}
|
||||
async function runAfterProductionCompile({ config, buildSpan, telemetry, metadata }) {
|
||||
const run = config.compiler.runAfterProductionCompile;
|
||||
if (!run) {
|
||||
return;
|
||||
}
|
||||
telemetry.record([
|
||||
{
|
||||
eventName: _build.EVENT_BUILD_FEATURE_USAGE,
|
||||
payload: {
|
||||
featureName: 'runAfterProductionCompile',
|
||||
invocationCount: 1
|
||||
}
|
||||
}
|
||||
]);
|
||||
const afterBuildSpinner = (0, _spinner.default)('Running next.config.js provided runAfterProductionCompile');
|
||||
try {
|
||||
const startTime = performance.now();
|
||||
await buildSpan.traceChild('after-production-compile').traceAsyncFn(async ()=>{
|
||||
await run(metadata);
|
||||
});
|
||||
const duration = performance.now() - startTime;
|
||||
const formattedDuration = `${Math.round(duration)}ms`;
|
||||
_log.event(`Completed runAfterProductionCompile in ${formattedDuration}`);
|
||||
} catch (err) {
|
||||
// Handle specific known errors differently if needed
|
||||
if ((0, _iserror.default)(err)) {
|
||||
_log.error(`Failed to run runAfterProductionCompile: ${err.message}`);
|
||||
}
|
||||
throw err;
|
||||
} finally{
|
||||
afterBuildSpinner == null ? void 0 : afterBuildSpinner.stop();
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=after-production-compile.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/after-production-compile.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/after-production-compile.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/after-production-compile.ts"],"sourcesContent":["import type { NextConfigComplete } from '../server/config-shared'\nimport type { Span } from '../trace'\n\nimport * as Log from './output/log'\nimport createSpinner from './spinner'\nimport isError from '../lib/is-error'\nimport type { Telemetry } from '../telemetry/storage'\nimport { EVENT_BUILD_FEATURE_USAGE } from '../telemetry/events/build'\n\n// TODO: refactor this to account for more compiler lifecycle events\n// such as beforeProductionBuild, but for now this is the only one that is needed\nexport async function runAfterProductionCompile({\n config,\n buildSpan,\n telemetry,\n metadata,\n}: {\n config: NextConfigComplete\n buildSpan: Span\n telemetry: Telemetry\n metadata: {\n projectDir: string\n distDir: string\n }\n}): Promise<void> {\n const run = config.compiler.runAfterProductionCompile\n if (!run) {\n return\n }\n telemetry.record([\n {\n eventName: EVENT_BUILD_FEATURE_USAGE,\n payload: {\n featureName: 'runAfterProductionCompile',\n invocationCount: 1,\n },\n },\n ])\n const afterBuildSpinner = createSpinner(\n 'Running next.config.js provided runAfterProductionCompile'\n )\n\n try {\n const startTime = performance.now()\n await buildSpan\n .traceChild('after-production-compile')\n .traceAsyncFn(async () => {\n await run(metadata)\n })\n const duration = performance.now() - startTime\n const formattedDuration = `${Math.round(duration)}ms`\n Log.event(`Completed runAfterProductionCompile in ${formattedDuration}`)\n } catch (err) {\n // Handle specific known errors differently if needed\n if (isError(err)) {\n Log.error(`Failed to run runAfterProductionCompile: ${err.message}`)\n }\n\n throw err\n } finally {\n afterBuildSpinner?.stop()\n }\n}\n"],"names":["runAfterProductionCompile","config","buildSpan","telemetry","metadata","run","compiler","record","eventName","EVENT_BUILD_FEATURE_USAGE","payload","featureName","invocationCount","afterBuildSpinner","createSpinner","startTime","performance","now","traceChild","traceAsyncFn","duration","formattedDuration","Math","round","Log","event","err","isError","error","message","stop"],"mappings":";;;;+BAWsBA;;;eAAAA;;;6DARD;gEACK;gEACN;uBAEsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAInC,eAAeA,0BAA0B,EAC9CC,MAAM,EACNC,SAAS,EACTC,SAAS,EACTC,QAAQ,EAST;IACC,MAAMC,MAAMJ,OAAOK,QAAQ,CAACN,yBAAyB;IACrD,IAAI,CAACK,KAAK;QACR;IACF;IACAF,UAAUI,MAAM,CAAC;QACf;YACEC,WAAWC,gCAAyB;YACpCC,SAAS;gBACPC,aAAa;gBACbC,iBAAiB;YACnB;QACF;KACD;IACD,MAAMC,oBAAoBC,IAAAA,gBAAa,EACrC;IAGF,IAAI;QACF,MAAMC,YAAYC,YAAYC,GAAG;QACjC,MAAMf,UACHgB,UAAU,CAAC,4BACXC,YAAY,CAAC;YACZ,MAAMd,IAAID;QACZ;QACF,MAAMgB,WAAWJ,YAAYC,GAAG,KAAKF;QACrC,MAAMM,oBAAoB,GAAGC,KAAKC,KAAK,CAACH,UAAU,EAAE,CAAC;QACrDI,KAAIC,KAAK,CAAC,CAAC,uCAAuC,EAAEJ,mBAAmB;IACzE,EAAE,OAAOK,KAAK;QACZ,qDAAqD;QACrD,IAAIC,IAAAA,gBAAO,EAACD,MAAM;YAChBF,KAAII,KAAK,CAAC,CAAC,yCAAyC,EAAEF,IAAIG,OAAO,EAAE;QACrE;QAEA,MAAMH;IACR,SAAU;QACRb,qCAAAA,kBAAmBiB,IAAI;IACzB;AACF","ignoreList":[0]}
|
||||
23
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.d.ts
generated
vendored
Normal file
23
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.d.ts
generated
vendored
Normal file
@@ -0,0 +1,23 @@
|
||||
import type { Module } from '@swc/core';
|
||||
export declare class NoSuchDeclarationError extends Error {
|
||||
}
|
||||
export declare class UnsupportedValueError extends Error {
|
||||
/** @example `config.runtime[0].value` */
|
||||
path?: string;
|
||||
constructor(message: string, paths?: string[]);
|
||||
}
|
||||
/**
|
||||
* Extracts the value of an exported const variable named `exportedName`
|
||||
* (e.g. "export const config = { runtime: 'edge' }") from swc's AST.
|
||||
* The value must be one of (or throws UnsupportedValueError):
|
||||
* - string
|
||||
* - boolean
|
||||
* - number
|
||||
* - null
|
||||
* - undefined
|
||||
* - array containing values listed in this list
|
||||
* - object containing values listed in this list
|
||||
*
|
||||
* Throws NoSuchDeclarationError if the declaration is not found.
|
||||
*/
|
||||
export declare function extractExportedConstValue(module: Module, exportedName: string): any;
|
||||
205
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.js
generated
vendored
Normal file
205
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.js
generated
vendored
Normal file
@@ -0,0 +1,205 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
NoSuchDeclarationError: null,
|
||||
UnsupportedValueError: null,
|
||||
extractExportedConstValue: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
NoSuchDeclarationError: function() {
|
||||
return NoSuchDeclarationError;
|
||||
},
|
||||
UnsupportedValueError: function() {
|
||||
return UnsupportedValueError;
|
||||
},
|
||||
extractExportedConstValue: function() {
|
||||
return extractExportedConstValue;
|
||||
}
|
||||
});
|
||||
class NoSuchDeclarationError extends Error {
|
||||
}
|
||||
function isExportDeclaration(node) {
|
||||
return node.type === 'ExportDeclaration';
|
||||
}
|
||||
function isVariableDeclaration(node) {
|
||||
return node.type === 'VariableDeclaration';
|
||||
}
|
||||
function isIdentifier(node) {
|
||||
return node.type === 'Identifier';
|
||||
}
|
||||
function isBooleanLiteral(node) {
|
||||
return node.type === 'BooleanLiteral';
|
||||
}
|
||||
function isNullLiteral(node) {
|
||||
return node.type === 'NullLiteral';
|
||||
}
|
||||
function isStringLiteral(node) {
|
||||
return node.type === 'StringLiteral';
|
||||
}
|
||||
function isNumericLiteral(node) {
|
||||
return node.type === 'NumericLiteral';
|
||||
}
|
||||
function isArrayExpression(node) {
|
||||
return node.type === 'ArrayExpression';
|
||||
}
|
||||
function isObjectExpression(node) {
|
||||
return node.type === 'ObjectExpression';
|
||||
}
|
||||
function isKeyValueProperty(node) {
|
||||
return node.type === 'KeyValueProperty';
|
||||
}
|
||||
function isRegExpLiteral(node) {
|
||||
return node.type === 'RegExpLiteral';
|
||||
}
|
||||
function isTemplateLiteral(node) {
|
||||
return node.type === 'TemplateLiteral';
|
||||
}
|
||||
function isTsSatisfiesExpression(node) {
|
||||
return node.type === 'TsSatisfiesExpression';
|
||||
}
|
||||
class UnsupportedValueError extends Error {
|
||||
constructor(message, paths){
|
||||
super(message);
|
||||
// Generating "path" that looks like "config.runtime[0].value"
|
||||
let codePath;
|
||||
if (paths) {
|
||||
codePath = '';
|
||||
for (const path of paths){
|
||||
if (path[0] === '[') {
|
||||
// "array" + "[0]"
|
||||
codePath += path;
|
||||
} else {
|
||||
if (codePath === '') {
|
||||
codePath = path;
|
||||
} else {
|
||||
// "object" + ".key"
|
||||
codePath += `.${path}`;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
this.path = codePath;
|
||||
}
|
||||
}
|
||||
function extractValue(node, path) {
|
||||
if (isNullLiteral(node)) {
|
||||
return null;
|
||||
} else if (isBooleanLiteral(node)) {
|
||||
// e.g. true / false
|
||||
return node.value;
|
||||
} else if (isStringLiteral(node)) {
|
||||
// e.g. "abc"
|
||||
return node.value;
|
||||
} else if (isNumericLiteral(node)) {
|
||||
// e.g. 123
|
||||
return node.value;
|
||||
} else if (isRegExpLiteral(node)) {
|
||||
// e.g. /abc/i
|
||||
return new RegExp(node.pattern, node.flags);
|
||||
} else if (isIdentifier(node)) {
|
||||
switch(node.value){
|
||||
case 'undefined':
|
||||
return undefined;
|
||||
default:
|
||||
throw new UnsupportedValueError(`Unknown identifier "${node.value}"`, path);
|
||||
}
|
||||
} else if (isArrayExpression(node)) {
|
||||
// e.g. [1, 2, 3]
|
||||
const arr = [];
|
||||
for(let i = 0, len = node.elements.length; i < len; i++){
|
||||
const elem = node.elements[i];
|
||||
if (elem) {
|
||||
if (elem.spread) {
|
||||
// e.g. [ ...a ]
|
||||
throw new UnsupportedValueError('Unsupported spread operator in the Array Expression', path);
|
||||
}
|
||||
arr.push(extractValue(elem.expression, path && [
|
||||
...path,
|
||||
`[${i}]`
|
||||
]));
|
||||
} else {
|
||||
// e.g. [1, , 2]
|
||||
// ^^
|
||||
arr.push(undefined);
|
||||
}
|
||||
}
|
||||
return arr;
|
||||
} else if (isObjectExpression(node)) {
|
||||
// e.g. { a: 1, b: 2 }
|
||||
const obj = {};
|
||||
for (const prop of node.properties){
|
||||
if (!isKeyValueProperty(prop)) {
|
||||
// e.g. { ...a }
|
||||
throw new UnsupportedValueError('Unsupported spread operator in the Object Expression', path);
|
||||
}
|
||||
let key;
|
||||
if (isIdentifier(prop.key)) {
|
||||
// e.g. { a: 1, b: 2 }
|
||||
key = prop.key.value;
|
||||
} else if (isStringLiteral(prop.key)) {
|
||||
// e.g. { "a": 1, "b": 2 }
|
||||
key = prop.key.value;
|
||||
} else {
|
||||
throw new UnsupportedValueError(`Unsupported key type "${prop.key.type}" in the Object Expression`, path);
|
||||
}
|
||||
obj[key] = extractValue(prop.value, path && [
|
||||
...path,
|
||||
key
|
||||
]);
|
||||
}
|
||||
return obj;
|
||||
} else if (isTemplateLiteral(node)) {
|
||||
// e.g. `abc`
|
||||
if (node.expressions.length !== 0) {
|
||||
// TODO: should we add support for `${'e'}d${'g'}'e'`?
|
||||
throw new UnsupportedValueError('Unsupported template literal with expressions', path);
|
||||
}
|
||||
// When TemplateLiteral has 0 expressions, the length of quasis is always 1.
|
||||
// Because when parsing TemplateLiteral, the parser yields the first quasi,
|
||||
// then the first expression, then the next quasi, then the next expression, etc.,
|
||||
// until the last quasi.
|
||||
// Thus if there is no expression, the parser ends at the frst and also last quasis
|
||||
//
|
||||
// A "cooked" interpretation where backslashes have special meaning, while a
|
||||
// "raw" interpretation where backslashes do not have special meaning
|
||||
// https://exploringjs.com/impatient-js/ch_template-literals.html#template-strings-cooked-vs-raw
|
||||
const [{ cooked, raw }] = node.quasis;
|
||||
return cooked ?? raw;
|
||||
} else if (isTsSatisfiesExpression(node)) {
|
||||
return extractValue(node.expression);
|
||||
} else {
|
||||
throw new UnsupportedValueError(`Unsupported node type "${node.type}"`, path);
|
||||
}
|
||||
}
|
||||
function extractExportedConstValue(module1, exportedName) {
|
||||
for (const moduleItem of module1.body){
|
||||
if (!isExportDeclaration(moduleItem)) {
|
||||
continue;
|
||||
}
|
||||
const declaration = moduleItem.declaration;
|
||||
if (!isVariableDeclaration(declaration)) {
|
||||
continue;
|
||||
}
|
||||
if (declaration.kind !== 'const') {
|
||||
continue;
|
||||
}
|
||||
for (const decl of declaration.declarations){
|
||||
if (isIdentifier(decl.id) && decl.id.value === exportedName && decl.init) {
|
||||
return extractValue(decl.init, [
|
||||
exportedName
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new NoSuchDeclarationError();
|
||||
}
|
||||
|
||||
//# sourceMappingURL=extract-const-value.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/analysis/extract-const-value.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
82
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.d.ts
generated
vendored
Normal file
82
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.d.ts
generated
vendored
Normal file
@@ -0,0 +1,82 @@
|
||||
import type { NextConfig } from '../../server/config-shared';
|
||||
import type { RouteHas } from '../../lib/load-custom-routes';
|
||||
import type { RSCMeta } from '../webpack/loaders/get-module-build-info';
|
||||
import { PAGE_TYPES } from '../../lib/page-types';
|
||||
import { type AppSegmentConfig } from '../segment-config/app/app-segment-config';
|
||||
import { type PagesSegmentConfig, type PagesSegmentConfigConfig } from '../segment-config/pages/pages-segment-config';
|
||||
export type ProxyMatcher = {
|
||||
regexp: string;
|
||||
locale?: false;
|
||||
has?: RouteHas[];
|
||||
missing?: RouteHas[];
|
||||
originalSource: string;
|
||||
};
|
||||
export type ProxyConfig = {
|
||||
/**
|
||||
* The matcher for the proxy. Read more: [Next.js Docs: Proxy `matcher`](https://nextjs.org/docs/app/api-reference/file-conventions/proxy#matcher),
|
||||
* [Next.js Docs: Proxy matching paths](https://nextjs.org/docs/app/building-your-application/routing/proxy#matching-paths)
|
||||
*/
|
||||
matchers?: ProxyMatcher[];
|
||||
/**
|
||||
* The regions that the proxy should run in.
|
||||
*/
|
||||
regions?: string | string[];
|
||||
/**
|
||||
* A glob, or an array of globs, ignoring dynamic code evaluation for specific
|
||||
* files. The globs are relative to your application root folder.
|
||||
*/
|
||||
unstable_allowDynamic?: string[];
|
||||
};
|
||||
export interface AppPageStaticInfo {
|
||||
type: PAGE_TYPES.APP;
|
||||
ssg?: boolean;
|
||||
ssr?: boolean;
|
||||
rsc?: RSCModuleType;
|
||||
generateStaticParams?: boolean;
|
||||
generateSitemaps?: boolean;
|
||||
generateImageMetadata?: boolean;
|
||||
middleware?: ProxyConfig;
|
||||
config: Omit<AppSegmentConfig, 'runtime' | 'maxDuration'> | undefined;
|
||||
runtime: AppSegmentConfig['runtime'] | undefined;
|
||||
preferredRegion: AppSegmentConfig['preferredRegion'] | undefined;
|
||||
maxDuration: number | undefined;
|
||||
hadUnsupportedValue: boolean;
|
||||
}
|
||||
export interface PagesPageStaticInfo {
|
||||
type: PAGE_TYPES.PAGES;
|
||||
getStaticProps?: boolean;
|
||||
getServerSideProps?: boolean;
|
||||
rsc?: RSCModuleType;
|
||||
generateStaticParams?: boolean;
|
||||
generateSitemaps?: boolean;
|
||||
generateImageMetadata?: boolean;
|
||||
middleware?: ProxyConfig;
|
||||
config: (Omit<PagesSegmentConfig, 'runtime' | 'config' | 'maxDuration'> & {
|
||||
config?: Omit<PagesSegmentConfigConfig, 'runtime' | 'maxDuration'>;
|
||||
}) | undefined;
|
||||
runtime: PagesSegmentConfig['runtime'] | undefined;
|
||||
preferredRegion: PagesSegmentConfigConfig['regions'] | undefined;
|
||||
maxDuration: number | undefined;
|
||||
hadUnsupportedValue: boolean;
|
||||
}
|
||||
export type PageStaticInfo = AppPageStaticInfo | PagesPageStaticInfo;
|
||||
export type RSCModuleType = 'server' | 'client';
|
||||
export declare function getRSCModuleInformation(source: string, isReactServerLayer: boolean): RSCMeta;
|
||||
type GetPageStaticInfoParams = {
|
||||
pageFilePath: string;
|
||||
nextConfig: Partial<NextConfig>;
|
||||
isDev: boolean;
|
||||
page: string;
|
||||
pageType: PAGE_TYPES;
|
||||
};
|
||||
export declare function getAppPageStaticInfo({ pageFilePath, nextConfig, isDev, page, }: GetPageStaticInfoParams): Promise<AppPageStaticInfo>;
|
||||
export declare function getPagesPageStaticInfo({ pageFilePath, nextConfig, isDev, page, }: GetPageStaticInfoParams): Promise<PagesPageStaticInfo>;
|
||||
/**
|
||||
* For a given pageFilePath and nextConfig, if the config supports it, this
|
||||
* function will read the file and return the runtime that should be used.
|
||||
* It will look into the file content only if the page *requires* a runtime
|
||||
* to be specified, that is, when gSSP or gSP is used.
|
||||
* Related discussion: https://github.com/vercel/next.js/discussions/34179
|
||||
*/
|
||||
export declare function getPageStaticInfo(params: GetPageStaticInfoParams): Promise<PageStaticInfo>;
|
||||
export {};
|
||||
601
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.js
generated
vendored
Normal file
601
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.js
generated
vendored
Normal file
@@ -0,0 +1,601 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
getAppPageStaticInfo: null,
|
||||
getMiddlewareMatchers: null,
|
||||
getPageStaticInfo: null,
|
||||
getPagesPageStaticInfo: null,
|
||||
getRSCModuleInformation: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
getAppPageStaticInfo: function() {
|
||||
return getAppPageStaticInfo;
|
||||
},
|
||||
getMiddlewareMatchers: function() {
|
||||
return getMiddlewareMatchers;
|
||||
},
|
||||
getPageStaticInfo: function() {
|
||||
return getPageStaticInfo;
|
||||
},
|
||||
getPagesPageStaticInfo: function() {
|
||||
return getPagesPageStaticInfo;
|
||||
},
|
||||
getRSCModuleInformation: function() {
|
||||
return getRSCModuleInformation;
|
||||
}
|
||||
});
|
||||
const _fs = require("fs");
|
||||
const _path = require("path");
|
||||
const _lrucache = require("../../server/lib/lru-cache");
|
||||
const _extractconstvalue = require("./extract-const-value");
|
||||
const _parsemodule = require("./parse-module");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
|
||||
const _constants = require("../../lib/constants");
|
||||
const _trytoparsepath = require("../../lib/try-to-parse-path");
|
||||
const _isapiroute = require("../../lib/is-api-route");
|
||||
const _isedgeruntime = require("../../lib/is-edge-runtime");
|
||||
const _constants1 = require("../../shared/lib/constants");
|
||||
const _pagetypes = require("../../lib/page-types");
|
||||
const _appsegmentconfig = require("../segment-config/app/app-segment-config");
|
||||
const _zod = require("../../shared/lib/zod");
|
||||
const _pagessegmentconfig = require("../segment-config/pages/pages-segment-config");
|
||||
const _middlewareconfig = require("../segment-config/middleware/middleware-config");
|
||||
const _apppaths = require("../../shared/lib/router/utils/app-paths");
|
||||
const _normalizepagepath = require("../../shared/lib/page-path/normalize-page-path");
|
||||
const _utils = require("../utils");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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 PARSE_PATTERN = /(?<!(_jsx|jsx-))runtime|preferredRegion|getStaticProps|getServerSideProps|generateStaticParams|export const|generateImageMetadata|generateSitemaps|middleware|proxy/;
|
||||
const CLIENT_MODULE_LABEL = /\/\* __next_internal_client_entry_do_not_use__ ([^ ]*) (cjs|auto) \*\//;
|
||||
const ACTION_MODULE_LABEL = /\/\* __next_internal_action_entry_do_not_use__ (\{[^}]+\}) \*\//;
|
||||
const CLIENT_DIRECTIVE = 'use client';
|
||||
const SERVER_ACTION_DIRECTIVE = 'use server';
|
||||
function getRSCModuleInformation(source, isReactServerLayer) {
|
||||
const actionsJson = source.match(ACTION_MODULE_LABEL);
|
||||
const parsedActionsMeta = actionsJson ? JSON.parse(actionsJson[1]) : undefined;
|
||||
const clientInfoMatch = source.match(CLIENT_MODULE_LABEL);
|
||||
const isClientRef = !!clientInfoMatch;
|
||||
if (!isReactServerLayer) {
|
||||
return {
|
||||
type: _constants1.RSC_MODULE_TYPES.client,
|
||||
actionIds: parsedActionsMeta,
|
||||
isClientRef
|
||||
};
|
||||
}
|
||||
const clientRefsString = clientInfoMatch == null ? void 0 : clientInfoMatch[1];
|
||||
const clientRefs = clientRefsString ? clientRefsString.split(',') : [];
|
||||
const clientEntryType = clientInfoMatch == null ? void 0 : clientInfoMatch[2];
|
||||
const type = clientInfoMatch ? _constants1.RSC_MODULE_TYPES.client : _constants1.RSC_MODULE_TYPES.server;
|
||||
return {
|
||||
type,
|
||||
actionIds: parsedActionsMeta,
|
||||
clientRefs,
|
||||
clientEntryType,
|
||||
isClientRef
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Receives a parsed AST from SWC and checks if it belongs to a module that
|
||||
* requires a runtime to be specified. Those are:
|
||||
* - Modules with `export function getStaticProps | getServerSideProps`
|
||||
* - Modules with `export { getStaticProps | getServerSideProps } <from ...>`
|
||||
* - Modules with `export const runtime = ...`
|
||||
*/ function checkExports(ast, expectedExports, page) {
|
||||
const exportsSet = new Set([
|
||||
'getStaticProps',
|
||||
'getServerSideProps',
|
||||
'generateImageMetadata',
|
||||
'generateSitemaps',
|
||||
'generateStaticParams'
|
||||
]);
|
||||
if (!Array.isArray(ast == null ? void 0 : ast.body)) {
|
||||
return {};
|
||||
}
|
||||
try {
|
||||
let getStaticProps = false;
|
||||
let getServerSideProps = false;
|
||||
let generateImageMetadata = false;
|
||||
let generateSitemaps = false;
|
||||
let generateStaticParams = false;
|
||||
let exports1 = new Set();
|
||||
let directives = new Set();
|
||||
let hasLeadingNonDirectiveNode = false;
|
||||
for (const node of ast.body){
|
||||
var _node_declaration, _node_declaration1, _node_declaration_identifier, _node_declaration2;
|
||||
// There should be no non-string literals nodes before directives
|
||||
if (node.type === 'ExpressionStatement' && node.expression.type === 'StringLiteral') {
|
||||
if (!hasLeadingNonDirectiveNode) {
|
||||
const directive = node.expression.value;
|
||||
if (CLIENT_DIRECTIVE === directive) {
|
||||
directives.add('client');
|
||||
}
|
||||
if (SERVER_ACTION_DIRECTIVE === directive) {
|
||||
directives.add('server');
|
||||
}
|
||||
}
|
||||
} else {
|
||||
hasLeadingNonDirectiveNode = true;
|
||||
}
|
||||
if (node.type === 'ExportDeclaration' && ((_node_declaration = node.declaration) == null ? void 0 : _node_declaration.type) === 'VariableDeclaration') {
|
||||
var _node_declaration3;
|
||||
for (const declaration of (_node_declaration3 = node.declaration) == null ? void 0 : _node_declaration3.declarations){
|
||||
if (expectedExports.includes(declaration.id.value)) {
|
||||
exports1.add(declaration.id.value);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (node.type === 'ExportDeclaration' && ((_node_declaration1 = node.declaration) == null ? void 0 : _node_declaration1.type) === 'FunctionDeclaration' && exportsSet.has((_node_declaration_identifier = node.declaration.identifier) == null ? void 0 : _node_declaration_identifier.value)) {
|
||||
const id = node.declaration.identifier.value;
|
||||
getServerSideProps = id === 'getServerSideProps';
|
||||
getStaticProps = id === 'getStaticProps';
|
||||
generateImageMetadata = id === 'generateImageMetadata';
|
||||
generateSitemaps = id === 'generateSitemaps';
|
||||
generateStaticParams = id === 'generateStaticParams';
|
||||
}
|
||||
if (node.type === 'ExportDeclaration' && ((_node_declaration2 = node.declaration) == null ? void 0 : _node_declaration2.type) === 'VariableDeclaration') {
|
||||
var _node_declaration_declarations_, _node_declaration4;
|
||||
const id = (_node_declaration4 = node.declaration) == null ? void 0 : (_node_declaration_declarations_ = _node_declaration4.declarations[0]) == null ? void 0 : _node_declaration_declarations_.id.value;
|
||||
if (exportsSet.has(id)) {
|
||||
getServerSideProps = id === 'getServerSideProps';
|
||||
getStaticProps = id === 'getStaticProps';
|
||||
generateImageMetadata = id === 'generateImageMetadata';
|
||||
generateSitemaps = id === 'generateSitemaps';
|
||||
generateStaticParams = id === 'generateStaticParams';
|
||||
}
|
||||
}
|
||||
if (node.type === 'ExportNamedDeclaration') {
|
||||
for (const specifier of node.specifiers){
|
||||
var _specifier_orig;
|
||||
if (specifier.type === 'ExportSpecifier' && ((_specifier_orig = specifier.orig) == null ? void 0 : _specifier_orig.type) === 'Identifier') {
|
||||
const value = specifier.orig.value;
|
||||
if (!getServerSideProps && value === 'getServerSideProps') {
|
||||
getServerSideProps = true;
|
||||
}
|
||||
if (!getStaticProps && value === 'getStaticProps') {
|
||||
getStaticProps = true;
|
||||
}
|
||||
if (!generateImageMetadata && value === 'generateImageMetadata') {
|
||||
generateImageMetadata = true;
|
||||
}
|
||||
if (!generateSitemaps && value === 'generateSitemaps') {
|
||||
generateSitemaps = true;
|
||||
}
|
||||
if (!generateStaticParams && value === 'generateStaticParams') {
|
||||
generateStaticParams = true;
|
||||
}
|
||||
if (expectedExports.includes(value) && !exports1.has(value)) {
|
||||
// An export was found that was actually a re-export, and not a
|
||||
// literal value. We should warn here.
|
||||
_log.warn(`Next.js can't recognize the exported \`${value}\` field in "${page}", it may be re-exported from another file. The default config will be used instead.`);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return {
|
||||
getStaticProps,
|
||||
getServerSideProps,
|
||||
generateImageMetadata,
|
||||
generateSitemaps,
|
||||
generateStaticParams,
|
||||
directives,
|
||||
exports: exports1
|
||||
};
|
||||
} catch {}
|
||||
return {};
|
||||
}
|
||||
function validateMiddlewareProxyExports({ ast, page, pageFilePath, isDev }) {
|
||||
// Check if this is middleware/proxy
|
||||
const isMiddleware = page === `/${_constants.MIDDLEWARE_FILENAME}` || page === `/src/${_constants.MIDDLEWARE_FILENAME}`;
|
||||
const isProxy = page === `/${_constants.PROXY_FILENAME}` || page === `/src/${_constants.PROXY_FILENAME}`;
|
||||
if (!isMiddleware && !isProxy) {
|
||||
return;
|
||||
}
|
||||
if (!ast || !Array.isArray(ast.body)) {
|
||||
return;
|
||||
}
|
||||
const fileName = isProxy ? _constants.PROXY_FILENAME : _constants.MIDDLEWARE_FILENAME;
|
||||
// Parse AST to get export info (since checkExports doesn't return middleware/proxy info)
|
||||
let hasDefaultExport = false;
|
||||
let hasMiddlewareExport = false;
|
||||
let hasProxyExport = false;
|
||||
for (const node of ast.body){
|
||||
var _node_declaration, _node_declaration1;
|
||||
if (node.type === 'ExportDefaultDeclaration' || node.type === 'ExportDefaultExpression') {
|
||||
hasDefaultExport = true;
|
||||
}
|
||||
if (node.type === 'ExportDeclaration' && ((_node_declaration = node.declaration) == null ? void 0 : _node_declaration.type) === 'FunctionDeclaration') {
|
||||
var _node_declaration_identifier;
|
||||
const id = (_node_declaration_identifier = node.declaration.identifier) == null ? void 0 : _node_declaration_identifier.value;
|
||||
if (id === 'middleware') {
|
||||
hasMiddlewareExport = true;
|
||||
}
|
||||
if (id === 'proxy') {
|
||||
hasProxyExport = true;
|
||||
}
|
||||
}
|
||||
if (node.type === 'ExportDeclaration' && ((_node_declaration1 = node.declaration) == null ? void 0 : _node_declaration1.type) === 'VariableDeclaration') {
|
||||
var _node_declaration_declarations_, _node_declaration2;
|
||||
const id = (_node_declaration2 = node.declaration) == null ? void 0 : (_node_declaration_declarations_ = _node_declaration2.declarations[0]) == null ? void 0 : _node_declaration_declarations_.id.value;
|
||||
if (id === 'middleware') {
|
||||
hasMiddlewareExport = true;
|
||||
}
|
||||
if (id === 'proxy') {
|
||||
hasProxyExport = true;
|
||||
}
|
||||
}
|
||||
if (node.type === 'ExportNamedDeclaration') {
|
||||
for (const specifier of node.specifiers){
|
||||
var _specifier_orig;
|
||||
if (specifier.type === 'ExportSpecifier' && ((_specifier_orig = specifier.orig) == null ? void 0 : _specifier_orig.type) === 'Identifier') {
|
||||
// Use the exported name if it exists (for aliased exports like `export { foo as proxy }`),
|
||||
// otherwise fall back to the original name (for simple re-exports like `export { proxy }`)
|
||||
const exportedIdentifier = specifier.exported || specifier.orig;
|
||||
const value = exportedIdentifier.value;
|
||||
if (value === 'middleware') {
|
||||
hasMiddlewareExport = true;
|
||||
}
|
||||
if (value === 'proxy') {
|
||||
hasProxyExport = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const hasValidExport = hasDefaultExport || isMiddleware && hasMiddlewareExport || isProxy && hasProxyExport;
|
||||
const relativePath = (0, _path.relative)(process.cwd(), pageFilePath);
|
||||
const resolvedPath = relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
|
||||
if (!hasValidExport) {
|
||||
const message = `The file "${resolvedPath}" must export a function, either as a default export or as a named "${fileName}" export.\n` + `This function is what Next.js runs for every request handled by this ${fileName === 'proxy' ? 'proxy (previously called middleware)' : 'middleware'}.\n\n` + `Why this happens:\n` + (isProxy ? "- You are migrating from `middleware` to `proxy`, but haven't updated the exported function.\n" : '') + `- The file exists but doesn't export a function.\n` + `- The export is not a function (e.g., an object or constant).\n` + `- There's a syntax error preventing the export from being recognized.\n\n` + `To fix it:\n` + `- Ensure this file has either a default or "${fileName}" function export.\n\n` + `Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`;
|
||||
if (isDev) {
|
||||
// errorOnce as proxy/middleware runs per request including multiple
|
||||
// internal _next/ routes and spams logs.
|
||||
_log.errorOnce(message);
|
||||
} else {
|
||||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
async function tryToReadFile(filePath, shouldThrow) {
|
||||
try {
|
||||
return await _fs.promises.readFile(filePath, {
|
||||
encoding: 'utf8'
|
||||
});
|
||||
} catch (error) {
|
||||
if (shouldThrow) {
|
||||
error.message = `Next.js ERROR: Failed to read file ${filePath}:\n${error.message}`;
|
||||
throw error;
|
||||
}
|
||||
}
|
||||
}
|
||||
function getMiddlewareMatchers(matcherOrMatchers, nextConfig) {
|
||||
const matchers = Array.isArray(matcherOrMatchers) ? matcherOrMatchers : [
|
||||
matcherOrMatchers
|
||||
];
|
||||
const { i18n } = nextConfig;
|
||||
return matchers.map((matcher)=>{
|
||||
matcher = typeof matcher === 'string' ? {
|
||||
source: matcher
|
||||
} : matcher;
|
||||
const originalSource = matcher.source;
|
||||
let { source, ...rest } = matcher;
|
||||
const isRoot = source === '/';
|
||||
if ((i18n == null ? void 0 : i18n.locales) && matcher.locale !== false) {
|
||||
source = `/:nextInternalLocale((?!_next/)[^/.]{1,})${isRoot ? '' : source}`;
|
||||
}
|
||||
source = `/:nextData(_next/data/[^/]{1,})?${source}${isRoot ? `(${nextConfig.i18n ? '|\\.json|' : ''}/?index|/?index\\.json)?` : '{(\\.json)}?'}`;
|
||||
if (nextConfig.basePath) {
|
||||
source = `${nextConfig.basePath}${source}`;
|
||||
}
|
||||
// Validate that the source is still.
|
||||
const result = _middlewareconfig.SourceSchema.safeParse(source);
|
||||
if (!result.success) {
|
||||
(0, _zod.reportZodError)('Failed to parse middleware source', result.error);
|
||||
// We need to exit here because middleware being built occurs before we
|
||||
// finish setting up the server. Exiting here is the only way to ensure
|
||||
// that we don't hang.
|
||||
process.exit(1);
|
||||
}
|
||||
return {
|
||||
...rest,
|
||||
// We know that parsed.regexStr is not undefined because we already
|
||||
// checked that the source is valid.
|
||||
regexp: (0, _trytoparsepath.tryToParsePath)(result.data).regexStr,
|
||||
originalSource: originalSource || source
|
||||
};
|
||||
});
|
||||
}
|
||||
function parseMiddlewareConfig(page, rawConfig, nextConfig) {
|
||||
// If there's no config to parse, then return nothing.
|
||||
if (typeof rawConfig !== 'object' || !rawConfig) return {};
|
||||
const input = _middlewareconfig.MiddlewareConfigInputSchema.safeParse(rawConfig);
|
||||
if (!input.success) {
|
||||
(0, _zod.reportZodError)(`${page} contains invalid middleware config`, input.error);
|
||||
// We need to exit here because middleware being built occurs before we
|
||||
// finish setting up the server. Exiting here is the only way to ensure
|
||||
// that we don't hang.
|
||||
process.exit(1);
|
||||
}
|
||||
const config = {};
|
||||
if (input.data.matcher) {
|
||||
config.matchers = getMiddlewareMatchers(input.data.matcher, nextConfig);
|
||||
}
|
||||
if (input.data.unstable_allowDynamic) {
|
||||
config.unstable_allowDynamic = Array.isArray(input.data.unstable_allowDynamic) ? input.data.unstable_allowDynamic : [
|
||||
input.data.unstable_allowDynamic
|
||||
];
|
||||
}
|
||||
if (input.data.regions) {
|
||||
config.regions = input.data.regions;
|
||||
}
|
||||
return config;
|
||||
}
|
||||
const apiRouteWarnings = new _lrucache.LRUCache(250);
|
||||
function warnAboutExperimentalEdge(apiRoute) {
|
||||
if (process.env.NODE_ENV === 'production' && process.env.NEXT_PRIVATE_BUILD_WORKER === '1') {
|
||||
return;
|
||||
}
|
||||
if (apiRoute && apiRouteWarnings.has(apiRoute)) {
|
||||
return;
|
||||
}
|
||||
_log.warn(apiRoute ? `${apiRoute} provided runtime 'experimental-edge'. It can be updated to 'edge' instead.` : `You are using an experimental edge runtime, the API might change.`);
|
||||
if (apiRoute) {
|
||||
apiRouteWarnings.set(apiRoute, 1);
|
||||
}
|
||||
}
|
||||
let hadUnsupportedValue = false;
|
||||
const warnedUnsupportedValueMap = new _lrucache.LRUCache(250, ()=>1);
|
||||
function warnAboutUnsupportedValue(pageFilePath, page, error) {
|
||||
hadUnsupportedValue = true;
|
||||
const isProductionBuild = process.env.NODE_ENV === 'production';
|
||||
if (// we only log for the server compilation so it's not
|
||||
// duplicated due to webpack build worker having fresh
|
||||
// module scope for each compiler
|
||||
process.env.NEXT_COMPILER_NAME !== 'server' || isProductionBuild && warnedUnsupportedValueMap.has(pageFilePath)) {
|
||||
return;
|
||||
}
|
||||
warnedUnsupportedValueMap.set(pageFilePath, true);
|
||||
const message = `Next.js can't recognize the exported \`config\` field in ` + (page ? `route "${page}"` : `"${pageFilePath}"`) + ':\n' + error.message + (error.path ? ` at "${error.path}"` : '') + '.\n' + 'Read More - https://nextjs.org/docs/messages/invalid-page-config';
|
||||
// for a build we use `Log.error` instead of throwing
|
||||
// so that all errors can be logged before exiting the process
|
||||
if (isProductionBuild) {
|
||||
_log.error(message);
|
||||
} else {
|
||||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
async function getAppPageStaticInfo({ pageFilePath, nextConfig, isDev, page }) {
|
||||
const content = await tryToReadFile(pageFilePath, !isDev);
|
||||
if (!content || !PARSE_PATTERN.test(content)) {
|
||||
return {
|
||||
type: _pagetypes.PAGE_TYPES.APP,
|
||||
config: undefined,
|
||||
runtime: undefined,
|
||||
preferredRegion: undefined,
|
||||
maxDuration: undefined,
|
||||
hadUnsupportedValue: false
|
||||
};
|
||||
}
|
||||
const ast = await (0, _parsemodule.parseModule)(pageFilePath, content);
|
||||
validateMiddlewareProxyExports({
|
||||
ast,
|
||||
page,
|
||||
pageFilePath,
|
||||
isDev
|
||||
});
|
||||
const { generateStaticParams, generateImageMetadata, generateSitemaps, exports: exports1, directives } = checkExports(ast, _appsegmentconfig.AppSegmentConfigSchemaKeys, page);
|
||||
const { type: rsc } = getRSCModuleInformation(content, true);
|
||||
const exportedConfig = {};
|
||||
if (exports1) {
|
||||
for (const property of exports1){
|
||||
try {
|
||||
exportedConfig[property] = (0, _extractconstvalue.extractExportedConstValue)(ast, property);
|
||||
} catch (e) {
|
||||
if (e instanceof _extractconstvalue.UnsupportedValueError) {
|
||||
warnAboutUnsupportedValue(pageFilePath, page, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
exportedConfig.config = (0, _extractconstvalue.extractExportedConstValue)(ast, 'config');
|
||||
} catch (e) {
|
||||
if (e instanceof _extractconstvalue.UnsupportedValueError) {
|
||||
warnAboutUnsupportedValue(pageFilePath, page, e);
|
||||
}
|
||||
// `export config` doesn't exist, or other unknown error thrown by swc, silence them
|
||||
}
|
||||
const route = (0, _apppaths.normalizeAppPath)(page);
|
||||
const config = (0, _appsegmentconfig.parseAppSegmentConfig)(exportedConfig, route);
|
||||
// Prevent edge runtime and generateStaticParams in the same file.
|
||||
if ((0, _isedgeruntime.isEdgeRuntime)(config.runtime) && generateStaticParams) {
|
||||
throw Object.defineProperty(new Error(`Page "${page}" cannot use both \`export const runtime = 'edge'\` and export \`generateStaticParams\`.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E42",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
// Prevent use client and generateStaticParams in the same file.
|
||||
if ((directives == null ? void 0 : directives.has('client')) && generateStaticParams) {
|
||||
throw Object.defineProperty(new Error(`Page "${page}" cannot use both "use client" and export function "generateStaticParams()".`), "__NEXT_ERROR_CODE", {
|
||||
value: "E475",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if ('unstable_prefetch' in config && !nextConfig.cacheComponents) {
|
||||
throw Object.defineProperty(new Error(`Page "${page}" cannot use \`export const unstable_prefetch = ...\` without enabling \`cacheComponents\`.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E905",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return {
|
||||
type: _pagetypes.PAGE_TYPES.APP,
|
||||
rsc,
|
||||
generateImageMetadata,
|
||||
generateSitemaps,
|
||||
generateStaticParams,
|
||||
config,
|
||||
middleware: parseMiddlewareConfig(page, exportedConfig.config, nextConfig),
|
||||
runtime: config.runtime,
|
||||
preferredRegion: config.preferredRegion,
|
||||
maxDuration: config.maxDuration,
|
||||
hadUnsupportedValue
|
||||
};
|
||||
}
|
||||
async function getPagesPageStaticInfo({ pageFilePath, nextConfig, isDev, page }) {
|
||||
var _config_config, _config_config1, _config_config2;
|
||||
const content = await tryToReadFile(pageFilePath, !isDev);
|
||||
if (!content || !PARSE_PATTERN.test(content)) {
|
||||
return {
|
||||
type: _pagetypes.PAGE_TYPES.PAGES,
|
||||
config: undefined,
|
||||
runtime: undefined,
|
||||
preferredRegion: undefined,
|
||||
maxDuration: undefined,
|
||||
hadUnsupportedValue: false
|
||||
};
|
||||
}
|
||||
const ast = await (0, _parsemodule.parseModule)(pageFilePath, content);
|
||||
validateMiddlewareProxyExports({
|
||||
ast,
|
||||
page,
|
||||
pageFilePath,
|
||||
isDev
|
||||
});
|
||||
const { getServerSideProps, getStaticProps, exports: exports1 } = checkExports(ast, _pagessegmentconfig.PagesSegmentConfigSchemaKeys, page);
|
||||
const { type: rsc } = getRSCModuleInformation(content, true);
|
||||
const exportedConfig = {};
|
||||
if (exports1) {
|
||||
for (const property of exports1){
|
||||
try {
|
||||
exportedConfig[property] = (0, _extractconstvalue.extractExportedConstValue)(ast, property);
|
||||
} catch (e) {
|
||||
if (e instanceof _extractconstvalue.UnsupportedValueError) {
|
||||
warnAboutUnsupportedValue(pageFilePath, page, e);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
try {
|
||||
exportedConfig.config = (0, _extractconstvalue.extractExportedConstValue)(ast, 'config');
|
||||
} catch (e) {
|
||||
if (e instanceof _extractconstvalue.UnsupportedValueError) {
|
||||
warnAboutUnsupportedValue(pageFilePath, page, e);
|
||||
}
|
||||
// `export config` doesn't exist, or other unknown error thrown by swc, silence them
|
||||
}
|
||||
// Validate the config.
|
||||
const route = (0, _normalizepagepath.normalizePagePath)(page);
|
||||
const config = (0, _pagessegmentconfig.parsePagesSegmentConfig)(exportedConfig, route);
|
||||
const isAnAPIRoute = (0, _isapiroute.isAPIRoute)(route);
|
||||
let resolvedRuntime = config.runtime ?? ((_config_config = config.config) == null ? void 0 : _config_config.runtime);
|
||||
if ((0, _utils.isProxyFile)(page) && resolvedRuntime) {
|
||||
const relativePath = (0, _path.relative)(process.cwd(), pageFilePath);
|
||||
const resolvedPath = relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
|
||||
const message = `Route segment config is not allowed in Proxy file at "${resolvedPath}". Proxy always runs on Node.js runtime. Learn more: https://nextjs.org/docs/messages/middleware-to-proxy`;
|
||||
if (isDev) {
|
||||
// errorOnce as proxy/middleware runs per request including multiple
|
||||
// internal _next/ routes and spams logs.
|
||||
_log.errorOnce(message);
|
||||
resolvedRuntime = _constants.SERVER_RUNTIME.nodejs;
|
||||
} else {
|
||||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
if (resolvedRuntime === _constants.SERVER_RUNTIME.experimentalEdge) {
|
||||
warnAboutExperimentalEdge(isAnAPIRoute ? page : null);
|
||||
}
|
||||
if (!(0, _utils.isProxyFile)(page) && resolvedRuntime === _constants.SERVER_RUNTIME.edge && page && !isAnAPIRoute) {
|
||||
const message = `Page ${page} provided runtime 'edge', the edge runtime for rendering is currently experimental. Use runtime 'experimental-edge' instead.`;
|
||||
if (isDev) {
|
||||
_log.error(message);
|
||||
} else {
|
||||
throw Object.defineProperty(new Error(message), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
return {
|
||||
type: _pagetypes.PAGE_TYPES.PAGES,
|
||||
getStaticProps,
|
||||
getServerSideProps,
|
||||
rsc,
|
||||
config,
|
||||
middleware: parseMiddlewareConfig(page, exportedConfig.config, nextConfig),
|
||||
runtime: resolvedRuntime,
|
||||
preferredRegion: (_config_config1 = config.config) == null ? void 0 : _config_config1.regions,
|
||||
maxDuration: config.maxDuration ?? ((_config_config2 = config.config) == null ? void 0 : _config_config2.maxDuration),
|
||||
hadUnsupportedValue
|
||||
};
|
||||
}
|
||||
async function getPageStaticInfo(params) {
|
||||
if (params.pageType === _pagetypes.PAGE_TYPES.APP) {
|
||||
return getAppPageStaticInfo(params);
|
||||
}
|
||||
return getPagesPageStaticInfo(params);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=get-page-static-info.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/analysis/get-page-static-info.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
5
apps/public-web/node_modules/next/dist/build/analysis/parse-module.d.ts
generated
vendored
Normal file
5
apps/public-web/node_modules/next/dist/build/analysis/parse-module.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
/**
|
||||
* Parses a module with SWC using an LRU cache where the parsed module will
|
||||
* be indexed by a sha of its content holding up to 500 entries.
|
||||
*/
|
||||
export declare const parseModule: (_: string, content: string) => Promise<any>;
|
||||
20
apps/public-web/node_modules/next/dist/build/analysis/parse-module.js
generated
vendored
Normal file
20
apps/public-web/node_modules/next/dist/build/analysis/parse-module.js
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "parseModule", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return parseModule;
|
||||
}
|
||||
});
|
||||
const _lrucache = require("../../server/lib/lru-cache");
|
||||
const _withpromisecache = require("../../lib/with-promise-cache");
|
||||
const _crypto = require("crypto");
|
||||
const _swc = require("../swc");
|
||||
const parseModule = (0, _withpromisecache.withPromiseCache)(new _lrucache.LRUCache(500), async (filename, content)=>(0, _swc.parse)(content, {
|
||||
isModule: 'unknown',
|
||||
filename
|
||||
}).catch(()=>null), (_, content)=>(0, _crypto.createHash)('sha1').update(content).digest('hex'));
|
||||
|
||||
//# sourceMappingURL=parse-module.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/analysis/parse-module.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/analysis/parse-module.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../src/build/analysis/parse-module.ts"],"sourcesContent":["import { LRUCache } from '../../server/lib/lru-cache'\nimport { withPromiseCache } from '../../lib/with-promise-cache'\nimport { createHash } from 'crypto'\nimport { parse } from '../swc'\n\n/**\n * Parses a module with SWC using an LRU cache where the parsed module will\n * be indexed by a sha of its content holding up to 500 entries.\n */\nexport const parseModule = withPromiseCache(\n new LRUCache<any>(500),\n async (filename: string, content: string) =>\n parse(content, { isModule: 'unknown', filename }).catch(() => null),\n (_, content) => createHash('sha1').update(content).digest('hex')\n)\n"],"names":["parseModule","withPromiseCache","LRUCache","filename","content","parse","isModule","catch","_","createHash","update","digest"],"mappings":";;;;+BASaA;;;eAAAA;;;0BATY;kCACQ;wBACN;qBACL;AAMf,MAAMA,cAAcC,IAAAA,kCAAgB,EACzC,IAAIC,kBAAQ,CAAM,MAClB,OAAOC,UAAkBC,UACvBC,IAAAA,UAAK,EAACD,SAAS;QAAEE,UAAU;QAAWH;IAAS,GAAGI,KAAK,CAAC,IAAM,OAChE,CAACC,GAAGJ,UAAYK,IAAAA,kBAAU,EAAC,QAAQC,MAAM,CAACN,SAASO,MAAM,CAAC","ignoreList":[0]}
|
||||
9
apps/public-web/node_modules/next/dist/build/analyze/index.d.ts
generated
vendored
Normal file
9
apps/public-web/node_modules/next/dist/build/analyze/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,9 @@
|
||||
export type AnalyzeOptions = {
|
||||
dir: string;
|
||||
reactProductionProfiling?: boolean;
|
||||
noMangling?: boolean;
|
||||
appDirOnly?: boolean;
|
||||
output?: boolean;
|
||||
port?: number;
|
||||
};
|
||||
export default function analyze({ dir, reactProductionProfiling, noMangling, appDirOnly, output, port, }: AnalyzeOptions): Promise<void>;
|
||||
242
apps/public-web/node_modules/next/dist/build/analyze/index.js
generated
vendored
Normal file
242
apps/public-web/node_modules/next/dist/build/analyze/index.js
generated
vendored
Normal file
@@ -0,0 +1,242 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return analyze;
|
||||
}
|
||||
});
|
||||
const _trace = require("../../trace");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../output/log"));
|
||||
const _nodepath = /*#__PURE__*/ _interop_require_wildcard(require("node:path"));
|
||||
const _config = /*#__PURE__*/ _interop_require_default(require("../../server/config"));
|
||||
const _constants = require("../../shared/lib/constants");
|
||||
const _turbopackanalyze = require("../turbopack-analyze");
|
||||
const _durationtostring = require("../duration-to-string");
|
||||
const _promises = require("node:fs/promises");
|
||||
const _entries = require("../entries");
|
||||
const _findpagefile = require("../../server/lib/find-page-file");
|
||||
const _findpagesdir = require("../../lib/find-pages-dir");
|
||||
const _pagetypes = require("../../lib/page-types");
|
||||
const _loadcustomroutes = /*#__PURE__*/ _interop_require_default(require("../../lib/load-custom-routes"));
|
||||
const _generateroutesmanifest = require("../generate-routes-manifest");
|
||||
const _ppr = require("../../server/lib/experimental/ppr");
|
||||
const _apppaths = require("../../shared/lib/router/utils/app-paths");
|
||||
const _nodehttp = /*#__PURE__*/ _interop_require_default(require("node:http"));
|
||||
const _servehandler = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/serve-handler"));
|
||||
const _storage = require("../../telemetry/storage");
|
||||
const _events = require("../../telemetry/events");
|
||||
const _shared = require("../../trace/shared");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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;
|
||||
}
|
||||
async function analyze({ dir, reactProductionProfiling = false, noMangling = false, appDirOnly = false, output = false, port = 4000 }) {
|
||||
try {
|
||||
const config = await (0, _config.default)(_constants.PHASE_ANALYZE, dir, {
|
||||
silent: false,
|
||||
reactProductionProfiling
|
||||
});
|
||||
process.env.NEXT_DEPLOYMENT_ID = config.deploymentId || '';
|
||||
const distDir = _nodepath.join(dir, '.next');
|
||||
const telemetry = new _storage.Telemetry({
|
||||
distDir
|
||||
});
|
||||
(0, _trace.setGlobal)('phase', _constants.PHASE_ANALYZE);
|
||||
(0, _trace.setGlobal)('distDir', distDir);
|
||||
(0, _trace.setGlobal)('telemetry', telemetry);
|
||||
_log.info('Analyzing a production build...');
|
||||
const analyzeContext = {
|
||||
config,
|
||||
dir,
|
||||
distDir,
|
||||
noMangling,
|
||||
appDirOnly
|
||||
};
|
||||
const { duration: analyzeDuration, shutdownPromise } = await (0, _turbopackanalyze.turbopackAnalyze)(analyzeContext);
|
||||
const durationString = (0, _durationtostring.durationToString)(analyzeDuration);
|
||||
const analyzeDir = _nodepath.join(distDir, 'diagnostics/analyze');
|
||||
await shutdownPromise;
|
||||
const routes = await collectRoutesForAnalyze(dir, config, appDirOnly);
|
||||
await (0, _promises.cp)(_nodepath.join(__dirname, '../../bundle-analyzer'), analyzeDir, {
|
||||
recursive: true
|
||||
});
|
||||
await (0, _promises.mkdir)(_nodepath.join(analyzeDir, 'data'), {
|
||||
recursive: true
|
||||
});
|
||||
await (0, _promises.writeFile)(_nodepath.join(analyzeDir, 'data', 'routes.json'), JSON.stringify(routes, null, 2));
|
||||
let logMessage = `Analyze completed in ${durationString}.`;
|
||||
if (output) {
|
||||
logMessage += ` Results written to ${analyzeDir}.\nTo explore the analyze results interactively, run \`next experimental-analyze\` without \`--output\`.`;
|
||||
}
|
||||
_log.event(logMessage);
|
||||
telemetry.record((0, _events.eventAnalyzeCompleted)({
|
||||
success: true,
|
||||
durationInSeconds: Math.round(analyzeDuration),
|
||||
totalPageCount: routes.length
|
||||
}));
|
||||
if (!output) {
|
||||
await startServer(analyzeDir, port);
|
||||
}
|
||||
} catch (e) {
|
||||
const telemetry = _shared.traceGlobals.get('telemetry');
|
||||
if (telemetry) {
|
||||
telemetry.record((0, _events.eventAnalyzeCompleted)({
|
||||
success: false
|
||||
}));
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Collects all routes from the project for the bundle analyzer.
|
||||
* Returns a list of route paths (both static and dynamic).
|
||||
*/ async function collectRoutesForAnalyze(dir, config, appDirOnly) {
|
||||
const { pagesDir, appDir } = (0, _findpagesdir.findPagesDir)(dir);
|
||||
const validFileMatcher = (0, _findpagefile.createValidFileMatcher)(config.pageExtensions, appDir);
|
||||
let appType;
|
||||
if (pagesDir && appDir) {
|
||||
appType = 'hybrid';
|
||||
} else if (pagesDir) {
|
||||
appType = 'pages';
|
||||
} else if (appDir) {
|
||||
appType = 'app';
|
||||
} else {
|
||||
throw Object.defineProperty(new Error('No pages or app directory found.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E929",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
const { appPaths } = appDir ? await (0, _entries.collectAppFiles)(appDir, validFileMatcher) : {
|
||||
appPaths: []
|
||||
};
|
||||
const pagesPaths = pagesDir ? await (0, _entries.collectPagesFiles)(pagesDir, validFileMatcher) : null;
|
||||
const appMapping = await (0, _entries.createPagesMapping)({
|
||||
pagePaths: appPaths,
|
||||
isDev: false,
|
||||
pagesType: _pagetypes.PAGE_TYPES.APP,
|
||||
pageExtensions: config.pageExtensions,
|
||||
pagesDir,
|
||||
appDir,
|
||||
appDirOnly
|
||||
});
|
||||
const pagesMapping = pagesPaths ? await (0, _entries.createPagesMapping)({
|
||||
pagePaths: pagesPaths,
|
||||
isDev: false,
|
||||
pagesType: _pagetypes.PAGE_TYPES.PAGES,
|
||||
pageExtensions: config.pageExtensions,
|
||||
pagesDir,
|
||||
appDir,
|
||||
appDirOnly
|
||||
}) : null;
|
||||
const pageKeys = {
|
||||
pages: pagesMapping ? Object.keys(pagesMapping) : [],
|
||||
app: appMapping ? Object.keys(appMapping).map((key)=>(0, _apppaths.normalizeAppPath)(key)) : undefined
|
||||
};
|
||||
// Load custom routes
|
||||
const { redirects, headers, rewrites } = await (0, _loadcustomroutes.default)(config);
|
||||
// Compute restricted redirect paths
|
||||
const restrictedRedirectPaths = [
|
||||
'/_next'
|
||||
].map((pathPrefix)=>config.basePath ? `${config.basePath}${pathPrefix}` : pathPrefix);
|
||||
const isAppPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
|
||||
// Generate routes manifest
|
||||
const { routesManifest } = (0, _generateroutesmanifest.generateRoutesManifest)({
|
||||
appType,
|
||||
pageKeys,
|
||||
config,
|
||||
redirects,
|
||||
headers,
|
||||
rewrites,
|
||||
restrictedRedirectPaths,
|
||||
isAppPPREnabled
|
||||
});
|
||||
return routesManifest.dynamicRoutes.map((r)=>r.page).concat(routesManifest.staticRoutes.map((r)=>r.page));
|
||||
}
|
||||
function startServer(dir, port) {
|
||||
const server = _nodehttp.default.createServer((req, res)=>{
|
||||
return (0, _servehandler.default)(req, res, {
|
||||
public: dir
|
||||
});
|
||||
});
|
||||
return new Promise((resolve, reject)=>{
|
||||
function onError(err) {
|
||||
server.close(()=>{
|
||||
reject(err);
|
||||
});
|
||||
}
|
||||
server.on('error', onError);
|
||||
server.listen(port, 'localhost', ()=>{
|
||||
const address = server.address();
|
||||
if (address == null) {
|
||||
reject(Object.defineProperty(new Error('Unable to get server address'), "__NEXT_ERROR_CODE", {
|
||||
value: "E928",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
}));
|
||||
return;
|
||||
}
|
||||
// No longer needed after startup
|
||||
server.removeListener('error', onError);
|
||||
let addressString;
|
||||
if (typeof address === 'string') {
|
||||
addressString = address;
|
||||
} else if (address.family === 'IPv6' && (address.address === '::' || address.address === '::1')) {
|
||||
addressString = `localhost:${address.port}`;
|
||||
} else if (address.family === 'IPv6') {
|
||||
addressString = `[${address.address}]:${address.port}`;
|
||||
} else {
|
||||
addressString = `${address.address}:${address.port}`;
|
||||
}
|
||||
_log.info(`Bundle analyzer available at http://${addressString}`);
|
||||
resolve();
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
//# sourceMappingURL=index.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/analyze/index.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/analyze/index.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
20
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.d.ts
generated
vendored
Normal file
20
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.d.ts
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
import type { NextBabelLoaderOptions, NextJsLoaderContext } from './types';
|
||||
import { type SourceMap, type BabelLoaderTransformOptions } from './util';
|
||||
/**
|
||||
* An internal (non-exported) type used by babel.
|
||||
*/
|
||||
export type ResolvedBabelConfig = {
|
||||
options: BabelLoaderTransformOptions;
|
||||
passes: BabelPluginPasses;
|
||||
externalDependencies: ReadonlyArray<string>;
|
||||
};
|
||||
export type BabelPlugin = unknown;
|
||||
export type BabelPluginPassList = ReadonlyArray<BabelPlugin>;
|
||||
export type BabelPluginPasses = ReadonlyArray<BabelPluginPassList>;
|
||||
export default function getConfig(ctx: NextJsLoaderContext, { source, target, loaderOptions, filename, inputSourceMap, }: {
|
||||
source: string;
|
||||
loaderOptions: NextBabelLoaderOptions;
|
||||
target: string;
|
||||
filename: string;
|
||||
inputSourceMap?: SourceMap | undefined;
|
||||
}): Promise<ResolvedBabelConfig | null>;
|
||||
429
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.js
generated
vendored
Normal file
429
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.js
generated
vendored
Normal file
@@ -0,0 +1,429 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getConfig;
|
||||
}
|
||||
});
|
||||
const _nodefs = require("node:fs");
|
||||
const _nodeutil = require("node:util");
|
||||
const _json5 = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/json5"));
|
||||
const _core = require("next/dist/compiled/babel/core");
|
||||
const _corelibconfig = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-config"));
|
||||
const _util = require("./util");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("../../output/log"));
|
||||
const _swc = require("../../swc");
|
||||
const _installbindings = require("../../swc/install-bindings");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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 nextDistPath = /(next[\\/]dist[\\/]shared[\\/]lib)|(next[\\/]dist[\\/]client)|(next[\\/]dist[\\/]pages)/;
|
||||
function shouldSkipBabel(transformMode, configFilePath, hasReactCompiler) {
|
||||
return transformMode === 'standalone' && configFilePath == null && !hasReactCompiler;
|
||||
}
|
||||
const fileExtensionRegex = /\.([a-z]+)$/;
|
||||
async function getCacheCharacteristics(loaderOptions, source, filename) {
|
||||
var _fileExtensionRegex_exec;
|
||||
let isStandalone, isServer, pagesDir;
|
||||
switch(loaderOptions.transformMode){
|
||||
case 'default':
|
||||
isStandalone = false;
|
||||
isServer = loaderOptions.isServer;
|
||||
pagesDir = loaderOptions.pagesDir;
|
||||
break;
|
||||
case 'standalone':
|
||||
isStandalone = true;
|
||||
break;
|
||||
default:
|
||||
throw Object.defineProperty(new Error(`unsupported transformMode in loader options: ${(0, _nodeutil.inspect)(loaderOptions)}`), "__NEXT_ERROR_CODE", {
|
||||
value: "E811",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
const isPageFile = pagesDir != null && filename.startsWith(pagesDir);
|
||||
const isNextDist = nextDistPath.test(filename);
|
||||
const hasModuleExports = source.indexOf('module.exports') !== -1;
|
||||
const fileExt = ((_fileExtensionRegex_exec = fileExtensionRegex.exec(filename)) == null ? void 0 : _fileExtensionRegex_exec[1]) || 'unknown';
|
||||
let { reactCompilerPlugins, reactCompilerExclude, configFile: configFilePath, transformMode } = loaderOptions;
|
||||
// Compute `hasReactCompiler` as part of the cache characteristics / key,
|
||||
// rather than inside of `getFreshConfig`:
|
||||
// - `isReactCompilerRequired` depends on the file contents
|
||||
// - `node_modules` and `reactCompilerExclude` depend on the file path, which
|
||||
// isn't part of the cache characteristics
|
||||
let hasReactCompiler = reactCompilerPlugins != null && reactCompilerPlugins.length !== 0 && !loaderOptions.isServer && !/[/\\]node_modules[/\\]/.test(filename) && // Assumption: `reactCompilerExclude` is cheap because it should only
|
||||
// operate on the file path and *not* the file contents (it's sync)
|
||||
!(reactCompilerExclude == null ? void 0 : reactCompilerExclude(filename));
|
||||
// `isReactCompilerRequired` is expensive to run (parses/visits with SWC), so
|
||||
// only run it if there's a good chance we might be able to skip calling Babel
|
||||
// entirely (speculatively call `shouldSkipBabel`).
|
||||
//
|
||||
// Otherwise, we can let react compiler handle this logic for us. It should
|
||||
// behave equivalently.
|
||||
if (hasReactCompiler && shouldSkipBabel(transformMode, configFilePath, /*hasReactCompiler*/ false)) {
|
||||
hasReactCompiler &&= await (0, _swc.isReactCompilerRequired)(filename);
|
||||
}
|
||||
return {
|
||||
isStandalone,
|
||||
isServer,
|
||||
isPageFile,
|
||||
isNextDist,
|
||||
hasModuleExports,
|
||||
hasReactCompiler,
|
||||
fileExt,
|
||||
configFilePath
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Return an array of Babel plugins, conditioned upon loader options and
|
||||
* source file characteristics.
|
||||
*/ function getPlugins(loaderOptions, cacheCharacteristics) {
|
||||
const { isServer, isPageFile, isNextDist, hasModuleExports } = cacheCharacteristics;
|
||||
const { development, hasReactRefresh } = loaderOptions;
|
||||
const applyCommonJsItem = hasModuleExports ? (0, _core.createConfigItem)(require('../plugins/commonjs'), {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const reactRefreshItem = hasReactRefresh ? (0, _core.createConfigItem)([
|
||||
require('next/dist/compiled/react-refresh/babel'),
|
||||
{
|
||||
skipEnvCheck: true
|
||||
}
|
||||
], {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const pageConfigItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
|
||||
require('../plugins/next-page-config')
|
||||
], {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const disallowExportAllItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
|
||||
require('../plugins/next-page-disallow-re-export-all-exports')
|
||||
], {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const transformDefineItem = (0, _core.createConfigItem)([
|
||||
require.resolve('next/dist/compiled/babel/plugin-transform-define'),
|
||||
{
|
||||
'process.env.NODE_ENV': development ? 'development' : 'production',
|
||||
'typeof window': isServer ? 'undefined' : 'object',
|
||||
'process.browser': isServer ? false : true
|
||||
},
|
||||
'next-js-transform-define-instance'
|
||||
], {
|
||||
type: 'plugin'
|
||||
});
|
||||
const nextSsgItem = !isServer && isPageFile ? (0, _core.createConfigItem)([
|
||||
require.resolve('../plugins/next-ssg-transform')
|
||||
], {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const commonJsItem = isNextDist ? (0, _core.createConfigItem)(require('next/dist/compiled/babel/plugin-transform-modules-commonjs'), {
|
||||
type: 'plugin'
|
||||
}) : null;
|
||||
const nextFontUnsupported = (0, _core.createConfigItem)([
|
||||
require('../plugins/next-font-unsupported')
|
||||
], {
|
||||
type: 'plugin'
|
||||
});
|
||||
return [
|
||||
reactRefreshItem,
|
||||
pageConfigItem,
|
||||
disallowExportAllItem,
|
||||
applyCommonJsItem,
|
||||
transformDefineItem,
|
||||
nextSsgItem,
|
||||
commonJsItem,
|
||||
nextFontUnsupported
|
||||
].filter(Boolean);
|
||||
}
|
||||
const isJsonFile = /\.(json|babelrc)$/;
|
||||
const isJsFile = /\.js$/;
|
||||
/**
|
||||
* While this function does block execution while reading from disk, it
|
||||
* should not introduce any issues. The function is only invoked when
|
||||
* generating a fresh config, and only a small handful of configs should
|
||||
* be generated during compilation.
|
||||
*/ function getCustomBabelConfig(configFilePath) {
|
||||
if (isJsonFile.exec(configFilePath)) {
|
||||
const babelConfigRaw = (0, _nodefs.readFileSync)(configFilePath, 'utf8');
|
||||
return _json5.default.parse(babelConfigRaw);
|
||||
} else if (isJsFile.exec(configFilePath)) {
|
||||
return require(configFilePath);
|
||||
}
|
||||
throw Object.defineProperty(new Error('The Next.js Babel loader does not support .mjs or .cjs config files.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E477",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
let babelConfigWarned = false;
|
||||
/**
|
||||
* Check if custom babel configuration from user only contains options that
|
||||
* can be migrated into latest Next.js features supported by SWC.
|
||||
*
|
||||
* This raises soft warning messages only, not making any errors yet.
|
||||
*/ function checkCustomBabelConfigDeprecation(config) {
|
||||
if (!config || Object.keys(config).length === 0) {
|
||||
return;
|
||||
}
|
||||
const { plugins, presets, ...otherOptions } = config;
|
||||
if (Object.keys(otherOptions ?? {}).length > 0) {
|
||||
return;
|
||||
}
|
||||
if (babelConfigWarned) {
|
||||
return;
|
||||
}
|
||||
babelConfigWarned = true;
|
||||
const isPresetReadyToDeprecate = !presets || presets.length === 0 || presets.length === 1 && presets[0] === 'next/babel';
|
||||
const pluginReasons = [];
|
||||
const unsupportedPlugins = [];
|
||||
if (Array.isArray(plugins)) {
|
||||
for (const plugin of plugins){
|
||||
const pluginName = Array.isArray(plugin) ? plugin[0] : plugin;
|
||||
// [NOTE]: We cannot detect if the user uses babel-plugin-macro based transform plugins,
|
||||
// such as `styled-components/macro` in here.
|
||||
switch(pluginName){
|
||||
case 'styled-components':
|
||||
case 'babel-plugin-styled-components':
|
||||
pluginReasons.push(`\t- 'styled-components' can be enabled via 'compiler.styledComponents' in 'next.config.js'`);
|
||||
break;
|
||||
case '@emotion/babel-plugin':
|
||||
pluginReasons.push(`\t- '@emotion/babel-plugin' can be enabled via 'compiler.emotion' in 'next.config.js'`);
|
||||
break;
|
||||
case 'babel-plugin-relay':
|
||||
pluginReasons.push(`\t- 'babel-plugin-relay' can be enabled via 'compiler.relay' in 'next.config.js'`);
|
||||
break;
|
||||
case 'react-remove-properties':
|
||||
pluginReasons.push(`\t- 'react-remove-properties' can be enabled via 'compiler.reactRemoveProperties' in 'next.config.js'`);
|
||||
break;
|
||||
case 'transform-remove-console':
|
||||
pluginReasons.push(`\t- 'transform-remove-console' can be enabled via 'compiler.removeConsole' in 'next.config.js'`);
|
||||
break;
|
||||
default:
|
||||
unsupportedPlugins.push(pluginName);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (isPresetReadyToDeprecate && unsupportedPlugins.length === 0) {
|
||||
_log.warn(`It looks like there is a custom Babel configuration that can be removed${pluginReasons.length > 0 ? ':' : '.'}`);
|
||||
if (pluginReasons.length > 0) {
|
||||
_log.warn(`Next.js supports the following features natively: `);
|
||||
_log.warn(pluginReasons.join(''));
|
||||
_log.warn(`For more details configuration options, please refer https://nextjs.org/docs/architecture/nextjs-compiler#supported-features`);
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Generate a new, flat Babel config, ready to be handed to Babel-traverse.
|
||||
* This config should have no unresolved overrides, presets, etc.
|
||||
*
|
||||
* The config returned by this function is cached, so the function should not
|
||||
* depend on file-specific configuration or configuration that could change
|
||||
* across invocations without a process restart.
|
||||
*/ async function getFreshConfig(ctx, cacheCharacteristics, loaderOptions, target) {
|
||||
const { transformMode } = loaderOptions;
|
||||
const { hasReactCompiler, configFilePath, fileExt } = cacheCharacteristics;
|
||||
let customConfig = configFilePath && getCustomBabelConfig(configFilePath);
|
||||
if (shouldSkipBabel(transformMode, configFilePath, hasReactCompiler)) {
|
||||
// Optimization: There's nothing useful to do, bail out and skip babel on
|
||||
// this file
|
||||
return null;
|
||||
}
|
||||
checkCustomBabelConfigDeprecation(customConfig);
|
||||
// We can assume that `reactCompilerPlugins` does not change without a process
|
||||
// restart (it's safe to cache), as it's specified in the `next.config.js`,
|
||||
// which always causes a full restart of `next dev` if changed.
|
||||
const reactCompilerPluginsIfEnabled = hasReactCompiler ? loaderOptions.reactCompilerPlugins ?? [] : [];
|
||||
let isServer, pagesDir, srcDir, development;
|
||||
if (transformMode === 'default') {
|
||||
isServer = loaderOptions.isServer;
|
||||
pagesDir = loaderOptions.pagesDir;
|
||||
srcDir = loaderOptions.srcDir;
|
||||
development = loaderOptions.development;
|
||||
}
|
||||
let options = {
|
||||
babelrc: false,
|
||||
cloneInputAst: false,
|
||||
// Use placeholder file info. `updateBabelConfigWithFileDetails` will
|
||||
// replace this after caching.
|
||||
filename: `basename.${fileExt}`,
|
||||
inputSourceMap: undefined,
|
||||
sourceFileName: `basename.${fileExt}`,
|
||||
// Set the default sourcemap behavior based on Webpack's mapping flag,
|
||||
// but allow users to override if they want.
|
||||
sourceMaps: loaderOptions.sourceMaps === undefined ? ctx.sourceMap : loaderOptions.sourceMaps
|
||||
};
|
||||
const baseCaller = {
|
||||
name: 'next-babel-turbo-loader',
|
||||
supportsStaticESM: true,
|
||||
supportsDynamicImport: true,
|
||||
// Provide plugins with insight into webpack target.
|
||||
// https://github.com/babel/babel-loader/issues/787
|
||||
target,
|
||||
// Webpack 5 supports TLA behind a flag. We enable it by default
|
||||
// for Babel, and then webpack will throw an error if the experimental
|
||||
// flag isn't enabled.
|
||||
supportsTopLevelAwait: true,
|
||||
isServer,
|
||||
srcDir,
|
||||
pagesDir,
|
||||
isDev: development,
|
||||
transformMode,
|
||||
...loaderOptions.caller
|
||||
};
|
||||
options.plugins = [
|
||||
...transformMode === 'default' ? getPlugins(loaderOptions, cacheCharacteristics) : [],
|
||||
...reactCompilerPluginsIfEnabled,
|
||||
...(customConfig == null ? void 0 : customConfig.plugins) || []
|
||||
];
|
||||
// target can be provided in babelrc
|
||||
options.target = isServer ? undefined : customConfig == null ? void 0 : customConfig.target;
|
||||
// env can be provided in babelrc
|
||||
options.env = customConfig == null ? void 0 : customConfig.env;
|
||||
options.presets = (()=>{
|
||||
// If presets is defined the user will have next/babel in their babelrc
|
||||
if (customConfig == null ? void 0 : customConfig.presets) {
|
||||
return customConfig.presets;
|
||||
}
|
||||
// If presets is not defined the user will likely have "env" in their babelrc
|
||||
if (customConfig) {
|
||||
return undefined;
|
||||
}
|
||||
// If no custom config is provided the default is to use next/babel
|
||||
return [
|
||||
'next/babel'
|
||||
];
|
||||
})();
|
||||
options.overrides = loaderOptions.overrides;
|
||||
options.caller = {
|
||||
...baseCaller,
|
||||
hasJsxRuntime: transformMode === 'default' ? loaderOptions.hasJsxRuntime : undefined
|
||||
};
|
||||
// Babel does strict checks on the config so undefined is not allowed
|
||||
if (typeof options.target === 'undefined') {
|
||||
delete options.target;
|
||||
}
|
||||
Object.defineProperty(options.caller, 'onWarning', {
|
||||
enumerable: false,
|
||||
writable: false,
|
||||
value: (reason)=>{
|
||||
if (!(reason instanceof Error)) {
|
||||
reason = Object.defineProperty(new Error(reason), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
ctx.emitWarning(reason);
|
||||
}
|
||||
});
|
||||
const loadedOptions = (0, _core.loadOptions)(options);
|
||||
const config = (0, _util.consumeIterator)((0, _corelibconfig.default)(loadedOptions));
|
||||
return config;
|
||||
}
|
||||
/**
|
||||
* Each key returned here corresponds with a Babel config that can be shared.
|
||||
* The conditions of permissible sharing between files is dependent on specific
|
||||
* file attributes and Next.js compiler states: `CharacteristicsGermaneToCaching`.
|
||||
*/ function getCacheKey(cacheCharacteristics) {
|
||||
const { isStandalone, isServer, isPageFile, isNextDist, hasModuleExports, hasReactCompiler, fileExt, configFilePath } = cacheCharacteristics;
|
||||
const flags = 0 | (isStandalone ? 1 : 0) | (isServer ? 2 : 0) | (isPageFile ? 4 : 0) | (isNextDist ? 8 : 0) | (hasModuleExports ? 16 : 0) | (hasReactCompiler ? 32 : 0);
|
||||
// separate strings with null bytes, assuming null bytes are not valid in file
|
||||
// paths
|
||||
return `${configFilePath || ''}\x00${fileExt}\x00${flags}`;
|
||||
}
|
||||
const configCache = new Map();
|
||||
const configFiles = new Set();
|
||||
/**
|
||||
* Applies file-specific values to a potentially-cached configuration object.
|
||||
*/ function updateBabelConfigWithFileDetails(cachedConfig, loaderOptions, filename, inputSourceMap) {
|
||||
if (cachedConfig == null) {
|
||||
return null;
|
||||
}
|
||||
return {
|
||||
...cachedConfig,
|
||||
options: {
|
||||
...cachedConfig.options,
|
||||
cwd: loaderOptions.cwd,
|
||||
root: loaderOptions.cwd,
|
||||
filename,
|
||||
inputSourceMap,
|
||||
// Ensure that Webpack will get a full absolute path in the sourcemap
|
||||
// so that it can properly map the module back to its internal cached
|
||||
// modules.
|
||||
sourceFileName: filename
|
||||
}
|
||||
};
|
||||
}
|
||||
async function getConfig(ctx, { source, target, loaderOptions, filename, inputSourceMap }) {
|
||||
// Install bindings early so they are definitely available to the loader.
|
||||
// When run by webpack in next this is already done with correct configuration so this is a no-op.
|
||||
// In turbopack loaders are run in a subprocess so it may or may not be done.
|
||||
await (0, _installbindings.installBindings)();
|
||||
const cacheCharacteristics = await getCacheCharacteristics(loaderOptions, source, filename);
|
||||
if (loaderOptions.configFile) {
|
||||
// Ensures webpack invalidates the cache for this loader when the config file changes
|
||||
ctx.addDependency(loaderOptions.configFile);
|
||||
}
|
||||
const cacheKey = getCacheKey(cacheCharacteristics);
|
||||
const cachedConfig = configCache.get(cacheKey);
|
||||
if (cachedConfig !== undefined) {
|
||||
return updateBabelConfigWithFileDetails(cachedConfig, loaderOptions, filename, inputSourceMap);
|
||||
}
|
||||
if (loaderOptions.configFile && !configFiles.has(loaderOptions.configFile)) {
|
||||
configFiles.add(loaderOptions.configFile);
|
||||
_log.info(`Using external babel configuration from ${loaderOptions.configFile}`);
|
||||
}
|
||||
const freshConfig = await getFreshConfig(ctx, cacheCharacteristics, loaderOptions, target);
|
||||
configCache.set(cacheKey, freshConfig);
|
||||
return updateBabelConfigWithFileDetails(freshConfig, loaderOptions, filename, inputSourceMap);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=get-config.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/loader/get-config.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
3
apps/public-web/node_modules/next/dist/build/babel/loader/index.d.ts
generated
vendored
Normal file
3
apps/public-web/node_modules/next/dist/build/babel/loader/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,3 @@
|
||||
import type { NextJsLoaderContext } from './types';
|
||||
declare function nextBabelLoaderOuter(this: NextJsLoaderContext, inputSource: string, inputSourceMap?: any): void;
|
||||
export default nextBabelLoaderOuter;
|
||||
56
apps/public-web/node_modules/next/dist/build/babel/loader/index.js
generated
vendored
Normal file
56
apps/public-web/node_modules/next/dist/build/babel/loader/index.js
generated
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
const _transform = /*#__PURE__*/ _interop_require_default(require("./transform"));
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
async function nextBabelLoader(ctx, parentTrace, inputSource, inputSourceMap) {
|
||||
const filename = ctx.resourcePath;
|
||||
// Ensure `.d.ts` are not processed.
|
||||
if (filename.endsWith('.d.ts')) {
|
||||
return [
|
||||
inputSource,
|
||||
inputSourceMap
|
||||
];
|
||||
}
|
||||
const target = ctx.target;
|
||||
const loaderOptions = parentTrace.traceChild('get-options')// @ts-ignore TODO: remove ignore once webpack 5 types are used
|
||||
.traceFn(()=>ctx.getOptions());
|
||||
if (loaderOptions.exclude && loaderOptions.exclude(filename)) {
|
||||
return [
|
||||
inputSource,
|
||||
inputSourceMap
|
||||
];
|
||||
}
|
||||
const loaderSpanInner = parentTrace.traceChild('next-babel-turbo-transform');
|
||||
const { code: transformedSource, map: outputSourceMap } = await loaderSpanInner.traceAsyncFn(async ()=>await (0, _transform.default)(ctx, inputSource, inputSourceMap, loaderOptions, filename, target, loaderSpanInner));
|
||||
return [
|
||||
transformedSource,
|
||||
outputSourceMap
|
||||
];
|
||||
}
|
||||
function nextBabelLoaderOuter(inputSource, // webpack's source map format is compatible with babel, but the type signature doesn't match
|
||||
inputSourceMap) {
|
||||
const callback = this.async();
|
||||
const loaderSpan = this.currentTraceSpan.traceChild('next-babel-turbo-loader');
|
||||
loaderSpan.traceAsyncFn(()=>nextBabelLoader(this, loaderSpan, inputSource, inputSourceMap)).then(([transformedSource, outputSourceMap])=>callback == null ? void 0 : callback(/* err */ null, transformedSource, outputSourceMap ?? inputSourceMap), (err)=>{
|
||||
callback == null ? void 0 : callback(err);
|
||||
});
|
||||
}
|
||||
// check this type matches `webpack.LoaderDefinitionFunction`, but be careful
|
||||
// not to publicly rely on the webpack type since the generated typescript
|
||||
// declarations will be wrong.
|
||||
const _nextBabelLoaderOuter = nextBabelLoaderOuter;
|
||||
const _default = nextBabelLoaderOuter;
|
||||
|
||||
//# sourceMappingURL=index.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/loader/index.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/loader/index.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/loader/index.ts"],"sourcesContent":["import type { Span } from '../../../trace'\nimport transform from './transform'\nimport type { NextJsLoaderContext } from './types'\nimport type { SourceMap } from './util'\nimport type { webpack } from 'next/dist/compiled/webpack/webpack'\n\nasync function nextBabelLoader(\n ctx: NextJsLoaderContext,\n parentTrace: Span,\n inputSource: string,\n inputSourceMap: SourceMap | null | undefined\n): Promise<[string, SourceMap | null | undefined]> {\n const filename = ctx.resourcePath\n\n // Ensure `.d.ts` are not processed.\n if (filename.endsWith('.d.ts')) {\n return [inputSource, inputSourceMap]\n }\n\n const target = ctx.target\n const loaderOptions: any = parentTrace\n .traceChild('get-options')\n // @ts-ignore TODO: remove ignore once webpack 5 types are used\n .traceFn(() => ctx.getOptions())\n\n if (loaderOptions.exclude && loaderOptions.exclude(filename)) {\n return [inputSource, inputSourceMap]\n }\n\n const loaderSpanInner = parentTrace.traceChild('next-babel-turbo-transform')\n const { code: transformedSource, map: outputSourceMap } =\n await loaderSpanInner.traceAsyncFn(\n async () =>\n await transform(\n ctx,\n inputSource,\n inputSourceMap,\n loaderOptions,\n filename,\n target,\n loaderSpanInner\n )\n )\n\n return [transformedSource, outputSourceMap]\n}\n\nfunction nextBabelLoaderOuter(\n this: NextJsLoaderContext,\n inputSource: string,\n // webpack's source map format is compatible with babel, but the type signature doesn't match\n inputSourceMap?: any\n) {\n const callback = this.async()\n\n const loaderSpan = this.currentTraceSpan.traceChild('next-babel-turbo-loader')\n loaderSpan\n .traceAsyncFn(() =>\n nextBabelLoader(this, loaderSpan, inputSource, inputSourceMap)\n )\n .then(\n ([transformedSource, outputSourceMap]) =>\n callback?.(\n /* err */ null,\n transformedSource,\n outputSourceMap ?? inputSourceMap\n ),\n (err) => {\n callback?.(err)\n }\n )\n}\n\n// check this type matches `webpack.LoaderDefinitionFunction`, but be careful\n// not to publicly rely on the webpack type since the generated typescript\n// declarations will be wrong.\nconst _nextBabelLoaderOuter: webpack.LoaderDefinitionFunction<\n {},\n NextJsLoaderContext\n> = nextBabelLoaderOuter\n\nexport default nextBabelLoaderOuter\n"],"names":["nextBabelLoader","ctx","parentTrace","inputSource","inputSourceMap","filename","resourcePath","endsWith","target","loaderOptions","traceChild","traceFn","getOptions","exclude","loaderSpanInner","code","transformedSource","map","outputSourceMap","traceAsyncFn","transform","nextBabelLoaderOuter","callback","async","loaderSpan","currentTraceSpan","then","err","_nextBabelLoaderOuter"],"mappings":";;;;+BAiFA;;;eAAA;;;kEAhFsB;;;;;;AAKtB,eAAeA,gBACbC,GAAwB,EACxBC,WAAiB,EACjBC,WAAmB,EACnBC,cAA4C;IAE5C,MAAMC,WAAWJ,IAAIK,YAAY;IAEjC,oCAAoC;IACpC,IAAID,SAASE,QAAQ,CAAC,UAAU;QAC9B,OAAO;YAACJ;YAAaC;SAAe;IACtC;IAEA,MAAMI,SAASP,IAAIO,MAAM;IACzB,MAAMC,gBAAqBP,YACxBQ,UAAU,CAAC,cACZ,+DAA+D;KAC9DC,OAAO,CAAC,IAAMV,IAAIW,UAAU;IAE/B,IAAIH,cAAcI,OAAO,IAAIJ,cAAcI,OAAO,CAACR,WAAW;QAC5D,OAAO;YAACF;YAAaC;SAAe;IACtC;IAEA,MAAMU,kBAAkBZ,YAAYQ,UAAU,CAAC;IAC/C,MAAM,EAAEK,MAAMC,iBAAiB,EAAEC,KAAKC,eAAe,EAAE,GACrD,MAAMJ,gBAAgBK,YAAY,CAChC,UACE,MAAMC,IAAAA,kBAAS,EACbnB,KACAE,aACAC,gBACAK,eACAJ,UACAG,QACAM;IAIR,OAAO;QAACE;QAAmBE;KAAgB;AAC7C;AAEA,SAASG,qBAEPlB,WAAmB,EACnB,6FAA6F;AAC7FC,cAAoB;IAEpB,MAAMkB,WAAW,IAAI,CAACC,KAAK;IAE3B,MAAMC,aAAa,IAAI,CAACC,gBAAgB,CAACf,UAAU,CAAC;IACpDc,WACGL,YAAY,CAAC,IACZnB,gBAAgB,IAAI,EAAEwB,YAAYrB,aAAaC,iBAEhDsB,IAAI,CACH,CAAC,CAACV,mBAAmBE,gBAAgB,GACnCI,4BAAAA,SACE,OAAO,GAAG,MACVN,mBACAE,mBAAmBd,iBAEvB,CAACuB;QACCL,4BAAAA,SAAWK;IACb;AAEN;AAEA,6EAA6E;AAC7E,0EAA0E;AAC1E,8BAA8B;AAC9B,MAAMC,wBAGFP;MAEJ,WAAeA","ignoreList":[0]}
|
||||
5
apps/public-web/node_modules/next/dist/build/babel/loader/transform.d.ts
generated
vendored
Normal file
5
apps/public-web/node_modules/next/dist/build/babel/loader/transform.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import { type GeneratorResult } from 'next/dist/compiled/babel/generator';
|
||||
import type { Span } from '../../../trace';
|
||||
import type { NextJsLoaderContext } from './types';
|
||||
import type { SourceMap } from './util';
|
||||
export default function transform(ctx: NextJsLoaderContext, source: string, inputSourceMap: SourceMap | null | undefined, loaderOptions: any, filename: string, target: string, parentSpan: Span): Promise<GeneratorResult>;
|
||||
103
apps/public-web/node_modules/next/dist/build/babel/loader/transform.js
generated
vendored
Normal file
103
apps/public-web/node_modules/next/dist/build/babel/loader/transform.js
generated
vendored
Normal file
@@ -0,0 +1,103 @@
|
||||
/*
|
||||
* Partially adapted from @babel/core (MIT license).
|
||||
*/ "use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return transform;
|
||||
}
|
||||
});
|
||||
const _traverse = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/traverse"));
|
||||
const _generator = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/generator"));
|
||||
const _corelibnormalizefile = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-normalize-file"));
|
||||
const _corelibnormalizeopts = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-normalize-opts"));
|
||||
const _corelibblockhoistplugin = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-block-hoist-plugin"));
|
||||
const _corelibpluginpass = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/core-lib-plugin-pass"));
|
||||
const _getconfig = /*#__PURE__*/ _interop_require_default(require("./get-config"));
|
||||
const _util = require("./util");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function getTraversalParams(file, pluginPairs) {
|
||||
const passPairs = [];
|
||||
const passes = [];
|
||||
const visitors = [];
|
||||
for (const plugin of pluginPairs.concat((0, _corelibblockhoistplugin.default)())){
|
||||
const pass = new _corelibpluginpass.default(file, plugin.key, plugin.options);
|
||||
passPairs.push([
|
||||
plugin,
|
||||
pass
|
||||
]);
|
||||
passes.push(pass);
|
||||
visitors.push(plugin.visitor);
|
||||
}
|
||||
return {
|
||||
passPairs,
|
||||
passes,
|
||||
visitors
|
||||
};
|
||||
}
|
||||
function invokePluginPre(file, passPairs) {
|
||||
for (const [{ pre }, pass] of passPairs){
|
||||
if (pre) {
|
||||
pre.call(pass, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
function invokePluginPost(file, passPairs) {
|
||||
for (const [{ post }, pass] of passPairs){
|
||||
if (post) {
|
||||
post.call(pass, file);
|
||||
}
|
||||
}
|
||||
}
|
||||
function transformAstPass(file, pluginPairs, parentSpan) {
|
||||
const { passPairs, passes, visitors } = getTraversalParams(file, pluginPairs);
|
||||
invokePluginPre(file, passPairs);
|
||||
const visitor = _traverse.default.visitors.merge(visitors, passes, // @ts-ignore - the exported types are incorrect here
|
||||
file.opts.wrapPluginVisitorMethod);
|
||||
parentSpan.traceChild('babel-turbo-traverse').traceFn(()=>(0, _traverse.default)(file.ast, visitor, file.scope));
|
||||
invokePluginPost(file, passPairs);
|
||||
}
|
||||
function transformAst(file, babelConfig, parentSpan) {
|
||||
for (const pluginPairs of babelConfig.passes){
|
||||
transformAstPass(file, pluginPairs, parentSpan);
|
||||
}
|
||||
}
|
||||
async function transform(ctx, source, inputSourceMap, loaderOptions, filename, target, parentSpan) {
|
||||
const getConfigSpan = parentSpan.traceChild('babel-turbo-get-config');
|
||||
const babelConfig = await (0, _getconfig.default)(ctx, {
|
||||
source,
|
||||
loaderOptions,
|
||||
inputSourceMap: inputSourceMap ?? undefined,
|
||||
target,
|
||||
filename
|
||||
});
|
||||
if (!babelConfig) {
|
||||
return {
|
||||
code: source,
|
||||
map: inputSourceMap ?? null
|
||||
};
|
||||
}
|
||||
getConfigSpan.stop();
|
||||
const normalizeSpan = parentSpan.traceChild('babel-turbo-normalize-file');
|
||||
const file = (0, _util.consumeIterator)((0, _corelibnormalizefile.default)(babelConfig.passes, (0, _corelibnormalizeopts.default)(babelConfig), source));
|
||||
normalizeSpan.stop();
|
||||
const transformSpan = parentSpan.traceChild('babel-turbo-transform');
|
||||
transformAst(file, babelConfig, transformSpan);
|
||||
transformSpan.stop();
|
||||
const generateSpan = parentSpan.traceChild('babel-turbo-generate');
|
||||
const { code, map } = (0, _generator.default)(file.ast, file.opts.generatorOpts, file.code);
|
||||
generateSpan.stop();
|
||||
return {
|
||||
code,
|
||||
map
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=transform.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/loader/transform.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/loader/transform.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
77
apps/public-web/node_modules/next/dist/build/babel/loader/types.d.ts
generated
vendored
Normal file
77
apps/public-web/node_modules/next/dist/build/babel/loader/types.d.ts
generated
vendored
Normal file
@@ -0,0 +1,77 @@
|
||||
import type { webpack } from 'next/dist/compiled/webpack/webpack'
|
||||
import type { JSONValue } from '../../../server/config-shared'
|
||||
import type { Span } from '../../../trace'
|
||||
|
||||
export interface NextJsLoaderContext extends webpack.LoaderContext<{}> {
|
||||
currentTraceSpan: Span
|
||||
target: string
|
||||
}
|
||||
|
||||
export interface NextBabelLoaderBaseOptions {
|
||||
cwd: string
|
||||
|
||||
/**
|
||||
* Should we read the user-provided custom babel config? Used in both `transformMode`s.
|
||||
*/
|
||||
configFile?: string
|
||||
|
||||
/**
|
||||
* Custom plugins to be added to the generated babel options.
|
||||
*/
|
||||
reactCompilerPlugins?: Array<JSONValue>
|
||||
|
||||
/**
|
||||
* Paths that the loader should not apply the react-compiler to.
|
||||
*/
|
||||
reactCompilerExclude?: (excludePath: string) => boolean
|
||||
|
||||
overrides?: any
|
||||
|
||||
/**
|
||||
* Extra fields to pass to presets/plugins via the Babel 'caller' API.
|
||||
*/
|
||||
caller?: any
|
||||
|
||||
/**
|
||||
* Advanced: Can override webpack's sourcemap behavior (see `NextJsLoaderContext["sourceMap"]`).
|
||||
*/
|
||||
sourceMaps?: boolean | 'inline' | 'both' | null | undefined
|
||||
}
|
||||
|
||||
/**
|
||||
* Options to create babel loader for the default transformations.
|
||||
*
|
||||
* This is primary usecase of babel-loader configuration for running
|
||||
* all of the necessary transforms for the ecmascript instead of swc loader.
|
||||
*/
|
||||
export type NextBabelLoaderOptionDefaultPresets = NextBabelLoaderBaseOptions & {
|
||||
transformMode: 'default'
|
||||
|
||||
isServer: boolean
|
||||
distDir: string
|
||||
pagesDir: string | undefined
|
||||
srcDir: string
|
||||
development: boolean
|
||||
hasJsxRuntime: boolean
|
||||
hasReactRefresh: boolean
|
||||
}
|
||||
|
||||
/**
|
||||
* Options to create babel loader for 'standalone' transformations.
|
||||
*
|
||||
* This'll create a babel loader does not enable any of the default Next.js
|
||||
* presets or plugins that perform transformations. Non-transforming syntax
|
||||
* plugins (e.g. Typescript) will still be enabled.
|
||||
*
|
||||
* This is useful when Babel is used in combination with SWC, and we expect SWC
|
||||
* to perform downleveling and Next.js-specific transforms. Standalone mode is
|
||||
* used in Turbopack and when React Compiler is used with webpack.
|
||||
*/
|
||||
export type NextBabelLoaderOptionStandalone = NextBabelLoaderBaseOptions & {
|
||||
transformMode: 'standalone'
|
||||
isServer: boolean
|
||||
}
|
||||
|
||||
export type NextBabelLoaderOptions =
|
||||
| NextBabelLoaderOptionDefaultPresets
|
||||
| NextBabelLoaderOptionStandalone
|
||||
16
apps/public-web/node_modules/next/dist/build/babel/loader/util.d.ts
generated
vendored
Normal file
16
apps/public-web/node_modules/next/dist/build/babel/loader/util.d.ts
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
import type { TransformOptions } from 'next/dist/compiled/babel/core';
|
||||
export declare function consumeIterator(iter: Iterator<any>): any;
|
||||
/**
|
||||
* Source map standard format as to revision 3.
|
||||
*
|
||||
* `TransformOptions` uses this type, but doesn't export it separately
|
||||
*/
|
||||
export type SourceMap = NonNullable<TransformOptions['inputSourceMap']>;
|
||||
/**
|
||||
* An extension of the normal babel configuration, with extra `babel-loader`-specific fields that transforms can read.
|
||||
*
|
||||
* See: https://github.com/babel/babel-loader/blob/main/src/injectCaller.js
|
||||
*/
|
||||
export type BabelLoaderTransformOptions = TransformOptions & {
|
||||
target?: string;
|
||||
};
|
||||
20
apps/public-web/node_modules/next/dist/build/babel/loader/util.js
generated
vendored
Normal file
20
apps/public-web/node_modules/next/dist/build/babel/loader/util.js
generated
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "consumeIterator", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return consumeIterator;
|
||||
}
|
||||
});
|
||||
function consumeIterator(iter) {
|
||||
while(true){
|
||||
const { value, done } = iter.next();
|
||||
if (done) {
|
||||
return value;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=util.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/loader/util.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/loader/util.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/loader/util.ts"],"sourcesContent":["import type { TransformOptions } from 'next/dist/compiled/babel/core'\n\nexport function consumeIterator(iter: Iterator<any>) {\n while (true) {\n const { value, done } = iter.next()\n if (done) {\n return value\n }\n }\n}\n\n/**\n * Source map standard format as to revision 3.\n *\n * `TransformOptions` uses this type, but doesn't export it separately\n */\nexport type SourceMap = NonNullable<TransformOptions['inputSourceMap']>\n\n/**\n * An extension of the normal babel configuration, with extra `babel-loader`-specific fields that transforms can read.\n *\n * See: https://github.com/babel/babel-loader/blob/main/src/injectCaller.js\n */\nexport type BabelLoaderTransformOptions = TransformOptions & {\n target?: string\n}\n"],"names":["consumeIterator","iter","value","done","next"],"mappings":";;;;+BAEgBA;;;eAAAA;;;AAAT,SAASA,gBAAgBC,IAAmB;IACjD,MAAO,KAAM;QACX,MAAM,EAAEC,KAAK,EAAEC,IAAI,EAAE,GAAGF,KAAKG,IAAI;QACjC,IAAID,MAAM;YACR,OAAOD;QACT;IACF;AACF","ignoreList":[0]}
|
||||
2
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.d.ts
generated
vendored
Normal file
2
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function CommonJSModulePlugin(...args: any): PluginObj;
|
||||
42
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.js
generated
vendored
Normal file
42
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.js
generated
vendored
Normal file
@@ -0,0 +1,42 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, // Handle module.exports in user code
|
||||
"default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return CommonJSModulePlugin;
|
||||
}
|
||||
});
|
||||
const _plugintransformmodulescommonjs = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/plugin-transform-modules-commonjs"));
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function CommonJSModulePlugin(...args) {
|
||||
const commonjs = (0, _plugintransformmodulescommonjs.default)(...args);
|
||||
return {
|
||||
visitor: {
|
||||
Program: {
|
||||
exit (path, state) {
|
||||
let foundModuleExports = false;
|
||||
path.traverse({
|
||||
MemberExpression (expressionPath) {
|
||||
if (expressionPath.node.object.name !== 'module') return;
|
||||
if (expressionPath.node.property.name !== 'exports') return;
|
||||
foundModuleExports = true;
|
||||
}
|
||||
});
|
||||
if (!foundModuleExports) {
|
||||
return;
|
||||
}
|
||||
commonjs.visitor.Program.exit.call(this, path, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=commonjs.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/commonjs.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/plugins/commonjs.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\nimport commonjsPlugin from 'next/dist/compiled/babel/plugin-transform-modules-commonjs'\n\n// Handle module.exports in user code\nexport default function CommonJSModulePlugin(...args: any): PluginObj {\n const commonjs = commonjsPlugin(...args)\n return {\n visitor: {\n Program: {\n exit(path: NodePath<types.Program>, state) {\n let foundModuleExports = false\n path.traverse({\n MemberExpression(expressionPath: any) {\n if (expressionPath.node.object.name !== 'module') return\n if (expressionPath.node.property.name !== 'exports') return\n foundModuleExports = true\n },\n })\n\n if (!foundModuleExports) {\n return\n }\n\n commonjs.visitor.Program.exit.call(this, path, state)\n },\n },\n },\n }\n}\n"],"names":["CommonJSModulePlugin","args","commonjs","commonjsPlugin","visitor","Program","exit","path","state","foundModuleExports","traverse","MemberExpression","expressionPath","node","object","name","property","call"],"mappings":";;;;+BAIA,qCAAqC;AACrC;;;eAAwBA;;;uFAHG;;;;;;AAGZ,SAASA,qBAAqB,GAAGC,IAAS;IACvD,MAAMC,WAAWC,IAAAA,uCAAc,KAAIF;IACnC,OAAO;QACLG,SAAS;YACPC,SAAS;gBACPC,MAAKC,IAA6B,EAAEC,KAAK;oBACvC,IAAIC,qBAAqB;oBACzBF,KAAKG,QAAQ,CAAC;wBACZC,kBAAiBC,cAAmB;4BAClC,IAAIA,eAAeC,IAAI,CAACC,MAAM,CAACC,IAAI,KAAK,UAAU;4BAClD,IAAIH,eAAeC,IAAI,CAACG,QAAQ,CAACD,IAAI,KAAK,WAAW;4BACrDN,qBAAqB;wBACvB;oBACF;oBAEA,IAAI,CAACA,oBAAoB;wBACvB;oBACF;oBAEAP,SAASE,OAAO,CAACC,OAAO,CAACC,IAAI,CAACW,IAAI,CAAC,IAAI,EAAEV,MAAMC;gBACjD;YACF;QACF;IACF;AACF","ignoreList":[0]}
|
||||
5
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.d.ts
generated
vendored
Normal file
5
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function ({ types: t, }: {
|
||||
types: typeof BabelTypes;
|
||||
}): PluginObj<any>;
|
||||
74
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.js
generated
vendored
Normal file
74
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.js
generated
vendored
Normal file
@@ -0,0 +1,74 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
const _pluginsyntaxjsx = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/babel/plugin-syntax-jsx"));
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function _default({ types: t }) {
|
||||
return {
|
||||
inherits: _pluginsyntaxjsx.default,
|
||||
visitor: {
|
||||
JSXElement (_path, state) {
|
||||
state.set('jsx', true);
|
||||
},
|
||||
// Fragment syntax is still JSX since it compiles to createElement(),
|
||||
// but JSXFragment is not a JSXElement
|
||||
JSXFragment (_path, state) {
|
||||
state.set('jsx', true);
|
||||
},
|
||||
Program: {
|
||||
exit (path, state) {
|
||||
if (state.get('jsx')) {
|
||||
const pragma = t.identifier(state.opts.pragma);
|
||||
let importAs = pragma;
|
||||
// if there's already a React in scope, use that instead of adding an import
|
||||
const existingBinding = state.opts.reuseImport !== false && state.opts.importAs && path.scope.getBinding(state.opts.importAs);
|
||||
// var _jsx = _pragma.createElement;
|
||||
if (state.opts.property) {
|
||||
if (state.opts.importAs) {
|
||||
importAs = t.identifier(state.opts.importAs);
|
||||
} else {
|
||||
importAs = path.scope.generateUidIdentifier('pragma');
|
||||
}
|
||||
const mapping = t.variableDeclaration('var', [
|
||||
t.variableDeclarator(pragma, t.memberExpression(importAs, t.identifier(state.opts.property)))
|
||||
]);
|
||||
// if the React binding came from a require('react'),
|
||||
// make sure that our usage comes after it.
|
||||
let newPath;
|
||||
if (existingBinding && t.isVariableDeclarator(existingBinding.path.node) && t.isCallExpression(existingBinding.path.node.init) && t.isIdentifier(existingBinding.path.node.init.callee) && existingBinding.path.node.init.callee.name === 'require') {
|
||||
;
|
||||
[newPath] = existingBinding.path.parentPath.insertAfter(mapping);
|
||||
} else {
|
||||
;
|
||||
[newPath] = path.unshiftContainer('body', mapping);
|
||||
}
|
||||
path.scope.registerDeclaration(newPath);
|
||||
}
|
||||
if (!existingBinding) {
|
||||
const importSpecifier = t.importDeclaration([
|
||||
state.opts.import ? t.importSpecifier(importAs, t.identifier(state.opts.import)) : state.opts.importNamespace ? t.importNamespaceSpecifier(importAs) : t.importDefaultSpecifier(importAs)
|
||||
], t.stringLiteral(state.opts.module || 'react'));
|
||||
const [newPath] = path.unshiftContainer('body', importSpecifier);
|
||||
for (const specifier of newPath.get('specifiers')){
|
||||
path.scope.registerBinding('module', specifier);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=jsx-pragma.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/jsx-pragma.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
2
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.d.ts
generated
vendored
Normal file
2
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function NextPageDisallowReExportAllExports(): PluginObj<any>;
|
||||
36
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.js
generated
vendored
Normal file
36
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.js
generated
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return NextPageDisallowReExportAllExports;
|
||||
}
|
||||
});
|
||||
function NextPageDisallowReExportAllExports() {
|
||||
return {
|
||||
visitor: {
|
||||
ImportDeclaration (path) {
|
||||
if ([
|
||||
'@next/font/local',
|
||||
'@next/font/google',
|
||||
'next/font/local',
|
||||
'next/font/google'
|
||||
].includes(path.node.source.value)) {
|
||||
var _path_node_loc, _path_node_loc1;
|
||||
const err = Object.defineProperty(new SyntaxError(`"next/font" requires SWC although Babel is being used due to a custom babel config being present.\nRead more: https://nextjs.org/docs/messages/babel-font-loader-conflict`), "__NEXT_ERROR_CODE", {
|
||||
value: "E542",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
err.code = 'BABEL_PARSE_ERROR';
|
||||
err.loc = ((_path_node_loc = path.node.loc) == null ? void 0 : _path_node_loc.start) ?? ((_path_node_loc1 = path.node.loc) == null ? void 0 : _path_node_loc1.end) ?? path.node.loc;
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=next-font-unsupported.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-font-unsupported.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/plugins/next-font-unsupported.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n\nexport default function NextPageDisallowReExportAllExports(): PluginObj<any> {\n return {\n visitor: {\n ImportDeclaration(path: NodePath<types.ImportDeclaration>) {\n if (\n [\n '@next/font/local',\n '@next/font/google',\n 'next/font/local',\n 'next/font/google',\n ].includes(path.node.source.value)\n ) {\n const err = new SyntaxError(\n `\"next/font\" requires SWC although Babel is being used due to a custom babel config being present.\\nRead more: https://nextjs.org/docs/messages/babel-font-loader-conflict`\n )\n ;(err as any).code = 'BABEL_PARSE_ERROR'\n ;(err as any).loc =\n path.node.loc?.start ?? path.node.loc?.end ?? path.node.loc\n throw err\n }\n },\n },\n }\n}\n"],"names":["NextPageDisallowReExportAllExports","visitor","ImportDeclaration","path","includes","node","source","value","err","SyntaxError","code","loc","start","end"],"mappings":";;;;+BAGA;;;eAAwBA;;;AAAT,SAASA;IACtB,OAAO;QACLC,SAAS;YACPC,mBAAkBC,IAAuC;gBACvD,IACE;oBACE;oBACA;oBACA;oBACA;iBACD,CAACC,QAAQ,CAACD,KAAKE,IAAI,CAACC,MAAM,CAACC,KAAK,GACjC;wBAMEJ,gBAAwBA;oBAL1B,MAAMK,MAAM,qBAEX,CAFW,IAAIC,YACd,CAAC,yKAAyK,CAAC,GADjK,qBAAA;+BAAA;oCAAA;sCAAA;oBAEZ;oBACED,IAAYE,IAAI,GAAG;oBACnBF,IAAYG,GAAG,GACfR,EAAAA,iBAAAA,KAAKE,IAAI,CAACM,GAAG,qBAAbR,eAAeS,KAAK,OAAIT,kBAAAA,KAAKE,IAAI,CAACM,GAAG,qBAAbR,gBAAeU,GAAG,KAAIV,KAAKE,IAAI,CAACM,GAAG;oBAC7D,MAAMH;gBACR;YACF;QACF;IACF;AACF","ignoreList":[0]}
|
||||
5
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.d.ts
generated
vendored
Normal file
5
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import { types as BabelTypes } from 'next/dist/compiled/babel/core';
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function nextPageConfig({ types: t, }: {
|
||||
types: typeof BabelTypes;
|
||||
}): PluginObj;
|
||||
104
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.js
generated
vendored
Normal file
104
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.js
generated
vendored
Normal file
@@ -0,0 +1,104 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, // config to parsing pageConfig for client bundles
|
||||
"default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return nextPageConfig;
|
||||
}
|
||||
});
|
||||
const _core = require("next/dist/compiled/babel/core");
|
||||
const CONFIG_KEY = 'config';
|
||||
function errorMessage(state, details) {
|
||||
const pageName = (state.filename || '').split(state.cwd || '').pop() || 'unknown';
|
||||
return `Invalid page config export found. ${details} in file ${pageName}. See: https://nextjs.org/docs/messages/invalid-page-config`;
|
||||
}
|
||||
function nextPageConfig({ types: t }) {
|
||||
return {
|
||||
visitor: {
|
||||
Program: {
|
||||
enter (path, state) {
|
||||
path.traverse({
|
||||
ExportDeclaration (exportPath, exportState) {
|
||||
var _exportPath_node_specifiers;
|
||||
if (_core.types.isExportNamedDeclaration(exportPath.node) && ((_exportPath_node_specifiers = exportPath.node.specifiers) == null ? void 0 : _exportPath_node_specifiers.some((specifier)=>{
|
||||
return (t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value) === CONFIG_KEY;
|
||||
})) && _core.types.isStringLiteral(exportPath.node.source)) {
|
||||
throw Object.defineProperty(new Error(errorMessage(exportState, 'Expected object but got export from')), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
},
|
||||
ExportNamedDeclaration (exportPath, exportState) {
|
||||
var _exportPath_node_declaration, _exportPath_scope_getBinding;
|
||||
if (exportState.bundleDropped || !exportPath.node.declaration && exportPath.node.specifiers.length === 0) {
|
||||
return;
|
||||
}
|
||||
const declarations = [
|
||||
...((_exportPath_node_declaration = exportPath.node.declaration) == null ? void 0 : _exportPath_node_declaration.declarations) || [],
|
||||
(_exportPath_scope_getBinding = exportPath.scope.getBinding(CONFIG_KEY)) == null ? void 0 : _exportPath_scope_getBinding.path.node
|
||||
].filter(Boolean);
|
||||
for (const specifier of exportPath.node.specifiers){
|
||||
if ((t.isIdentifier(specifier.exported) ? specifier.exported.name : specifier.exported.value) === CONFIG_KEY) {
|
||||
// export {} from 'somewhere'
|
||||
if (_core.types.isStringLiteral(exportPath.node.source)) {
|
||||
throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got import`)), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
// import hello from 'world'
|
||||
// export { hello as config }
|
||||
} else if (_core.types.isIdentifier(specifier.local)) {
|
||||
var _exportPath_scope_getBinding1;
|
||||
if (_core.types.isImportSpecifier((_exportPath_scope_getBinding1 = exportPath.scope.getBinding(specifier.local.name)) == null ? void 0 : _exportPath_scope_getBinding1.path.node)) {
|
||||
throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got import`)), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const declaration of declarations){
|
||||
if (!_core.types.isIdentifier(declaration.id, {
|
||||
name: CONFIG_KEY
|
||||
})) {
|
||||
continue;
|
||||
}
|
||||
let { init } = declaration;
|
||||
if (_core.types.isTSAsExpression(init)) {
|
||||
init = init.expression;
|
||||
}
|
||||
if (!_core.types.isObjectExpression(init)) {
|
||||
const got = init ? init.type : 'undefined';
|
||||
throw Object.defineProperty(new Error(errorMessage(exportState, `Expected object but got ${got}`)), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
for (const prop of init.properties){
|
||||
if (_core.types.isSpreadElement(prop)) {
|
||||
throw Object.defineProperty(new Error(errorMessage(exportState, `Property spread is not allowed`)), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=next-page-config.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-config.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
2
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.d.ts
generated
vendored
Normal file
2
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function NextPageDisallowReExportAllExports(): PluginObj<any>;
|
||||
29
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js
generated
vendored
Normal file
29
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js
generated
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return NextPageDisallowReExportAllExports;
|
||||
}
|
||||
});
|
||||
function NextPageDisallowReExportAllExports() {
|
||||
return {
|
||||
visitor: {
|
||||
ExportAllDeclaration (path) {
|
||||
var _path_node_loc, _path_node_loc1;
|
||||
const err = Object.defineProperty(new SyntaxError(`Using \`export * from '...'\` in a page is disallowed. Please use \`export { default } from '...'\` instead.\n` + `Read more: https://nextjs.org/docs/messages/export-all-in-page`), "__NEXT_ERROR_CODE", {
|
||||
value: "E555",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
err.code = 'BABEL_PARSE_ERROR';
|
||||
err.loc = ((_path_node_loc = path.node.loc) == null ? void 0 : _path_node_loc.start) ?? ((_path_node_loc1 = path.node.loc) == null ? void 0 : _path_node_loc1.end) ?? path.node.loc;
|
||||
throw err;
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=next-page-disallow-re-export-all-exports.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-page-disallow-re-export-all-exports.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/plugins/next-page-disallow-re-export-all-exports.ts"],"sourcesContent":["import type { NodePath, types } from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n\nexport default function NextPageDisallowReExportAllExports(): PluginObj<any> {\n return {\n visitor: {\n ExportAllDeclaration(path: NodePath<types.ExportAllDeclaration>) {\n const err = new SyntaxError(\n `Using \\`export * from '...'\\` in a page is disallowed. Please use \\`export { default } from '...'\\` instead.\\n` +\n `Read more: https://nextjs.org/docs/messages/export-all-in-page`\n )\n ;(err as any).code = 'BABEL_PARSE_ERROR'\n ;(err as any).loc =\n path.node.loc?.start ?? path.node.loc?.end ?? path.node.loc\n throw err\n },\n },\n }\n}\n"],"names":["NextPageDisallowReExportAllExports","visitor","ExportAllDeclaration","path","err","SyntaxError","code","loc","node","start","end"],"mappings":";;;;+BAGA;;;eAAwBA;;;AAAT,SAASA;IACtB,OAAO;QACLC,SAAS;YACPC,sBAAqBC,IAA0C;oBAO3DA,gBAAwBA;gBAN1B,MAAMC,MAAM,qBAGX,CAHW,IAAIC,YACd,CAAC,8GAA8G,CAAC,GAC9G,CAAC,8DAA8D,CAAC,GAFxD,qBAAA;2BAAA;gCAAA;kCAAA;gBAGZ;gBACED,IAAYE,IAAI,GAAG;gBACnBF,IAAYG,GAAG,GACfJ,EAAAA,iBAAAA,KAAKK,IAAI,CAACD,GAAG,qBAAbJ,eAAeM,KAAK,OAAIN,kBAAAA,KAAKK,IAAI,CAACD,GAAG,qBAAbJ,gBAAeO,GAAG,KAAIP,KAAKK,IAAI,CAACD,GAAG;gBAC7D,MAAMH;YACR;QACF;IACF;AACF","ignoreList":[0]}
|
||||
15
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.d.ts
generated
vendored
Normal file
15
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.d.ts
generated
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
import type { NodePath, types as BabelTypes } from 'next/dist/compiled/babel/core';
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export declare const EXPORT_NAME_GET_STATIC_PROPS = "getStaticProps";
|
||||
export declare const EXPORT_NAME_GET_STATIC_PATHS = "getStaticPaths";
|
||||
export declare const EXPORT_NAME_GET_SERVER_PROPS = "getServerSideProps";
|
||||
type PluginState = {
|
||||
refs: Set<NodePath<BabelTypes.Identifier>>;
|
||||
isPrerender: boolean;
|
||||
isServerProps: boolean;
|
||||
done: boolean;
|
||||
};
|
||||
export default function nextTransformSsg({ types: t, }: {
|
||||
types: typeof BabelTypes;
|
||||
}): PluginObj<PluginState>;
|
||||
export {};
|
||||
345
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.js
generated
vendored
Normal file
345
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.js
generated
vendored
Normal file
@@ -0,0 +1,345 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
EXPORT_NAME_GET_SERVER_PROPS: null,
|
||||
EXPORT_NAME_GET_STATIC_PATHS: null,
|
||||
EXPORT_NAME_GET_STATIC_PROPS: null,
|
||||
default: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
EXPORT_NAME_GET_SERVER_PROPS: function() {
|
||||
return EXPORT_NAME_GET_SERVER_PROPS;
|
||||
},
|
||||
EXPORT_NAME_GET_STATIC_PATHS: function() {
|
||||
return EXPORT_NAME_GET_STATIC_PATHS;
|
||||
},
|
||||
EXPORT_NAME_GET_STATIC_PROPS: function() {
|
||||
return EXPORT_NAME_GET_STATIC_PROPS;
|
||||
},
|
||||
default: function() {
|
||||
return nextTransformSsg;
|
||||
}
|
||||
});
|
||||
const _constants = require("../../../lib/constants");
|
||||
const _constants1 = require("../../../shared/lib/constants");
|
||||
const EXPORT_NAME_GET_STATIC_PROPS = 'getStaticProps';
|
||||
const EXPORT_NAME_GET_STATIC_PATHS = 'getStaticPaths';
|
||||
const EXPORT_NAME_GET_SERVER_PROPS = 'getServerSideProps';
|
||||
const ssgExports = new Set([
|
||||
EXPORT_NAME_GET_STATIC_PROPS,
|
||||
EXPORT_NAME_GET_STATIC_PATHS,
|
||||
EXPORT_NAME_GET_SERVER_PROPS,
|
||||
// legacy methods added so build doesn't fail from importing
|
||||
// server-side only methods
|
||||
`unstable_getStaticProps`,
|
||||
`unstable_getStaticPaths`,
|
||||
`unstable_getServerProps`,
|
||||
`unstable_getServerSideProps`
|
||||
]);
|
||||
function decorateSsgExport(t, path, state) {
|
||||
const gsspName = state.isPrerender ? _constants1.STATIC_PROPS_ID : _constants1.SERVER_PROPS_ID;
|
||||
const gsspId = t.identifier(gsspName);
|
||||
const addGsspExport = (exportPath)=>{
|
||||
if (state.done) {
|
||||
return;
|
||||
}
|
||||
state.done = true;
|
||||
const [pageCompPath] = exportPath.replaceWithMultiple([
|
||||
t.exportNamedDeclaration(t.variableDeclaration(// We use 'var' instead of 'let' or 'const' for ES5 support. Since
|
||||
// this runs in `Program#exit`, no ES2015 transforms (preset env)
|
||||
// will be ran against this code.
|
||||
'var', [
|
||||
t.variableDeclarator(gsspId, t.booleanLiteral(true))
|
||||
]), [
|
||||
t.exportSpecifier(gsspId, gsspId)
|
||||
]),
|
||||
exportPath.node
|
||||
]);
|
||||
exportPath.scope.registerDeclaration(pageCompPath);
|
||||
};
|
||||
path.traverse({
|
||||
ExportDefaultDeclaration (exportDefaultPath) {
|
||||
addGsspExport(exportDefaultPath);
|
||||
},
|
||||
ExportNamedDeclaration (exportNamedPath) {
|
||||
addGsspExport(exportNamedPath);
|
||||
}
|
||||
});
|
||||
}
|
||||
const isDataIdentifier = (name, state)=>{
|
||||
if (ssgExports.has(name)) {
|
||||
if (name === EXPORT_NAME_GET_SERVER_PROPS) {
|
||||
if (state.isPrerender) {
|
||||
throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
state.isServerProps = true;
|
||||
} else {
|
||||
if (state.isServerProps) {
|
||||
throw Object.defineProperty(new Error(_constants.SERVER_PROPS_SSG_CONFLICT), "__NEXT_ERROR_CODE", {
|
||||
value: "E394",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
state.isPrerender = true;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
};
|
||||
function nextTransformSsg({ types: t }) {
|
||||
function getIdentifier(path) {
|
||||
const parentPath = path.parentPath;
|
||||
if (parentPath.type === 'VariableDeclarator') {
|
||||
const pp = parentPath;
|
||||
const name = pp.get('id');
|
||||
return name.node.type === 'Identifier' ? name : null;
|
||||
}
|
||||
if (parentPath.type === 'AssignmentExpression') {
|
||||
const pp = parentPath;
|
||||
const name = pp.get('left');
|
||||
return name.node.type === 'Identifier' ? name : null;
|
||||
}
|
||||
if (path.node.type === 'ArrowFunctionExpression') {
|
||||
return null;
|
||||
}
|
||||
return path.node.id && path.node.id.type === 'Identifier' ? path.get('id') : null;
|
||||
}
|
||||
function isIdentifierReferenced(ident) {
|
||||
const b = ident.scope.getBinding(ident.node.name);
|
||||
if (b == null ? void 0 : b.referenced) {
|
||||
// Functions can reference themselves, so we need to check if there's a
|
||||
// binding outside the function scope or not.
|
||||
if (b.path.type === 'FunctionDeclaration') {
|
||||
return !b.constantViolations.concat(b.referencePaths)// Check that every reference is contained within the function:
|
||||
.every((ref)=>ref.findParent((p)=>p === b.path));
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function markFunction(path, state) {
|
||||
const ident = getIdentifier(path);
|
||||
if ((ident == null ? void 0 : ident.node) && isIdentifierReferenced(ident)) {
|
||||
state.refs.add(ident);
|
||||
}
|
||||
}
|
||||
function markImport(path, state) {
|
||||
const local = path.get('local');
|
||||
if (isIdentifierReferenced(local)) {
|
||||
state.refs.add(local);
|
||||
}
|
||||
}
|
||||
return {
|
||||
visitor: {
|
||||
Program: {
|
||||
enter (path, state) {
|
||||
state.refs = new Set();
|
||||
state.isPrerender = false;
|
||||
state.isServerProps = false;
|
||||
state.done = false;
|
||||
path.traverse({
|
||||
VariableDeclarator (variablePath, variableState) {
|
||||
if (variablePath.node.id.type === 'Identifier') {
|
||||
const local = variablePath.get('id');
|
||||
if (isIdentifierReferenced(local)) {
|
||||
variableState.refs.add(local);
|
||||
}
|
||||
} else if (variablePath.node.id.type === 'ObjectPattern') {
|
||||
const pattern = variablePath.get('id');
|
||||
const properties = pattern.get('properties');
|
||||
properties.forEach((p)=>{
|
||||
const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function() {
|
||||
throw Object.defineProperty(new Error('invariant'), "__NEXT_ERROR_CODE", {
|
||||
value: "E400",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}());
|
||||
if (isIdentifierReferenced(local)) {
|
||||
variableState.refs.add(local);
|
||||
}
|
||||
});
|
||||
} else if (variablePath.node.id.type === 'ArrayPattern') {
|
||||
const pattern = variablePath.get('id');
|
||||
const elements = pattern.get('elements');
|
||||
elements.forEach((e)=>{
|
||||
var _e_node, _e_node1;
|
||||
let local;
|
||||
if (((_e_node = e.node) == null ? void 0 : _e_node.type) === 'Identifier') {
|
||||
local = e;
|
||||
} else if (((_e_node1 = e.node) == null ? void 0 : _e_node1.type) === 'RestElement') {
|
||||
local = e.get('argument');
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
if (isIdentifierReferenced(local)) {
|
||||
variableState.refs.add(local);
|
||||
}
|
||||
});
|
||||
}
|
||||
},
|
||||
FunctionDeclaration: markFunction,
|
||||
FunctionExpression: markFunction,
|
||||
ArrowFunctionExpression: markFunction,
|
||||
ImportSpecifier: markImport,
|
||||
ImportDefaultSpecifier: markImport,
|
||||
ImportNamespaceSpecifier: markImport,
|
||||
ExportNamedDeclaration (exportNamedPath, exportNamedState) {
|
||||
const specifiers = exportNamedPath.get('specifiers');
|
||||
if (specifiers.length) {
|
||||
specifiers.forEach((s)=>{
|
||||
if (isDataIdentifier(t.isIdentifier(s.node.exported) ? s.node.exported.name : s.node.exported.value, exportNamedState)) {
|
||||
s.remove();
|
||||
}
|
||||
});
|
||||
if (exportNamedPath.node.specifiers.length < 1) {
|
||||
exportNamedPath.remove();
|
||||
}
|
||||
return;
|
||||
}
|
||||
const decl = exportNamedPath.get('declaration');
|
||||
if (decl == null || decl.node == null) {
|
||||
return;
|
||||
}
|
||||
switch(decl.node.type){
|
||||
case 'FunctionDeclaration':
|
||||
{
|
||||
const name = decl.node.id.name;
|
||||
if (isDataIdentifier(name, exportNamedState)) {
|
||||
exportNamedPath.remove();
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'VariableDeclaration':
|
||||
{
|
||||
const inner = decl.get('declarations');
|
||||
inner.forEach((d)=>{
|
||||
if (d.node.id.type !== 'Identifier') {
|
||||
return;
|
||||
}
|
||||
const name = d.node.id.name;
|
||||
if (isDataIdentifier(name, exportNamedState)) {
|
||||
d.remove();
|
||||
}
|
||||
});
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}, state);
|
||||
if (!state.isPrerender && !state.isServerProps) {
|
||||
return;
|
||||
}
|
||||
const refs = state.refs;
|
||||
let count;
|
||||
function sweepFunction(sweepPath) {
|
||||
const ident = getIdentifier(sweepPath);
|
||||
if ((ident == null ? void 0 : ident.node) && refs.has(ident) && !isIdentifierReferenced(ident)) {
|
||||
++count;
|
||||
if (t.isAssignmentExpression(sweepPath.parentPath.node) || t.isVariableDeclarator(sweepPath.parentPath.node)) {
|
||||
sweepPath.parentPath.remove();
|
||||
} else {
|
||||
sweepPath.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
function sweepImport(sweepPath) {
|
||||
const local = sweepPath.get('local');
|
||||
if (refs.has(local) && !isIdentifierReferenced(local)) {
|
||||
++count;
|
||||
sweepPath.remove();
|
||||
if (sweepPath.parent.specifiers.length === 0) {
|
||||
sweepPath.parentPath.remove();
|
||||
}
|
||||
}
|
||||
}
|
||||
do {
|
||||
;
|
||||
path.scope.crawl();
|
||||
count = 0;
|
||||
path.traverse({
|
||||
// eslint-disable-next-line no-loop-func
|
||||
VariableDeclarator (variablePath) {
|
||||
if (variablePath.node.id.type === 'Identifier') {
|
||||
const local = variablePath.get('id');
|
||||
if (refs.has(local) && !isIdentifierReferenced(local)) {
|
||||
++count;
|
||||
variablePath.remove();
|
||||
}
|
||||
} else if (variablePath.node.id.type === 'ObjectPattern') {
|
||||
const pattern = variablePath.get('id');
|
||||
const beforeCount = count;
|
||||
const properties = pattern.get('properties');
|
||||
properties.forEach((p)=>{
|
||||
const local = p.get(p.node.type === 'ObjectProperty' ? 'value' : p.node.type === 'RestElement' ? 'argument' : function() {
|
||||
throw Object.defineProperty(new Error('invariant'), "__NEXT_ERROR_CODE", {
|
||||
value: "E400",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}());
|
||||
if (refs.has(local) && !isIdentifierReferenced(local)) {
|
||||
++count;
|
||||
p.remove();
|
||||
}
|
||||
});
|
||||
if (beforeCount !== count && pattern.get('properties').length < 1) {
|
||||
variablePath.remove();
|
||||
}
|
||||
} else if (variablePath.node.id.type === 'ArrayPattern') {
|
||||
const pattern = variablePath.get('id');
|
||||
const beforeCount = count;
|
||||
const elements = pattern.get('elements');
|
||||
elements.forEach((e)=>{
|
||||
var _e_node, _e_node1;
|
||||
let local;
|
||||
if (((_e_node = e.node) == null ? void 0 : _e_node.type) === 'Identifier') {
|
||||
local = e;
|
||||
} else if (((_e_node1 = e.node) == null ? void 0 : _e_node1.type) === 'RestElement') {
|
||||
local = e.get('argument');
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
if (refs.has(local) && !isIdentifierReferenced(local)) {
|
||||
++count;
|
||||
e.remove();
|
||||
}
|
||||
});
|
||||
if (beforeCount !== count && pattern.get('elements').length < 1) {
|
||||
variablePath.remove();
|
||||
}
|
||||
}
|
||||
},
|
||||
FunctionDeclaration: sweepFunction,
|
||||
FunctionExpression: sweepFunction,
|
||||
ArrowFunctionExpression: sweepFunction,
|
||||
ImportSpecifier: sweepImport,
|
||||
ImportDefaultSpecifier: sweepImport,
|
||||
ImportNamespaceSpecifier: sweepImport
|
||||
});
|
||||
}while (count);
|
||||
decorateSsgExport(t, path, state);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=next-ssg-transform.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/next-ssg-transform.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
5
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.d.ts
generated
vendored
Normal file
5
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.d.ts
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function ({ types: t, }: {
|
||||
types: typeof BabelTypes;
|
||||
}): PluginObj<any>;
|
||||
60
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js
generated
vendored
Normal file
60
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js
generated
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
// matches any hook-like (the default)
|
||||
const isHook = /^use[A-Z]/;
|
||||
// matches only built-in hooks provided by React et al
|
||||
const isBuiltInHook = /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/;
|
||||
function _default({ types: t }) {
|
||||
const visitor = {
|
||||
CallExpression (path, state) {
|
||||
const onlyBuiltIns = state.opts.onlyBuiltIns;
|
||||
// if specified, options.lib is a list of libraries that provide hook functions
|
||||
const libs = state.opts.lib && (state.opts.lib === true ? [
|
||||
'react',
|
||||
'preact/hooks'
|
||||
] : [].concat(state.opts.lib));
|
||||
// skip function calls that are not the init of a variable declaration:
|
||||
if (!t.isVariableDeclarator(path.parent)) return;
|
||||
// skip function calls where the return value is not Array-destructured:
|
||||
if (!t.isArrayPattern(path.parent.id)) return;
|
||||
// name of the (hook) function being called:
|
||||
const hookName = path.node.callee.name;
|
||||
if (libs) {
|
||||
const binding = path.scope.getBinding(hookName);
|
||||
// not an import
|
||||
if (!binding || binding.kind !== 'module') return;
|
||||
const specifier = binding.path.parent.source.value;
|
||||
// not a match
|
||||
if (!libs.some((lib)=>lib === specifier)) return;
|
||||
}
|
||||
// only match function calls with names that look like a hook
|
||||
if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName)) return;
|
||||
path.parent.id = t.objectPattern(path.parent.id.elements.reduce((patterns, element, i)=>{
|
||||
if (element === null) {
|
||||
return patterns;
|
||||
}
|
||||
return patterns.concat(t.objectProperty(t.numericLiteral(i), // TODO: fix this
|
||||
element));
|
||||
}, []));
|
||||
}
|
||||
};
|
||||
return {
|
||||
name: 'optimize-hook-destructuring',
|
||||
visitor: {
|
||||
// this is a workaround to run before preset-env destroys destructured assignments
|
||||
Program (path, state) {
|
||||
path.traverse(visitor, state);
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=optimize-hook-destructuring.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/optimize-hook-destructuring.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../../../src/build/babel/plugins/optimize-hook-destructuring.ts"],"sourcesContent":["import type {\n NodePath,\n types as BabelTypes,\n} from 'next/dist/compiled/babel/core'\nimport type { PluginObj } from 'next/dist/compiled/babel/core'\n// matches any hook-like (the default)\nconst isHook = /^use[A-Z]/\n\n// matches only built-in hooks provided by React et al\nconst isBuiltInHook =\n /^use(Callback|Context|DebugValue|Effect|ImperativeHandle|LayoutEffect|Memo|Reducer|Ref|State)$/\n\nexport default function ({\n types: t,\n}: {\n types: typeof BabelTypes\n}): PluginObj<any> {\n const visitor = {\n CallExpression(path: NodePath<BabelTypes.CallExpression>, state: any) {\n const onlyBuiltIns = state.opts.onlyBuiltIns\n\n // if specified, options.lib is a list of libraries that provide hook functions\n const libs =\n state.opts.lib &&\n (state.opts.lib === true\n ? ['react', 'preact/hooks']\n : [].concat(state.opts.lib))\n\n // skip function calls that are not the init of a variable declaration:\n if (!t.isVariableDeclarator(path.parent)) return\n\n // skip function calls where the return value is not Array-destructured:\n if (!t.isArrayPattern(path.parent.id)) return\n\n // name of the (hook) function being called:\n const hookName = (path.node.callee as BabelTypes.Identifier).name\n\n if (libs) {\n const binding = path.scope.getBinding(hookName)\n // not an import\n if (!binding || binding.kind !== 'module') return\n\n const specifier = (binding.path.parent as BabelTypes.ImportDeclaration)\n .source.value\n // not a match\n if (!libs.some((lib: any) => lib === specifier)) return\n }\n\n // only match function calls with names that look like a hook\n if (!(onlyBuiltIns ? isBuiltInHook : isHook).test(hookName)) return\n\n path.parent.id = t.objectPattern(\n path.parent.id.elements.reduce<Array<BabelTypes.ObjectProperty>>(\n (patterns, element, i) => {\n if (element === null) {\n return patterns\n }\n\n return patterns.concat(\n t.objectProperty(\n t.numericLiteral(i),\n // TODO: fix this\n element as Exclude<\n typeof element,\n BabelTypes.MemberExpression | BabelTypes.TSParameterProperty\n >\n )\n )\n },\n []\n )\n )\n },\n }\n\n return {\n name: 'optimize-hook-destructuring',\n visitor: {\n // this is a workaround to run before preset-env destroys destructured assignments\n Program(path, state) {\n path.traverse(visitor, state)\n },\n },\n }\n}\n"],"names":["isHook","isBuiltInHook","types","t","visitor","CallExpression","path","state","onlyBuiltIns","opts","libs","lib","concat","isVariableDeclarator","parent","isArrayPattern","id","hookName","node","callee","name","binding","scope","getBinding","kind","specifier","source","value","some","test","objectPattern","elements","reduce","patterns","element","i","objectProperty","numericLiteral","Program","traverse"],"mappings":";;;;+BAYA;;;eAAA;;;AAPA,sCAAsC;AACtC,MAAMA,SAAS;AAEf,sDAAsD;AACtD,MAAMC,gBACJ;AAEa,SAAf,SAAyB,EACvBC,OAAOC,CAAC,EAGT;IACC,MAAMC,UAAU;QACdC,gBAAeC,IAAyC,EAAEC,KAAU;YAClE,MAAMC,eAAeD,MAAME,IAAI,CAACD,YAAY;YAE5C,+EAA+E;YAC/E,MAAME,OACJH,MAAME,IAAI,CAACE,GAAG,IACbJ,CAAAA,MAAME,IAAI,CAACE,GAAG,KAAK,OAChB;gBAAC;gBAAS;aAAe,GACzB,EAAE,CAACC,MAAM,CAACL,MAAME,IAAI,CAACE,GAAG,CAAA;YAE9B,uEAAuE;YACvE,IAAI,CAACR,EAAEU,oBAAoB,CAACP,KAAKQ,MAAM,GAAG;YAE1C,wEAAwE;YACxE,IAAI,CAACX,EAAEY,cAAc,CAACT,KAAKQ,MAAM,CAACE,EAAE,GAAG;YAEvC,4CAA4C;YAC5C,MAAMC,WAAW,AAACX,KAAKY,IAAI,CAACC,MAAM,CAA2BC,IAAI;YAEjE,IAAIV,MAAM;gBACR,MAAMW,UAAUf,KAAKgB,KAAK,CAACC,UAAU,CAACN;gBACtC,gBAAgB;gBAChB,IAAI,CAACI,WAAWA,QAAQG,IAAI,KAAK,UAAU;gBAE3C,MAAMC,YAAY,AAACJ,QAAQf,IAAI,CAACQ,MAAM,CACnCY,MAAM,CAACC,KAAK;gBACf,cAAc;gBACd,IAAI,CAACjB,KAAKkB,IAAI,CAAC,CAACjB,MAAaA,QAAQc,YAAY;YACnD;YAEA,6DAA6D;YAC7D,IAAI,CAAC,AAACjB,CAAAA,eAAeP,gBAAgBD,MAAK,EAAG6B,IAAI,CAACZ,WAAW;YAE7DX,KAAKQ,MAAM,CAACE,EAAE,GAAGb,EAAE2B,aAAa,CAC9BxB,KAAKQ,MAAM,CAACE,EAAE,CAACe,QAAQ,CAACC,MAAM,CAC5B,CAACC,UAAUC,SAASC;gBAClB,IAAID,YAAY,MAAM;oBACpB,OAAOD;gBACT;gBAEA,OAAOA,SAASrB,MAAM,CACpBT,EAAEiC,cAAc,CACdjC,EAAEkC,cAAc,CAACF,IACjB,iBAAiB;gBACjBD;YAMN,GACA,EAAE;QAGR;IACF;IAEA,OAAO;QACLd,MAAM;QACNhB,SAAS;YACP,kFAAkF;YAClFkC,SAAQhC,IAAI,EAAEC,KAAK;gBACjBD,KAAKiC,QAAQ,CAACnC,SAASG;YACzB;QACF;IACF;AACF","ignoreList":[0]}
|
||||
25
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.d.ts
generated
vendored
Normal file
25
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.d.ts
generated
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
/**
|
||||
COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
|
||||
MIT License
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWAR
|
||||
*/
|
||||
import type { types as BabelTypes } from 'next/dist/compiled/babel/core';
|
||||
import type { PluginObj } from 'next/dist/compiled/babel/core';
|
||||
export default function ({ types: t, }: {
|
||||
types: typeof BabelTypes;
|
||||
}): PluginObj;
|
||||
145
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.js
generated
vendored
Normal file
145
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.js
generated
vendored
Normal file
@@ -0,0 +1,145 @@
|
||||
/**
|
||||
COPYRIGHT (c) 2017-present James Kyle <me@thejameskyle.com>
|
||||
MIT License
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
"Software"), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
||||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
||||
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
||||
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWAR
|
||||
*/ // This file is https://github.com/jamiebuilds/react-loadable/blob/master/src/babel.js
|
||||
// - Modified to also look for `next/dynamic`
|
||||
// - Modified to put `webpack` and `modules` under `loadableGenerated` to be
|
||||
// backwards compatible with next/dynamic which has a `modules` key
|
||||
// - Modified to support `dynamic(import('something'))` and
|
||||
// `dynamic(import('something'), options)
|
||||
// - Removed `Loadable.Map` support, `next/dynamic` uses overloaded arguments
|
||||
// instead of a separate API
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
const _path = require("path");
|
||||
function _default({ types: t }) {
|
||||
return {
|
||||
visitor: {
|
||||
ImportDeclaration (path, state) {
|
||||
let source = path.node.source.value;
|
||||
if (source !== 'next/dynamic') return;
|
||||
let defaultSpecifier = path.get('specifiers').find((specifier)=>{
|
||||
return specifier.isImportDefaultSpecifier();
|
||||
});
|
||||
if (!defaultSpecifier) return;
|
||||
const bindingName = defaultSpecifier.node.local.name;
|
||||
const binding = path.scope.getBinding(bindingName);
|
||||
if (!binding) {
|
||||
return;
|
||||
}
|
||||
binding.referencePaths.forEach((refPath)=>{
|
||||
var _state_file_opts_caller, _state_file_opts_caller1;
|
||||
let callExpression = refPath.parentPath;
|
||||
if (!(callExpression == null ? void 0 : callExpression.isCallExpression())) return;
|
||||
let args = callExpression.get('arguments');
|
||||
if (args.length > 2) {
|
||||
throw callExpression.buildCodeFrameError('next/dynamic only accepts 2 arguments');
|
||||
}
|
||||
if (!args[0]) {
|
||||
return;
|
||||
}
|
||||
let loader;
|
||||
let options;
|
||||
if (args[0].isObjectExpression()) {
|
||||
options = args[0];
|
||||
} else {
|
||||
if (!args[1]) {
|
||||
callExpression.node.arguments.push(t.objectExpression([]));
|
||||
}
|
||||
// This is needed as the code is modified above
|
||||
args = callExpression.get('arguments');
|
||||
loader = args[0];
|
||||
options = args[1];
|
||||
}
|
||||
if (!options.isObjectExpression()) return;
|
||||
const options_ = options;
|
||||
let properties = options_.get('properties');
|
||||
let propertiesMap = {};
|
||||
properties.forEach((property)=>{
|
||||
const key = property.get('key');
|
||||
propertiesMap[key.node.name] = property;
|
||||
});
|
||||
if (propertiesMap.loadableGenerated) {
|
||||
return;
|
||||
}
|
||||
if (propertiesMap.loader) {
|
||||
loader = propertiesMap.loader.get('value');
|
||||
}
|
||||
if (propertiesMap.modules) {
|
||||
loader = propertiesMap.modules.get('value');
|
||||
}
|
||||
if (!loader || Array.isArray(loader)) {
|
||||
return;
|
||||
}
|
||||
const dynamicImports = [];
|
||||
const dynamicKeys = [];
|
||||
if (propertiesMap.ssr) {
|
||||
const ssr = propertiesMap.ssr.get('value');
|
||||
const nodePath = Array.isArray(ssr) ? undefined : ssr;
|
||||
if (nodePath) {
|
||||
var _state_file_opts_caller2;
|
||||
const nonSSR = nodePath.node.type === 'BooleanLiteral' && nodePath.node.value === false;
|
||||
// If `ssr` is set to `false`, erase the loader for server side
|
||||
if (nonSSR && loader && ((_state_file_opts_caller2 = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller2.isServer)) {
|
||||
loader.replaceWith(t.arrowFunctionExpression([], t.nullLiteral(), true));
|
||||
}
|
||||
}
|
||||
}
|
||||
loader.traverse({
|
||||
Import (importPath) {
|
||||
var _state_file_opts_caller;
|
||||
const importArguments = importPath.parentPath.get('arguments');
|
||||
if (!Array.isArray(importArguments)) return;
|
||||
const node = importArguments[0].node;
|
||||
dynamicImports.push(node);
|
||||
dynamicKeys.push(t.binaryExpression('+', t.stringLiteral((((_state_file_opts_caller = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller.srcDir) ? (0, _path.relative)(state.file.opts.caller.srcDir, state.file.opts.filename) : state.file.opts.filename) + ' -> '), node));
|
||||
}
|
||||
});
|
||||
if (!dynamicImports.length) return;
|
||||
options.node.properties.push(t.objectProperty(t.identifier('loadableGenerated'), t.objectExpression(((_state_file_opts_caller = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller.isDev) || ((_state_file_opts_caller1 = state.file.opts.caller) == null ? void 0 : _state_file_opts_caller1.isServer) ? [
|
||||
t.objectProperty(t.identifier('modules'), t.arrayExpression(dynamicKeys))
|
||||
] : [
|
||||
t.objectProperty(t.identifier('webpack'), t.arrowFunctionExpression([], t.arrayExpression(dynamicImports.map((dynamicImport)=>{
|
||||
return t.callExpression(t.memberExpression(t.identifier('require'), t.identifier('resolveWeak')), [
|
||||
dynamicImport
|
||||
]);
|
||||
}))))
|
||||
])));
|
||||
// Turns `dynamic(import('something'))` into `dynamic(() => import('something'))` for backwards compat.
|
||||
// This is the replicate the behavior in versions below Next.js 7 where we magically handled not executing the `import()` too.
|
||||
// We'll deprecate this behavior and provide a codemod for it in 7.1.
|
||||
if (loader.isCallExpression()) {
|
||||
const arrowFunction = t.arrowFunctionExpression([], loader.node);
|
||||
loader.replaceWith(arrowFunction);
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=react-loadable-plugin.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/plugins/react-loadable-plugin.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
43
apps/public-web/node_modules/next/dist/build/babel/preset.d.ts
generated
vendored
Normal file
43
apps/public-web/node_modules/next/dist/build/babel/preset.d.ts
generated
vendored
Normal file
@@ -0,0 +1,43 @@
|
||||
import type { PluginItem } from 'next/dist/compiled/babel/core';
|
||||
type StyledJsxPlugin = [string, any] | string;
|
||||
type StyledJsxBabelOptions = {
|
||||
plugins?: StyledJsxPlugin[];
|
||||
styleModule?: string;
|
||||
'babel-test'?: boolean;
|
||||
} | undefined;
|
||||
type NextBabelPresetOptions = {
|
||||
'preset-env'?: any;
|
||||
'preset-react'?: any;
|
||||
'class-properties'?: any;
|
||||
'transform-runtime'?: any;
|
||||
'styled-jsx'?: StyledJsxBabelOptions;
|
||||
/**
|
||||
* `syntax-typescript` is a subset of `preset-typescript`.
|
||||
*
|
||||
* - When babel is used in "standalone" mode (e.g. alongside SWC when using
|
||||
* react-compiler or turbopack) we'll prefer the options in
|
||||
* 'syntax-typescript`, and fall back to `preset-typescript`.
|
||||
*
|
||||
* - When babel is used in "default" mode (e.g. with a babel config in
|
||||
* webpack) we'll prefer the options in `preset-typescript`, and fall back
|
||||
* to `syntax-typescript`.
|
||||
*/
|
||||
'preset-typescript'?: any;
|
||||
'syntax-typescript'?: {
|
||||
disallowAmbiguousJSXLike?: boolean;
|
||||
dts?: boolean;
|
||||
isTSX?: boolean;
|
||||
allExtensions?: boolean;
|
||||
ignoreExtensions?: boolean;
|
||||
};
|
||||
};
|
||||
type BabelPreset = {
|
||||
presets?: PluginItem[] | null;
|
||||
plugins?: PluginItem[] | null;
|
||||
sourceType?: 'script' | 'module' | 'unambiguous';
|
||||
overrides?: Array<{
|
||||
test: RegExp;
|
||||
} & Omit<BabelPreset, 'overrides'>>;
|
||||
};
|
||||
declare const _default: (api: any, options?: NextBabelPresetOptions) => BabelPreset;
|
||||
export default _default;
|
||||
250
apps/public-web/node_modules/next/dist/build/babel/preset.js
generated
vendored
Normal file
250
apps/public-web/node_modules/next/dist/build/babel/preset.js
generated
vendored
Normal file
@@ -0,0 +1,250 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "default", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return _default;
|
||||
}
|
||||
});
|
||||
const _path = require("path");
|
||||
const isLoadIntentTest = process.env.NODE_ENV === 'test';
|
||||
const isLoadIntentDevelopment = process.env.NODE_ENV === 'development';
|
||||
// Resolve styled-jsx plugins
|
||||
function styledJsxOptions(options) {
|
||||
options = options || {};
|
||||
options.styleModule = 'styled-jsx/style';
|
||||
if (!Array.isArray(options.plugins)) {
|
||||
return options;
|
||||
}
|
||||
options.plugins = options.plugins.map((plugin)=>{
|
||||
if (Array.isArray(plugin)) {
|
||||
const [name, pluginOptions] = plugin;
|
||||
return [
|
||||
require.resolve(name),
|
||||
pluginOptions
|
||||
];
|
||||
}
|
||||
return require.resolve(plugin);
|
||||
});
|
||||
return options;
|
||||
}
|
||||
// Taken from https://github.com/babel/babel/commit/d60c5e1736543a6eac4b549553e107a9ba967051#diff-b4beead8ad9195361b4537601cc22532R158
|
||||
function supportsStaticESM(caller) {
|
||||
return !!(caller == null ? void 0 : caller.supportsStaticESM);
|
||||
}
|
||||
/**
|
||||
* HACK: A drop-in replacement for `@babel/preset-typescript` that only enables
|
||||
* `@babel/plugin-syntax-typescript` and does not transform the typescript.
|
||||
*
|
||||
* This is used for standalone mode, where Babel is being used alongside SWC
|
||||
* (i.e. Turbopack or with React Compiler on webpack).
|
||||
*
|
||||
* This should match the logic/behavior here:
|
||||
* https://github.com/babel/babel/blob/7f57d3a2e97b7e2800fb82cff9284a3591377971/packages/babel-preset-typescript/src/index.ts#L63
|
||||
*/ function presetTypescriptSyntaxOnly(_api, options) {
|
||||
const { allExtensions, ignoreExtensions, ...restOptions } = options;
|
||||
const disableExtensionDetect = allExtensions || ignoreExtensions;
|
||||
function getPlugins(isTSX, disallowAmbiguousJSXLike) {
|
||||
return [
|
||||
[
|
||||
require('next/dist/compiled/babel/plugin-syntax-typescript'),
|
||||
{
|
||||
isTSX,
|
||||
disallowAmbiguousJSXLike,
|
||||
...restOptions
|
||||
}
|
||||
]
|
||||
];
|
||||
}
|
||||
return {
|
||||
plugins: [],
|
||||
overrides: disableExtensionDetect ? [
|
||||
{
|
||||
plugins: getPlugins(options.isTSX, options.disallowAmbiguousJSXLike)
|
||||
}
|
||||
] : // Babel is being called with a filename.
|
||||
[
|
||||
{
|
||||
test: /\.ts$/,
|
||||
plugins: getPlugins(false, false)
|
||||
},
|
||||
{
|
||||
test: /\.mts$/,
|
||||
sourceType: 'module',
|
||||
plugins: getPlugins(false, true)
|
||||
},
|
||||
{
|
||||
test: /\.cts$/,
|
||||
sourceType: 'unambiguous',
|
||||
plugins: getPlugins(false, true)
|
||||
},
|
||||
{
|
||||
test: /\.tsx$/,
|
||||
plugins: getPlugins(true, false)
|
||||
}
|
||||
]
|
||||
};
|
||||
}
|
||||
const _default = (api, options = {})=>{
|
||||
var _options_presetreact, _options_presetreact1;
|
||||
const isStandalone = api.caller(// NOTE: `transformMode` may be undefined if the user configured `babel-loader` themselves. In
|
||||
// this case, we should assume we're in 'default' mode.
|
||||
(caller)=>!!caller && caller.transformMode === 'standalone');
|
||||
const isServer = api.caller((caller)=>!!caller && caller.isServer);
|
||||
// syntax plugins that are used in both standalone and default modes
|
||||
const sharedSyntaxPlugins = [
|
||||
require('next/dist/compiled/babel/plugin-syntax-dynamic-import'),
|
||||
[
|
||||
require('next/dist/compiled/babel/plugin-syntax-import-attributes'),
|
||||
{
|
||||
deprecatedAssertSyntax: true
|
||||
}
|
||||
],
|
||||
(isStandalone || isServer) && require('next/dist/compiled/babel/plugin-syntax-bigint')
|
||||
].filter(Boolean);
|
||||
if (isStandalone) {
|
||||
// Just enable a few syntax plugins, we'll let SWC handle any of the downleveling or
|
||||
// next.js-specific transforms.
|
||||
return {
|
||||
sourceType: 'unambiguous',
|
||||
presets: [
|
||||
[
|
||||
presetTypescriptSyntaxOnly,
|
||||
options['syntax-typescript'] ?? options['preset-typescript'] ?? {}
|
||||
]
|
||||
],
|
||||
plugins: [
|
||||
require('next/dist/compiled/babel/plugin-syntax-jsx'),
|
||||
...sharedSyntaxPlugins
|
||||
]
|
||||
};
|
||||
}
|
||||
const supportsESM = api.caller(supportsStaticESM);
|
||||
const isCallerDevelopment = api.caller((caller)=>caller == null ? void 0 : caller.isDev);
|
||||
// Look at external intent if used without a caller (e.g. via Jest):
|
||||
const isTest = isCallerDevelopment == null && isLoadIntentTest;
|
||||
// Look at external intent if used without a caller (e.g. Storybook):
|
||||
const isDevelopment = isCallerDevelopment === true || isCallerDevelopment == null && isLoadIntentDevelopment;
|
||||
// Default to production mode if not `test` nor `development`:
|
||||
const isProduction = !(isTest || isDevelopment);
|
||||
const isBabelLoader = api.caller((caller)=>!!caller && (caller.name === 'babel-loader' || caller.name === 'next-babel-turbo-loader'));
|
||||
const useJsxRuntime = ((_options_presetreact = options['preset-react']) == null ? void 0 : _options_presetreact.runtime) === 'automatic' || Boolean(api.caller((caller)=>!!caller && caller.hasJsxRuntime)) && ((_options_presetreact1 = options['preset-react']) == null ? void 0 : _options_presetreact1.runtime) !== 'classic';
|
||||
const presetEnvConfig = {
|
||||
// In the test environment `modules` is often needed to be set to true, babel figures that out by itself using the `'auto'` option
|
||||
// In production/development this option is set to `false` so that webpack can handle import/export with tree-shaking
|
||||
modules: 'auto',
|
||||
exclude: [
|
||||
'transform-typeof-symbol'
|
||||
],
|
||||
...options['preset-env']
|
||||
};
|
||||
// When transpiling for the server or tests, target the current Node version
|
||||
// if not explicitly specified:
|
||||
if ((isServer || isTest) && (!presetEnvConfig.targets || !(typeof presetEnvConfig.targets === 'object' && 'node' in presetEnvConfig.targets))) {
|
||||
presetEnvConfig.targets = {
|
||||
// Targets the current process' version of Node. This requires apps be
|
||||
// built and deployed on the same version of Node.
|
||||
// This is the same as using "current" but explicit
|
||||
node: process.versions.node
|
||||
};
|
||||
}
|
||||
const runtimeModuleName = isBabelLoader ? 'next/dist/compiled/@babel/runtime' : null;
|
||||
return {
|
||||
sourceType: 'unambiguous',
|
||||
presets: [
|
||||
[
|
||||
require('next/dist/compiled/babel/preset-env'),
|
||||
presetEnvConfig
|
||||
],
|
||||
[
|
||||
require('next/dist/compiled/babel/preset-react'),
|
||||
{
|
||||
// This adds @babel/plugin-transform-react-jsx-source and
|
||||
// @babel/plugin-transform-react-jsx-self automatically in development
|
||||
development: isDevelopment || isTest,
|
||||
...useJsxRuntime ? {
|
||||
runtime: 'automatic'
|
||||
} : {
|
||||
pragma: '__jsx'
|
||||
},
|
||||
...options['preset-react']
|
||||
}
|
||||
],
|
||||
[
|
||||
require('next/dist/compiled/babel/preset-typescript'),
|
||||
{
|
||||
allowNamespaces: true,
|
||||
...options['preset-typescript'] || options['syntax-typescript']
|
||||
}
|
||||
]
|
||||
],
|
||||
plugins: [
|
||||
...sharedSyntaxPlugins,
|
||||
!useJsxRuntime && [
|
||||
require('./plugins/jsx-pragma'),
|
||||
{
|
||||
// This produces the following injected import for modules containing JSX:
|
||||
// import React from 'react';
|
||||
// var __jsx = React.createElement;
|
||||
module: 'react',
|
||||
importAs: 'React',
|
||||
pragma: '__jsx',
|
||||
property: 'createElement'
|
||||
}
|
||||
],
|
||||
[
|
||||
require('./plugins/optimize-hook-destructuring'),
|
||||
{
|
||||
// only optimize hook functions imported from React/Preact
|
||||
lib: true
|
||||
}
|
||||
],
|
||||
require('./plugins/react-loadable-plugin'),
|
||||
// only enable this plugin if custom config for it was provided
|
||||
// otherwise we will only enable it if their browserslist triggers
|
||||
// preset-env to pull it in
|
||||
options['class-properties'] && [
|
||||
require('next/dist/compiled/babel/plugin-proposal-class-properties'),
|
||||
options['class-properties'] || {}
|
||||
],
|
||||
[
|
||||
require('next/dist/compiled/babel/plugin-proposal-object-rest-spread'),
|
||||
{
|
||||
useBuiltIns: true
|
||||
}
|
||||
],
|
||||
!isServer && [
|
||||
require('next/dist/compiled/babel/plugin-transform-runtime'),
|
||||
{
|
||||
corejs: false,
|
||||
helpers: true,
|
||||
regenerator: true,
|
||||
useESModules: supportsESM && presetEnvConfig.modules !== 'commonjs',
|
||||
absoluteRuntime: runtimeModuleName != null ? (0, _path.dirname)(require.resolve(`${runtimeModuleName}/package.json`)) : undefined,
|
||||
// regenerator needs `moduleName` to be set in addition to
|
||||
// `absoluteRuntime`.
|
||||
moduleName: runtimeModuleName,
|
||||
...options['transform-runtime']
|
||||
}
|
||||
],
|
||||
[
|
||||
isTest && options['styled-jsx'] && options['styled-jsx']['babel-test'] ? require('styled-jsx/babel-test') : require('styled-jsx/babel'),
|
||||
styledJsxOptions(options['styled-jsx'])
|
||||
],
|
||||
isProduction && [
|
||||
require('next/dist/compiled/babel/plugin-transform-react-remove-prop-types'),
|
||||
{
|
||||
removeImport: true
|
||||
}
|
||||
],
|
||||
// Always compile numeric separator because the resulting number is
|
||||
// smaller.
|
||||
require('next/dist/compiled/babel/plugin-proposal-numeric-separator'),
|
||||
require('next/dist/compiled/babel/plugin-proposal-export-namespace-from')
|
||||
].filter(Boolean)
|
||||
};
|
||||
};
|
||||
|
||||
//# sourceMappingURL=preset.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/babel/preset.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/babel/preset.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
56
apps/public-web/node_modules/next/dist/build/build-context.d.ts
generated
vendored
Normal file
56
apps/public-web/node_modules/next/dist/build/build-context.d.ts
generated
vendored
Normal file
@@ -0,0 +1,56 @@
|
||||
import type { LoadedEnvFiles } from '@next/env';
|
||||
import type { Rewrite, Redirect } from '../lib/load-custom-routes';
|
||||
import type { __ApiPreviewProps } from '../server/api-utils';
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { Span } from '../trace';
|
||||
import type getBaseWebpackConfig from './webpack-config';
|
||||
import type { TelemetryPluginState } from './webpack/plugins/telemetry-plugin/telemetry-plugin';
|
||||
import type { Telemetry } from '../telemetry/storage';
|
||||
export declare function resumePluginState(resumedState?: Record<string, any>): void;
|
||||
export declare function getProxiedPluginState<State extends Record<string, any>>(initialState: State): State;
|
||||
export declare function getPluginState(): Record<string, any>;
|
||||
export interface MappedPages {
|
||||
[page: string]: string;
|
||||
}
|
||||
export declare const NextBuildContext: Partial<{
|
||||
compilerIdx?: number;
|
||||
pluginState: Record<string, any>;
|
||||
dir: string;
|
||||
distDir: string;
|
||||
buildId: string;
|
||||
encryptionKey: string;
|
||||
config: NextConfigComplete;
|
||||
appDir: string;
|
||||
pagesDir: string;
|
||||
rewrites: {
|
||||
fallback: Rewrite[];
|
||||
afterFiles: Rewrite[];
|
||||
beforeFiles: Rewrite[];
|
||||
};
|
||||
originalRewrites: {
|
||||
fallback: Rewrite[];
|
||||
afterFiles: Rewrite[];
|
||||
beforeFiles: Rewrite[];
|
||||
};
|
||||
hasRewrites: boolean;
|
||||
originalRedirects: Redirect[];
|
||||
loadedEnvFiles: LoadedEnvFiles;
|
||||
previewProps: __ApiPreviewProps;
|
||||
mappedPages: MappedPages | undefined;
|
||||
mappedAppPages: MappedPages | undefined;
|
||||
mappedRootPaths: MappedPages;
|
||||
hasInstrumentationHook: boolean;
|
||||
telemetry: Telemetry;
|
||||
telemetryState: TelemetryPluginState;
|
||||
nextBuildSpan: Span;
|
||||
reactProductionProfiling: boolean;
|
||||
noMangling: boolean;
|
||||
appDirOnly: boolean;
|
||||
clientRouterFilters: Parameters<typeof getBaseWebpackConfig>[1]['clientRouterFilters'];
|
||||
previewModeId: string;
|
||||
fetchCacheKeyPrefix?: string;
|
||||
allowedRevalidateHeaderKeys?: string[];
|
||||
isCompileMode?: boolean;
|
||||
debugPrerender: boolean;
|
||||
analyze: boolean;
|
||||
}>;
|
||||
58
apps/public-web/node_modules/next/dist/build/build-context.js
generated
vendored
Normal file
58
apps/public-web/node_modules/next/dist/build/build-context.js
generated
vendored
Normal file
@@ -0,0 +1,58 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
NextBuildContext: null,
|
||||
getPluginState: null,
|
||||
getProxiedPluginState: null,
|
||||
resumePluginState: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
NextBuildContext: function() {
|
||||
return NextBuildContext;
|
||||
},
|
||||
getPluginState: function() {
|
||||
return getPluginState;
|
||||
},
|
||||
getProxiedPluginState: function() {
|
||||
return getProxiedPluginState;
|
||||
},
|
||||
resumePluginState: function() {
|
||||
return resumePluginState;
|
||||
}
|
||||
});
|
||||
// A layer for storing data that is used by plugins to communicate with each
|
||||
// other between different steps of the build process. This is only internal
|
||||
// to Next.js and will not be a part of the final build output.
|
||||
// These states don't need to be deeply merged.
|
||||
let pluginState = {};
|
||||
function resumePluginState(resumedState) {
|
||||
Object.assign(pluginState, resumedState);
|
||||
}
|
||||
function getProxiedPluginState(initialState) {
|
||||
return new Proxy(pluginState, {
|
||||
get (target, key) {
|
||||
if (typeof target[key] === 'undefined') {
|
||||
return target[key] = initialState[key];
|
||||
}
|
||||
return target[key];
|
||||
},
|
||||
set (target, key, value) {
|
||||
target[key] = value;
|
||||
return true;
|
||||
}
|
||||
});
|
||||
}
|
||||
function getPluginState() {
|
||||
return pluginState;
|
||||
}
|
||||
const NextBuildContext = {};
|
||||
|
||||
//# sourceMappingURL=build-context.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/build-context.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/build-context.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/build-context.ts"],"sourcesContent":["import type { LoadedEnvFiles } from '@next/env'\nimport type { Rewrite, Redirect } from '../lib/load-custom-routes'\nimport type { __ApiPreviewProps } from '../server/api-utils'\nimport type { NextConfigComplete } from '../server/config-shared'\nimport type { Span } from '../trace'\nimport type getBaseWebpackConfig from './webpack-config'\nimport type { TelemetryPluginState } from './webpack/plugins/telemetry-plugin/telemetry-plugin'\nimport type { Telemetry } from '../telemetry/storage'\n\n// A layer for storing data that is used by plugins to communicate with each\n// other between different steps of the build process. This is only internal\n// to Next.js and will not be a part of the final build output.\n// These states don't need to be deeply merged.\nlet pluginState: Record<string, any> = {}\nexport function resumePluginState(resumedState?: Record<string, any>) {\n Object.assign(pluginState, resumedState)\n}\n\n// This method gives you the plugin state with typed and mutable value fields\n// behind a proxy so we can lazily initialize the values **after** resuming the\n// plugin state.\nexport function getProxiedPluginState<State extends Record<string, any>>(\n initialState: State\n) {\n return new Proxy(pluginState, {\n get(target, key: string) {\n if (typeof target[key] === 'undefined') {\n return (target[key] = initialState[key])\n }\n return target[key]\n },\n set(target, key: string, value) {\n target[key] = value\n return true\n },\n }) as State\n}\n\nexport function getPluginState() {\n return pluginState\n}\n\nexport interface MappedPages {\n [page: string]: string\n}\n\n// a global object to store context for the current build\n// this is used to pass data between different steps of the build without having\n// to pass it through function arguments.\n// Not exhaustive, but should be extended to as needed whilst refactoring\nexport const NextBuildContext: Partial<{\n compilerIdx?: number\n pluginState: Record<string, any>\n // core fields\n dir: string\n distDir: string\n buildId: string\n encryptionKey: string\n config: NextConfigComplete\n appDir: string\n pagesDir: string\n rewrites: {\n fallback: Rewrite[]\n afterFiles: Rewrite[]\n beforeFiles: Rewrite[]\n }\n originalRewrites: {\n fallback: Rewrite[]\n afterFiles: Rewrite[]\n beforeFiles: Rewrite[]\n }\n hasRewrites: boolean\n originalRedirects: Redirect[]\n loadedEnvFiles: LoadedEnvFiles\n previewProps: __ApiPreviewProps\n mappedPages: MappedPages | undefined\n mappedAppPages: MappedPages | undefined\n mappedRootPaths: MappedPages\n hasInstrumentationHook: boolean\n\n // misc fields\n telemetry: Telemetry\n telemetryState: TelemetryPluginState\n nextBuildSpan: Span\n\n // cli fields\n reactProductionProfiling: boolean\n noMangling: boolean\n appDirOnly: boolean\n clientRouterFilters: Parameters<\n typeof getBaseWebpackConfig\n >[1]['clientRouterFilters']\n previewModeId: string\n fetchCacheKeyPrefix?: string\n allowedRevalidateHeaderKeys?: string[]\n isCompileMode?: boolean\n debugPrerender: boolean\n analyze: boolean\n}> = {}\n"],"names":["NextBuildContext","getPluginState","getProxiedPluginState","resumePluginState","pluginState","resumedState","Object","assign","initialState","Proxy","get","target","key","set","value"],"mappings":";;;;;;;;;;;;;;;;;IAkDaA,gBAAgB;eAAhBA;;IAZGC,cAAc;eAAdA;;IAjBAC,qBAAqB;eAArBA;;IAPAC,iBAAiB;eAAjBA;;;AALhB,4EAA4E;AAC5E,4EAA4E;AAC5E,+DAA+D;AAC/D,+CAA+C;AAC/C,IAAIC,cAAmC,CAAC;AACjC,SAASD,kBAAkBE,YAAkC;IAClEC,OAAOC,MAAM,CAACH,aAAaC;AAC7B;AAKO,SAASH,sBACdM,YAAmB;IAEnB,OAAO,IAAIC,MAAML,aAAa;QAC5BM,KAAIC,MAAM,EAAEC,GAAW;YACrB,IAAI,OAAOD,MAAM,CAACC,IAAI,KAAK,aAAa;gBACtC,OAAQD,MAAM,CAACC,IAAI,GAAGJ,YAAY,CAACI,IAAI;YACzC;YACA,OAAOD,MAAM,CAACC,IAAI;QACpB;QACAC,KAAIF,MAAM,EAAEC,GAAW,EAAEE,KAAK;YAC5BH,MAAM,CAACC,IAAI,GAAGE;YACd,OAAO;QACT;IACF;AACF;AAEO,SAASb;IACd,OAAOG;AACT;AAUO,MAAMJ,mBAgDR,CAAC","ignoreList":[0]}
|
||||
15
apps/public-web/node_modules/next/dist/build/collect-build-traces.d.ts
generated
vendored
Normal file
15
apps/public-web/node_modules/next/dist/build/collect-build-traces.d.ts
generated
vendored
Normal file
@@ -0,0 +1,15 @@
|
||||
import { Span } from '../trace';
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import { type BuildTraceContext } from './webpack/plugins/next-trace-entrypoints-plugin';
|
||||
import type { RoutesUsingEdgeRuntime } from './utils';
|
||||
export declare const makeIgnoreFn: (root: string, ignores: string[]) => (pathname: string) => boolean;
|
||||
export declare function collectBuildTraces({ dir, config, distDir, edgeRuntimeRoutes, staticPages, nextBuildSpan, buildTraceContext, outputFileTracingRoot, }: {
|
||||
dir: string;
|
||||
distDir: string;
|
||||
staticPages: string[];
|
||||
outputFileTracingRoot: string;
|
||||
edgeRuntimeRoutes: RoutesUsingEdgeRuntime;
|
||||
nextBuildSpan?: Span;
|
||||
config: NextConfigComplete;
|
||||
buildTraceContext?: BuildTraceContext;
|
||||
}): Promise<void>;
|
||||
536
apps/public-web/node_modules/next/dist/build/collect-build-traces.js
generated
vendored
Normal file
536
apps/public-web/node_modules/next/dist/build/collect-build-traces.js
generated
vendored
Normal file
@@ -0,0 +1,536 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
collectBuildTraces: null,
|
||||
makeIgnoreFn: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
collectBuildTraces: function() {
|
||||
return collectBuildTraces;
|
||||
},
|
||||
makeIgnoreFn: function() {
|
||||
return makeIgnoreFn;
|
||||
}
|
||||
});
|
||||
const _trace = require("../trace");
|
||||
const _nexttraceentrypointsplugin = require("./webpack/plugins/next-trace-entrypoints-plugin");
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
||||
const _promises = /*#__PURE__*/ _interop_require_default(require("fs/promises"));
|
||||
const _nonnullable = require("../lib/non-nullable");
|
||||
const _ciinfo = /*#__PURE__*/ _interop_require_wildcard(require("../server/ci-info"));
|
||||
const _debug = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/debug"));
|
||||
const _picomatch = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/picomatch"));
|
||||
const _requirehook = require("../server/require-hook");
|
||||
const _nft = require("next/dist/compiled/@vercel/nft");
|
||||
const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
|
||||
const _apppaths = require("../shared/lib/router/utils/app-paths");
|
||||
const _iserror = /*#__PURE__*/ _interop_require_default(require("../lib/is-error"));
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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 debug = (0, _debug.default)('next:build:build-traces');
|
||||
const makeIgnoreFn = (root, ignores)=>{
|
||||
// pre compile the ignore globs
|
||||
const isMatch = (0, _picomatch.default)(ignores, {
|
||||
contains: true,
|
||||
dot: true
|
||||
});
|
||||
return (pathname)=>{
|
||||
if (_path.default.isAbsolute(pathname) && !pathname.startsWith(root)) {
|
||||
return true;
|
||||
}
|
||||
return isMatch(pathname);
|
||||
};
|
||||
};
|
||||
function shouldIgnore(file, serverIgnoreFn, reasons, cachedIgnoreFiles, children = new Set()) {
|
||||
if (cachedIgnoreFiles.has(file)) {
|
||||
return cachedIgnoreFiles.get(file);
|
||||
}
|
||||
if (serverIgnoreFn(file)) {
|
||||
cachedIgnoreFiles.set(file, true);
|
||||
return true;
|
||||
}
|
||||
children.add(file);
|
||||
const reason = reasons.get(file);
|
||||
if (!reason || reason.parents.size === 0 || reason.type.includes('initial')) {
|
||||
cachedIgnoreFiles.set(file, false);
|
||||
return false;
|
||||
}
|
||||
// if all parents are ignored the child file
|
||||
// should be ignored as well
|
||||
let allParentsIgnored = true;
|
||||
for (const parent of reason.parents.values()){
|
||||
if (!children.has(parent)) {
|
||||
children.add(parent);
|
||||
if (!shouldIgnore(parent, serverIgnoreFn, reasons, cachedIgnoreFiles, children)) {
|
||||
allParentsIgnored = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
cachedIgnoreFiles.set(file, allParentsIgnored);
|
||||
return allParentsIgnored;
|
||||
}
|
||||
async function collectBuildTraces({ dir, config, distDir, edgeRuntimeRoutes, staticPages, nextBuildSpan = new _trace.Span({
|
||||
name: 'build'
|
||||
}), buildTraceContext, outputFileTracingRoot }) {
|
||||
const startTime = Date.now();
|
||||
debug('starting build traces');
|
||||
const { outputFileTracingIncludes = {}, outputFileTracingExcludes = {} } = config;
|
||||
const excludeGlobKeys = Object.keys(outputFileTracingExcludes);
|
||||
const includeGlobKeys = Object.keys(outputFileTracingIncludes);
|
||||
await nextBuildSpan.traceChild('node-file-trace-build', {
|
||||
isTurbotrace: 'false'
|
||||
}).traceAsyncFn(async ()=>{
|
||||
const nextServerTraceOutput = _path.default.join(distDir, 'next-server.js.nft.json');
|
||||
const nextMinimalTraceOutput = _path.default.join(distDir, 'next-minimal-server.js.nft.json');
|
||||
const root = outputFileTracingRoot;
|
||||
// Under standalone mode, we need to trace the extra IPC server and
|
||||
// worker files.
|
||||
const isStandalone = config.output === 'standalone';
|
||||
const sharedEntriesSet = Object.keys(_requirehook.defaultOverrides).map((value)=>require.resolve(value, {
|
||||
paths: [
|
||||
require.resolve('next/dist/server/require-hook')
|
||||
]
|
||||
}));
|
||||
const { cacheHandler, cacheHandlers } = config;
|
||||
// ensure we trace any dependencies needed for custom
|
||||
// incremental cache handler
|
||||
if (cacheHandler) {
|
||||
sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(cacheHandler) ? cacheHandler : _path.default.join(dir, cacheHandler)));
|
||||
}
|
||||
// Under standalone mode, we need to ensure that the cache entry debug
|
||||
// handler is traced so it can be copied. This is only used for testing,
|
||||
// and is not used in production.
|
||||
if (process.env.__NEXT_TEST_MODE && process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) {
|
||||
sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS) ? process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS : _path.default.join(dir, process.env.NEXT_PRIVATE_DEBUG_CACHE_ENTRY_HANDLERS)));
|
||||
}
|
||||
if (cacheHandlers) {
|
||||
for (const handlerPath of Object.values(cacheHandlers)){
|
||||
if (handlerPath) {
|
||||
sharedEntriesSet.push(require.resolve(_path.default.isAbsolute(handlerPath) ? handlerPath : _path.default.join(dir, handlerPath)));
|
||||
}
|
||||
}
|
||||
}
|
||||
const serverEntries = [
|
||||
...sharedEntriesSet,
|
||||
...isStandalone ? [
|
||||
require.resolve('next/dist/server/lib/start-server'),
|
||||
require.resolve('next/dist/server/next'),
|
||||
require.resolve('next/dist/server/require-hook')
|
||||
] : [],
|
||||
require.resolve('next/dist/server/next-server')
|
||||
].filter(Boolean);
|
||||
const minimalServerEntries = [
|
||||
...sharedEntriesSet,
|
||||
require.resolve('next/dist/compiled/next-server/server.runtime.prod')
|
||||
].filter(Boolean);
|
||||
const additionalIgnores = new Set();
|
||||
for (const glob of excludeGlobKeys){
|
||||
if ((0, _picomatch.default)(glob)('next-server')) {
|
||||
outputFileTracingExcludes[glob].forEach((exclude)=>{
|
||||
additionalIgnores.add(exclude);
|
||||
});
|
||||
}
|
||||
}
|
||||
const sharedIgnores = [
|
||||
'**/next/dist/compiled/next-server/**/*.dev.js',
|
||||
...isStandalone ? [] : [
|
||||
'**/next/dist/compiled/jest-worker/**/*'
|
||||
],
|
||||
'**/next/dist/compiled/webpack/*',
|
||||
'**/node_modules/webpack5/**/*',
|
||||
'**/next/dist/server/lib/route-resolver*',
|
||||
'next/dist/compiled/semver/semver/**/*.js',
|
||||
..._ciinfo.hasNextSupport ? [
|
||||
// only ignore image-optimizer code when
|
||||
// this is being handled outside of next-server
|
||||
'**/next/dist/server/image-optimizer.js'
|
||||
] : [],
|
||||
...isStandalone ? [] : _nexttraceentrypointsplugin.TRACE_IGNORES,
|
||||
...additionalIgnores
|
||||
];
|
||||
const sharedIgnoresFn = makeIgnoreFn(root, sharedIgnores);
|
||||
const serverIgnores = [
|
||||
...sharedIgnores,
|
||||
'**/node_modules/react{,-dom,-dom-server-turbopack}/**/*.development.js',
|
||||
'**/*.d.ts',
|
||||
'**/*.map',
|
||||
'**/next/dist/pages/**/*',
|
||||
..._ciinfo.hasNextSupport ? [
|
||||
'**/node_modules/sharp/**/*',
|
||||
'**/@img/sharp-libvips*/**/*'
|
||||
] : []
|
||||
].filter(_nonnullable.nonNullable);
|
||||
const serverIgnoreFn = makeIgnoreFn(root, serverIgnores);
|
||||
const minimalServerIgnores = [
|
||||
...serverIgnores,
|
||||
'**/next/dist/compiled/edge-runtime/**/*',
|
||||
'**/next/dist/server/web/sandbox/**/*',
|
||||
'**/next/dist/server/post-process.js'
|
||||
];
|
||||
const minimalServerIgnoreFn = makeIgnoreFn(root, minimalServerIgnores);
|
||||
const routesIgnores = [
|
||||
...sharedIgnores,
|
||||
// server chunks are provided via next-trace-entrypoints-plugin plugin
|
||||
// as otherwise all chunks are traced here and included for all pages
|
||||
// whether they are needed or not
|
||||
'**/.next/server/chunks/**',
|
||||
'**/next/dist/server/post-process.js'
|
||||
].filter(_nonnullable.nonNullable);
|
||||
const routeIgnoreFn = makeIgnoreFn(root, routesIgnores);
|
||||
const serverTracedFiles = new Set();
|
||||
const minimalServerTracedFiles = new Set();
|
||||
function addToTracedFiles(base, file, dest) {
|
||||
dest.add(_path.default.relative(distDir, _path.default.join(base, file)).replace(/\\/g, '/'));
|
||||
}
|
||||
if (isStandalone) {
|
||||
addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/processChild'), serverTracedFiles);
|
||||
addToTracedFiles('', require.resolve('next/dist/compiled/jest-worker/threadChild'), serverTracedFiles);
|
||||
}
|
||||
{
|
||||
var _buildTraceContext_chunksTrace;
|
||||
const chunksToTrace = [
|
||||
...(buildTraceContext == null ? void 0 : (_buildTraceContext_chunksTrace = buildTraceContext.chunksTrace) == null ? void 0 : _buildTraceContext_chunksTrace.action.input) || [],
|
||||
...serverEntries,
|
||||
...minimalServerEntries
|
||||
];
|
||||
const result = await (0, _nft.nodeFileTrace)(chunksToTrace, {
|
||||
base: outputFileTracingRoot,
|
||||
processCwd: dir,
|
||||
mixedModules: true,
|
||||
async readFile (p) {
|
||||
try {
|
||||
return await _promises.default.readFile(p, 'utf8');
|
||||
} catch (e) {
|
||||
if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'EISDIR')) {
|
||||
// since tracing runs in parallel with static generation server
|
||||
// files might be removed from that step so tolerate ENOENT
|
||||
// errors gracefully
|
||||
return '';
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
},
|
||||
async readlink (p) {
|
||||
try {
|
||||
return await _promises.default.readlink(p);
|
||||
} catch (e) {
|
||||
if ((0, _iserror.default)(e) && (e.code === 'EINVAL' || e.code === 'ENOENT' || e.code === 'UNKNOWN')) {
|
||||
return null;
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
},
|
||||
async stat (p) {
|
||||
try {
|
||||
return await _promises.default.stat(p);
|
||||
} catch (e) {
|
||||
if ((0, _iserror.default)(e) && (e.code === 'ENOENT' || e.code === 'ENOTDIR')) {
|
||||
return null;
|
||||
}
|
||||
throw e;
|
||||
}
|
||||
},
|
||||
// handle shared ignores at top-level as it
|
||||
// avoids over-tracing when we don't need to
|
||||
// and speeds up total trace time
|
||||
ignore (p) {
|
||||
if (sharedIgnoresFn(p)) {
|
||||
return true;
|
||||
}
|
||||
// if a chunk is attempting to be traced that isn't
|
||||
// in our initial list we need to ignore it to prevent
|
||||
// over tracing as webpack needs to be the source of
|
||||
// truth for which chunks should be included for each entry
|
||||
if (p.includes('.next/server/chunks') && !chunksToTrace.includes(_path.default.join(outputFileTracingRoot, p))) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
});
|
||||
const reasons = result.reasons;
|
||||
const fileList = result.fileList;
|
||||
for (const file of result.esmFileList){
|
||||
fileList.add(file);
|
||||
}
|
||||
const parentFilesMap = (0, _nexttraceentrypointsplugin.getFilesMapFromReasons)(fileList, reasons);
|
||||
const cachedLookupIgnore = new Map();
|
||||
const cachedLookupIgnoreMinimal = new Map();
|
||||
for (const [entries, tracedFiles] of [
|
||||
[
|
||||
serverEntries,
|
||||
serverTracedFiles
|
||||
],
|
||||
[
|
||||
minimalServerEntries,
|
||||
minimalServerTracedFiles
|
||||
]
|
||||
]){
|
||||
for (const file of entries){
|
||||
var _parentFilesMap_get;
|
||||
const curFiles = [
|
||||
...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
|
||||
];
|
||||
tracedFiles.add(_path.default.relative(distDir, file).replace(/\\/g, '/'));
|
||||
for (const curFile of curFiles || []){
|
||||
const filePath = _path.default.join(outputFileTracingRoot, curFile);
|
||||
if (!shouldIgnore(curFile, tracedFiles === minimalServerTracedFiles ? minimalServerIgnoreFn : serverIgnoreFn, reasons, tracedFiles === minimalServerTracedFiles ? cachedLookupIgnoreMinimal : cachedLookupIgnore)) {
|
||||
tracedFiles.add(_path.default.relative(distDir, filePath).replace(/\\/g, '/'));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
|
||||
const cachedLookupIgnoreRoutes = new Map();
|
||||
await Promise.all([
|
||||
...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
|
||||
].map(async ([entryName, entryNameFiles])=>{
|
||||
const isApp = entryName.startsWith('app/');
|
||||
const isPages = entryName.startsWith('pages/');
|
||||
let route = entryName;
|
||||
if (isApp) {
|
||||
route = (0, _apppaths.normalizeAppPath)(route.substring('app'.length));
|
||||
}
|
||||
if (isPages) {
|
||||
route = (0, _normalizepagepath.normalizePagePath)(route.substring('pages'.length));
|
||||
}
|
||||
// we don't need to trace for automatically statically optimized
|
||||
// pages as they don't have server bundles, note there is
|
||||
// the caveat with flying shuttle mode as it needs this for
|
||||
// detecting changed entries
|
||||
if (staticPages.includes(route)) {
|
||||
return;
|
||||
}
|
||||
const entryOutputPath = _path.default.join(distDir, 'server', `${entryName}.js`);
|
||||
const traceOutputPath = `${entryOutputPath}.nft.json`;
|
||||
const existingTrace = JSON.parse(await _promises.default.readFile(traceOutputPath, 'utf8'));
|
||||
const traceOutputDir = _path.default.dirname(traceOutputPath);
|
||||
const curTracedFiles = new Set();
|
||||
for (const file of [
|
||||
...entryNameFiles,
|
||||
entryOutputPath
|
||||
]){
|
||||
var _parentFilesMap_get;
|
||||
const curFiles = [
|
||||
...((_parentFilesMap_get = parentFilesMap.get(_path.default.relative(outputFileTracingRoot, file))) == null ? void 0 : _parentFilesMap_get.keys()) || []
|
||||
];
|
||||
for (const curFile of curFiles || []){
|
||||
if (!shouldIgnore(curFile, routeIgnoreFn, reasons, cachedLookupIgnoreRoutes)) {
|
||||
const filePath = _path.default.join(outputFileTracingRoot, curFile);
|
||||
const outputFile = _path.default.relative(traceOutputDir, filePath).replace(/\\/g, '/');
|
||||
curTracedFiles.add(outputFile);
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const file of existingTrace.files || []){
|
||||
curTracedFiles.add(file);
|
||||
}
|
||||
await _promises.default.writeFile(traceOutputPath, JSON.stringify({
|
||||
...existingTrace,
|
||||
files: [
|
||||
...curTracedFiles
|
||||
].sort()
|
||||
}));
|
||||
}));
|
||||
}
|
||||
const moduleTypes = [
|
||||
'app-page',
|
||||
'pages'
|
||||
];
|
||||
for (const type of moduleTypes){
|
||||
const modulePath = require.resolve(`next/dist/server/route-modules/${type}/module.compiled`);
|
||||
const relativeModulePath = _path.default.relative(root, modulePath);
|
||||
const contextDir = _path.default.join(_path.default.dirname(modulePath), 'vendored', 'contexts');
|
||||
for (const item of (await _promises.default.readdir(contextDir))){
|
||||
const itemPath = _path.default.relative(root, _path.default.join(contextDir, item));
|
||||
if (!serverIgnoreFn(itemPath)) {
|
||||
addToTracedFiles(root, itemPath, serverTracedFiles);
|
||||
addToTracedFiles(root, itemPath, minimalServerTracedFiles);
|
||||
}
|
||||
}
|
||||
addToTracedFiles(root, relativeModulePath, serverTracedFiles);
|
||||
addToTracedFiles(root, relativeModulePath, minimalServerTracedFiles);
|
||||
}
|
||||
const serverTracedFilesSorted = Array.from(serverTracedFiles);
|
||||
serverTracedFilesSorted.sort();
|
||||
const minimalServerTracedFilesSorted = Array.from(minimalServerTracedFiles);
|
||||
minimalServerTracedFilesSorted.sort();
|
||||
await Promise.all([
|
||||
_promises.default.writeFile(nextServerTraceOutput, JSON.stringify({
|
||||
version: 1,
|
||||
files: serverTracedFilesSorted
|
||||
})),
|
||||
_promises.default.writeFile(nextMinimalTraceOutput, JSON.stringify({
|
||||
version: 1,
|
||||
files: minimalServerTracedFilesSorted
|
||||
}))
|
||||
]);
|
||||
});
|
||||
// apply outputFileTracingIncludes/outputFileTracingExcludes after runTurbotrace
|
||||
const includeExcludeSpan = nextBuildSpan.traceChild('apply-include-excludes');
|
||||
await includeExcludeSpan.traceAsyncFn(async ()=>{
|
||||
const globOrig = require('next/dist/compiled/glob');
|
||||
const glob = (pattern)=>{
|
||||
return new Promise((resolve, reject)=>{
|
||||
globOrig(pattern, {
|
||||
cwd: dir,
|
||||
nodir: true,
|
||||
dot: true
|
||||
}, (err, files)=>{
|
||||
if (err) {
|
||||
return reject(err);
|
||||
}
|
||||
resolve(files);
|
||||
});
|
||||
});
|
||||
};
|
||||
const { entryNameFilesMap } = (buildTraceContext == null ? void 0 : buildTraceContext.chunksTrace) || {};
|
||||
await Promise.all([
|
||||
...entryNameFilesMap ? Object.entries(entryNameFilesMap) : new Map()
|
||||
].map(async ([entryName])=>{
|
||||
const isApp = entryName.startsWith('app/');
|
||||
const isPages = entryName.startsWith('pages/');
|
||||
let route = entryName;
|
||||
if (isApp) {
|
||||
route = (0, _apppaths.normalizeAppPath)(entryName);
|
||||
}
|
||||
if (isPages) {
|
||||
route = (0, _normalizepagepath.normalizePagePath)(entryName);
|
||||
}
|
||||
if (staticPages.includes(route)) {
|
||||
return;
|
||||
}
|
||||
// edge routes have no trace files
|
||||
if (edgeRuntimeRoutes.hasOwnProperty(route)) {
|
||||
return;
|
||||
}
|
||||
const combinedIncludes = new Set();
|
||||
const combinedExcludes = new Set();
|
||||
for (const curGlob of includeGlobKeys){
|
||||
const isMatch = (0, _picomatch.default)(curGlob, {
|
||||
dot: true,
|
||||
contains: true
|
||||
});
|
||||
if (isMatch(route)) {
|
||||
for (const include of outputFileTracingIncludes[curGlob]){
|
||||
combinedIncludes.add(include.replace(/\\/g, '/'));
|
||||
}
|
||||
}
|
||||
}
|
||||
for (const curGlob of excludeGlobKeys){
|
||||
const isMatch = (0, _picomatch.default)(curGlob, {
|
||||
dot: true,
|
||||
contains: true
|
||||
});
|
||||
if (isMatch(route)) {
|
||||
for (const exclude of outputFileTracingExcludes[curGlob]){
|
||||
combinedExcludes.add(exclude);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!(combinedIncludes == null ? void 0 : combinedIncludes.size) && !(combinedExcludes == null ? void 0 : combinedExcludes.size)) {
|
||||
return;
|
||||
}
|
||||
const traceFile = _path.default.join(distDir, `server`, `${entryName}.js.nft.json`);
|
||||
const pageDir = _path.default.dirname(traceFile);
|
||||
const traceContent = JSON.parse(await _promises.default.readFile(traceFile, 'utf8'));
|
||||
const includes = [];
|
||||
const resolvedTraceIncludes = new Map();
|
||||
if (combinedIncludes == null ? void 0 : combinedIncludes.size) {
|
||||
await Promise.all([
|
||||
...combinedIncludes
|
||||
].map(async (includeGlob)=>{
|
||||
const results = await glob(includeGlob);
|
||||
const resolvedInclude = resolvedTraceIncludes.get(includeGlob) || [
|
||||
...results.map((file)=>{
|
||||
return _path.default.relative(pageDir, _path.default.join(dir, file));
|
||||
})
|
||||
];
|
||||
includes.push(...resolvedInclude);
|
||||
resolvedTraceIncludes.set(includeGlob, resolvedInclude);
|
||||
}));
|
||||
}
|
||||
const combined = new Set([
|
||||
...traceContent.files,
|
||||
...includes
|
||||
]);
|
||||
if (combinedExcludes == null ? void 0 : combinedExcludes.size) {
|
||||
const resolvedGlobs = [
|
||||
...combinedExcludes
|
||||
].map((exclude)=>_path.default.join(dir, exclude));
|
||||
// pre compile before forEach
|
||||
const isMatch = (0, _picomatch.default)(resolvedGlobs, {
|
||||
dot: true,
|
||||
contains: true
|
||||
});
|
||||
combined.forEach((file)=>{
|
||||
if (isMatch(_path.default.join(pageDir, file))) {
|
||||
combined.delete(file);
|
||||
}
|
||||
});
|
||||
}
|
||||
// overwrite trace file with custom includes/excludes
|
||||
await _promises.default.writeFile(traceFile, JSON.stringify({
|
||||
version: traceContent.version,
|
||||
files: [
|
||||
...combined
|
||||
]
|
||||
}));
|
||||
}));
|
||||
});
|
||||
debug(`finished build tracing ${Date.now() - startTime}ms`);
|
||||
}
|
||||
|
||||
//# sourceMappingURL=collect-build-traces.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/collect-build-traces.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/collect-build-traces.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
14
apps/public-web/node_modules/next/dist/build/compiler.d.ts
generated
vendored
Normal file
14
apps/public-web/node_modules/next/dist/build/compiler.d.ts
generated
vendored
Normal file
@@ -0,0 +1,14 @@
|
||||
import type { webpack } from 'next/dist/compiled/webpack/webpack';
|
||||
import type { Span } from '../trace';
|
||||
export type CompilerResult = {
|
||||
errors: webpack.StatsError[];
|
||||
warnings: webpack.StatsError[];
|
||||
stats: webpack.Stats | undefined;
|
||||
};
|
||||
export declare function runCompiler(config: webpack.Configuration, { runWebpackSpan, inputFileSystem, }: {
|
||||
runWebpackSpan: Span;
|
||||
inputFileSystem?: webpack.Compiler['inputFileSystem'];
|
||||
}): Promise<[
|
||||
result: CompilerResult,
|
||||
inputFileSystem?: webpack.Compiler['inputFileSystem']
|
||||
]>;
|
||||
88
apps/public-web/node_modules/next/dist/build/compiler.js
generated
vendored
Normal file
88
apps/public-web/node_modules/next/dist/build/compiler.js
generated
vendored
Normal file
@@ -0,0 +1,88 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "runCompiler", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return runCompiler;
|
||||
}
|
||||
});
|
||||
const _getwebpackbundler = /*#__PURE__*/ _interop_require_default(require("../shared/lib/get-webpack-bundler"));
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function generateStats(result, stat) {
|
||||
const { errors, warnings } = stat.toJson({
|
||||
preset: 'errors-warnings',
|
||||
moduleTrace: true
|
||||
});
|
||||
if (errors && errors.length > 0) {
|
||||
result.errors.push(...errors);
|
||||
}
|
||||
if (warnings && warnings.length > 0) {
|
||||
result.warnings.push(...warnings);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
// Webpack 5 requires the compiler to be closed (to save caches)
|
||||
// Webpack 4 does not have this close method so in order to be backwards compatible we check if it exists
|
||||
function closeCompiler(compiler) {
|
||||
return new Promise((resolve, reject)=>{
|
||||
// @ts-ignore Close only exists on the compiler in webpack 5
|
||||
return compiler.close((err)=>err ? reject(err) : resolve());
|
||||
});
|
||||
}
|
||||
function runCompiler(config, { runWebpackSpan, inputFileSystem }) {
|
||||
return new Promise((resolve, reject)=>{
|
||||
const compiler = (0, _getwebpackbundler.default)()(config);
|
||||
// Ensure we use the previous inputFileSystem
|
||||
if (inputFileSystem) {
|
||||
compiler.inputFileSystem = inputFileSystem;
|
||||
}
|
||||
compiler.fsStartTime = Date.now();
|
||||
compiler.run((err, stats)=>{
|
||||
const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {
|
||||
name: config.name || 'unknown'
|
||||
});
|
||||
webpackCloseSpan.traceAsyncFn(()=>closeCompiler(compiler)).then(()=>{
|
||||
if (err) {
|
||||
const reason = err.stack ?? err.toString();
|
||||
if (reason) {
|
||||
return resolve([
|
||||
{
|
||||
errors: [
|
||||
{
|
||||
message: reason,
|
||||
details: err.details
|
||||
}
|
||||
],
|
||||
warnings: [],
|
||||
stats
|
||||
},
|
||||
compiler.inputFileSystem
|
||||
]);
|
||||
}
|
||||
return reject(err);
|
||||
} else if (!stats) throw Object.defineProperty(new Error('No Stats from webpack'), "__NEXT_ERROR_CODE", {
|
||||
value: "E370",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
const result = webpackCloseSpan.traceChild('webpack-generate-error-stats').traceFn(()=>generateStats({
|
||||
errors: [],
|
||||
warnings: [],
|
||||
stats
|
||||
}, stats));
|
||||
return resolve([
|
||||
result,
|
||||
compiler.inputFileSystem
|
||||
]);
|
||||
});
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
//# sourceMappingURL=compiler.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/compiler.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/compiler.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/compiler.ts"],"sourcesContent":["import type { webpack } from 'next/dist/compiled/webpack/webpack'\nimport type { Span } from '../trace'\nimport getWebpackBundler from '../shared/lib/get-webpack-bundler'\n\nexport type CompilerResult = {\n errors: webpack.StatsError[]\n warnings: webpack.StatsError[]\n stats: webpack.Stats | undefined\n}\n\nfunction generateStats(\n result: CompilerResult,\n stat: webpack.Stats\n): CompilerResult {\n const { errors, warnings } = stat.toJson({\n preset: 'errors-warnings',\n moduleTrace: true,\n })\n if (errors && errors.length > 0) {\n result.errors.push(...errors)\n }\n\n if (warnings && warnings.length > 0) {\n result.warnings.push(...warnings)\n }\n\n return result\n}\n\n// Webpack 5 requires the compiler to be closed (to save caches)\n// Webpack 4 does not have this close method so in order to be backwards compatible we check if it exists\nfunction closeCompiler(compiler: webpack.Compiler | webpack.MultiCompiler) {\n return new Promise<void>((resolve, reject) => {\n // @ts-ignore Close only exists on the compiler in webpack 5\n return compiler.close((err: any) => (err ? reject(err) : resolve()))\n })\n}\n\nexport function runCompiler(\n config: webpack.Configuration,\n {\n runWebpackSpan,\n inputFileSystem,\n }: {\n runWebpackSpan: Span\n inputFileSystem?: webpack.Compiler['inputFileSystem']\n }\n): Promise<\n [\n result: CompilerResult,\n inputFileSystem?: webpack.Compiler['inputFileSystem'],\n ]\n> {\n return new Promise((resolve, reject) => {\n const compiler = getWebpackBundler()(config)\n\n // Ensure we use the previous inputFileSystem\n if (inputFileSystem) {\n compiler.inputFileSystem = inputFileSystem\n }\n compiler.fsStartTime = Date.now()\n compiler.run((err, stats) => {\n const webpackCloseSpan = runWebpackSpan.traceChild('webpack-close', {\n name: config.name || 'unknown',\n })\n webpackCloseSpan\n .traceAsyncFn(() => closeCompiler(compiler))\n .then(() => {\n if (err) {\n const reason = err.stack ?? err.toString()\n if (reason) {\n return resolve([\n {\n errors: [{ message: reason, details: (err as any).details }],\n warnings: [],\n stats,\n },\n compiler.inputFileSystem,\n ])\n }\n return reject(err)\n } else if (!stats) throw new Error('No Stats from webpack')\n\n const result = webpackCloseSpan\n .traceChild('webpack-generate-error-stats')\n .traceFn(() =>\n generateStats({ errors: [], warnings: [], stats }, stats)\n )\n return resolve([result, compiler.inputFileSystem])\n })\n })\n })\n}\n"],"names":["runCompiler","generateStats","result","stat","errors","warnings","toJson","preset","moduleTrace","length","push","closeCompiler","compiler","Promise","resolve","reject","close","err","config","runWebpackSpan","inputFileSystem","getWebpackBundler","fsStartTime","Date","now","run","stats","webpackCloseSpan","traceChild","name","traceAsyncFn","then","reason","stack","toString","message","details","Error","traceFn"],"mappings":";;;;+BAsCgBA;;;eAAAA;;;0EApCc;;;;;;AAQ9B,SAASC,cACPC,MAAsB,EACtBC,IAAmB;IAEnB,MAAM,EAAEC,MAAM,EAAEC,QAAQ,EAAE,GAAGF,KAAKG,MAAM,CAAC;QACvCC,QAAQ;QACRC,aAAa;IACf;IACA,IAAIJ,UAAUA,OAAOK,MAAM,GAAG,GAAG;QAC/BP,OAAOE,MAAM,CAACM,IAAI,IAAIN;IACxB;IAEA,IAAIC,YAAYA,SAASI,MAAM,GAAG,GAAG;QACnCP,OAAOG,QAAQ,CAACK,IAAI,IAAIL;IAC1B;IAEA,OAAOH;AACT;AAEA,gEAAgE;AAChE,yGAAyG;AACzG,SAASS,cAAcC,QAAkD;IACvE,OAAO,IAAIC,QAAc,CAACC,SAASC;QACjC,4DAA4D;QAC5D,OAAOH,SAASI,KAAK,CAAC,CAACC,MAAcA,MAAMF,OAAOE,OAAOH;IAC3D;AACF;AAEO,SAASd,YACdkB,MAA6B,EAC7B,EACEC,cAAc,EACdC,eAAe,EAIhB;IAOD,OAAO,IAAIP,QAAQ,CAACC,SAASC;QAC3B,MAAMH,WAAWS,IAAAA,0BAAiB,IAAGH;QAErC,6CAA6C;QAC7C,IAAIE,iBAAiB;YACnBR,SAASQ,eAAe,GAAGA;QAC7B;QACAR,SAASU,WAAW,GAAGC,KAAKC,GAAG;QAC/BZ,SAASa,GAAG,CAAC,CAACR,KAAKS;YACjB,MAAMC,mBAAmBR,eAAeS,UAAU,CAAC,iBAAiB;gBAClEC,MAAMX,OAAOW,IAAI,IAAI;YACvB;YACAF,iBACGG,YAAY,CAAC,IAAMnB,cAAcC,WACjCmB,IAAI,CAAC;gBACJ,IAAId,KAAK;oBACP,MAAMe,SAASf,IAAIgB,KAAK,IAAIhB,IAAIiB,QAAQ;oBACxC,IAAIF,QAAQ;wBACV,OAAOlB,QAAQ;4BACb;gCACEV,QAAQ;oCAAC;wCAAE+B,SAASH;wCAAQI,SAAS,AAACnB,IAAYmB,OAAO;oCAAC;iCAAE;gCAC5D/B,UAAU,EAAE;gCACZqB;4BACF;4BACAd,SAASQ,eAAe;yBACzB;oBACH;oBACA,OAAOL,OAAOE;gBAChB,OAAO,IAAI,CAACS,OAAO,MAAM,qBAAkC,CAAlC,IAAIW,MAAM,0BAAV,qBAAA;2BAAA;gCAAA;kCAAA;gBAAiC;gBAE1D,MAAMnC,SAASyB,iBACZC,UAAU,CAAC,gCACXU,OAAO,CAAC,IACPrC,cAAc;wBAAEG,QAAQ,EAAE;wBAAEC,UAAU,EAAE;wBAAEqB;oBAAM,GAAGA;gBAEvD,OAAOZ,QAAQ;oBAACZ;oBAAQU,SAASQ,eAAe;iBAAC;YACnD;QACJ;IACF;AACF","ignoreList":[0]}
|
||||
28
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.d.ts
generated
vendored
Normal file
28
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.d.ts
generated
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
import { type WebpackLayerName } from '../lib/constants';
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
interface CompilerAliases {
|
||||
[alias: string]: string | string[];
|
||||
}
|
||||
export declare function createWebpackAliases({ distDir, isClient, isEdgeServer, dev, config, pagesDir, appDir, dir, reactProductionProfiling, }: {
|
||||
distDir: string;
|
||||
isClient: boolean;
|
||||
isEdgeServer: boolean;
|
||||
dev: boolean;
|
||||
config: NextConfigComplete;
|
||||
pagesDir: string | undefined;
|
||||
appDir: string | undefined;
|
||||
dir: string;
|
||||
reactProductionProfiling: boolean;
|
||||
}): CompilerAliases;
|
||||
export declare function createServerOnlyClientOnlyAliases(isServer: boolean): CompilerAliases;
|
||||
export declare function createNextApiEsmAliases(): Record<string, string>;
|
||||
export declare function createAppRouterApiAliases(isServerOnlyLayer: boolean): Record<string, string>;
|
||||
type BundledReactChannel = '' | '-experimental';
|
||||
export declare function createVendoredReactAliases(bundledReactChannel: BundledReactChannel, { layer, isBrowser, isEdgeServer, reactProductionProfiling, }: {
|
||||
layer: WebpackLayerName;
|
||||
isBrowser: boolean;
|
||||
isEdgeServer: boolean;
|
||||
reactProductionProfiling: boolean;
|
||||
}): CompilerAliases;
|
||||
export declare function getOptimizedModuleAliases(): CompilerAliases;
|
||||
export {};
|
||||
436
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.js
generated
vendored
Normal file
436
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.js
generated
vendored
Normal file
@@ -0,0 +1,436 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
createAppRouterApiAliases: null,
|
||||
createNextApiEsmAliases: null,
|
||||
createServerOnlyClientOnlyAliases: null,
|
||||
createVendoredReactAliases: null,
|
||||
createWebpackAliases: null,
|
||||
getOptimizedModuleAliases: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
createAppRouterApiAliases: function() {
|
||||
return createAppRouterApiAliases;
|
||||
},
|
||||
createNextApiEsmAliases: function() {
|
||||
return createNextApiEsmAliases;
|
||||
},
|
||||
createServerOnlyClientOnlyAliases: function() {
|
||||
return createServerOnlyClientOnlyAliases;
|
||||
},
|
||||
createVendoredReactAliases: function() {
|
||||
return createVendoredReactAliases;
|
||||
},
|
||||
createWebpackAliases: function() {
|
||||
return createWebpackAliases;
|
||||
},
|
||||
getOptimizedModuleAliases: function() {
|
||||
return getOptimizedModuleAliases;
|
||||
}
|
||||
});
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
||||
const _react = /*#__PURE__*/ _interop_require_wildcard(require("react"));
|
||||
const _constants = require("../lib/constants");
|
||||
const _requirehook = require("../server/require-hook");
|
||||
const _webpackconfig = require("./webpack-config");
|
||||
const _nextdirpaths = require("./next-dir-paths");
|
||||
const _utils = require("./utils");
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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 isReact19 = typeof _react.use === 'function';
|
||||
function createWebpackAliases({ distDir, isClient, isEdgeServer, dev, config, pagesDir, appDir, dir, reactProductionProfiling }) {
|
||||
const pageExtensions = config.pageExtensions;
|
||||
const customAppAliases = {};
|
||||
const customDocumentAliases = {};
|
||||
// tell webpack where to look for _app and _document
|
||||
// using aliases to allow falling back to the default
|
||||
// version when removed or not present
|
||||
if (dev) {
|
||||
const nextDistPath = 'next/dist/' + (isEdgeServer ? 'esm/' : '');
|
||||
customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_app`] = [
|
||||
...pagesDir ? pageExtensions.reduce((prev, ext)=>{
|
||||
prev.push(_path.default.join(pagesDir, `_app.${ext}`));
|
||||
return prev;
|
||||
}, []) : [],
|
||||
`${nextDistPath}pages/_app.js`
|
||||
];
|
||||
customAppAliases[`${_constants.PAGES_DIR_ALIAS}/_error`] = [
|
||||
...pagesDir ? pageExtensions.reduce((prev, ext)=>{
|
||||
prev.push(_path.default.join(pagesDir, `_error.${ext}`));
|
||||
return prev;
|
||||
}, []) : [],
|
||||
`${nextDistPath}pages/_error.js`
|
||||
];
|
||||
customDocumentAliases[`${_constants.PAGES_DIR_ALIAS}/_document`] = [
|
||||
...pagesDir ? pageExtensions.reduce((prev, ext)=>{
|
||||
prev.push(_path.default.join(pagesDir, `_document.${ext}`));
|
||||
return prev;
|
||||
}, []) : [],
|
||||
`${nextDistPath}pages/_document.js`
|
||||
];
|
||||
}
|
||||
return {
|
||||
'@vercel/og$': 'next/dist/server/og/image-response',
|
||||
// Avoid bundling both entrypoints in React 19 when we just need one.
|
||||
// Also avoids bundler warnings in React 18 where react-dom/server.edge doesn't exist.
|
||||
'next/dist/server/ReactDOMServerPages': isReact19 ? 'react-dom/server.edge' : 'react-dom/server.browser',
|
||||
// Alias next/dist imports to next/dist/esm assets,
|
||||
// let this alias hit before `next` alias.
|
||||
...isEdgeServer ? {
|
||||
'next/dist/api': 'next/dist/esm/api',
|
||||
'next/dist/build': 'next/dist/esm/build',
|
||||
'next/dist/client': 'next/dist/esm/client',
|
||||
'next/dist/shared': 'next/dist/esm/shared',
|
||||
'next/dist/pages': 'next/dist/esm/pages',
|
||||
'next/dist/lib': 'next/dist/esm/lib',
|
||||
'next/dist/server': 'next/dist/esm/server',
|
||||
...createNextApiEsmAliases()
|
||||
} : undefined,
|
||||
// For RSC server bundle
|
||||
...!(0, _webpackconfig.hasExternalOtelApiPackage)() && {
|
||||
'@opentelemetry/api': 'next/dist/compiled/@opentelemetry/api'
|
||||
},
|
||||
...config.images.loaderFile ? {
|
||||
'next/dist/shared/lib/image-loader': config.images.loaderFile,
|
||||
...isEdgeServer && {
|
||||
'next/dist/esm/shared/lib/image-loader': config.images.loaderFile
|
||||
}
|
||||
} : undefined,
|
||||
'styled-jsx/style$': _requirehook.defaultOverrides['styled-jsx/style'],
|
||||
'styled-jsx$': _requirehook.defaultOverrides['styled-jsx'],
|
||||
'next/dist/compiled/next-devtools': isClient ? 'next/dist/compiled/next-devtools' : 'next/dist/next-devtools/dev-overlay.shim.js',
|
||||
...customAppAliases,
|
||||
...customDocumentAliases,
|
||||
...pagesDir ? {
|
||||
[_constants.PAGES_DIR_ALIAS]: pagesDir
|
||||
} : {},
|
||||
...appDir ? {
|
||||
[_constants.APP_DIR_ALIAS]: appDir
|
||||
} : {},
|
||||
[_constants.ROOT_DIR_ALIAS]: dir,
|
||||
...isClient ? {
|
||||
'private-next-instrumentation-client': [
|
||||
_path.default.join(dir, 'src', 'instrumentation-client'),
|
||||
_path.default.join(dir, 'instrumentation-client'),
|
||||
'private-next-empty-module'
|
||||
],
|
||||
// disable typechecker, webpack5 allows aliases to be set to false to create a no-op module
|
||||
'private-next-empty-module': false
|
||||
} : {},
|
||||
[_constants.DOT_NEXT_ALIAS]: distDir,
|
||||
...isClient || isEdgeServer ? getOptimizedModuleAliases() : {},
|
||||
...reactProductionProfiling ? getReactProfilingInProduction() : {},
|
||||
[_constants.RSC_ACTION_VALIDATE_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/action-validate',
|
||||
[_constants.RSC_ACTION_CLIENT_WRAPPER_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/action-client-wrapper',
|
||||
[_constants.RSC_ACTION_PROXY_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/server-reference',
|
||||
[_constants.RSC_ACTION_ENCRYPTION_ALIAS]: 'next/dist/server/app-render/encryption',
|
||||
[_constants.RSC_CACHE_WRAPPER_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/cache-wrapper',
|
||||
[_constants.RSC_DYNAMIC_IMPORT_WRAPPER_ALIAS]: 'next/dist/build/webpack/loaders/next-flight-loader/track-dynamic-import',
|
||||
'@swc/helpers/_': _path.default.join(_path.default.dirname(require.resolve('@swc/helpers/package.json')), '_'),
|
||||
setimmediate: 'next/dist/compiled/setimmediate'
|
||||
};
|
||||
}
|
||||
function createServerOnlyClientOnlyAliases(isServer) {
|
||||
return isServer ? {
|
||||
'server-only$': 'next/dist/compiled/server-only/empty',
|
||||
'client-only$': 'next/dist/compiled/client-only/error',
|
||||
'next/dist/compiled/server-only$': 'next/dist/compiled/server-only/empty',
|
||||
'next/dist/compiled/client-only$': 'next/dist/compiled/client-only/error'
|
||||
} : {
|
||||
'server-only$': 'next/dist/compiled/server-only/index',
|
||||
'client-only$': 'next/dist/compiled/client-only/index',
|
||||
'next/dist/compiled/client-only$': 'next/dist/compiled/client-only/index',
|
||||
'next/dist/compiled/server-only': 'next/dist/compiled/server-only/index'
|
||||
};
|
||||
}
|
||||
function createNextApiEsmAliases() {
|
||||
const mapping = {
|
||||
head: 'next/dist/api/head',
|
||||
image: 'next/dist/api/image',
|
||||
constants: 'next/dist/api/constants',
|
||||
router: 'next/dist/api/router',
|
||||
dynamic: 'next/dist/api/dynamic',
|
||||
script: 'next/dist/api/script',
|
||||
link: 'next/dist/api/link',
|
||||
form: 'next/dist/api/form',
|
||||
navigation: 'next/dist/api/navigation',
|
||||
headers: 'next/dist/api/headers',
|
||||
og: 'next/dist/api/og',
|
||||
server: 'next/dist/api/server',
|
||||
// pages api
|
||||
document: 'next/dist/api/document',
|
||||
app: 'next/dist/api/app'
|
||||
};
|
||||
const aliasMap = {};
|
||||
// Handle fully specified imports like `next/image.js`
|
||||
for (const [key, value] of Object.entries(mapping)){
|
||||
const nextApiFilePath = _path.default.join(_nextdirpaths.NEXT_PROJECT_ROOT, key);
|
||||
aliasMap[nextApiFilePath + '.js'] = value;
|
||||
}
|
||||
return aliasMap;
|
||||
}
|
||||
function createAppRouterApiAliases(isServerOnlyLayer) {
|
||||
const mapping = {
|
||||
head: 'next/dist/client/components/noop-head',
|
||||
dynamic: 'next/dist/api/app-dynamic',
|
||||
link: 'next/dist/client/app-dir/link',
|
||||
form: 'next/dist/client/app-dir/form'
|
||||
};
|
||||
if (isServerOnlyLayer) {
|
||||
mapping['navigation'] = 'next/dist/api/navigation.react-server';
|
||||
mapping['link'] = 'next/dist/client/app-dir/link.react-server';
|
||||
}
|
||||
const aliasMap = {};
|
||||
for (const [key, value] of Object.entries(mapping)){
|
||||
const nextApiFilePath = _path.default.join(_nextdirpaths.NEXT_PROJECT_ROOT, key);
|
||||
aliasMap[nextApiFilePath + '.js'] = value;
|
||||
}
|
||||
return aliasMap;
|
||||
}
|
||||
function createVendoredReactAliases(bundledReactChannel, { layer, isBrowser, isEdgeServer, reactProductionProfiling }) {
|
||||
const environmentCondition = isBrowser ? 'browser' : isEdgeServer ? 'edge' : 'nodejs';
|
||||
const reactCondition = (0, _utils.shouldUseReactServerCondition)(layer) ? 'server' : 'client';
|
||||
// ✅ Correct alias
|
||||
// ❌ Incorrect alias i.e. importing this entrypoint should throw an error.
|
||||
// ❔ Alias that may produce correct code in certain conditions.Keep until react-markup is available.
|
||||
let reactAlias;
|
||||
if (environmentCondition === 'browser' && reactCondition === 'client') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ✅ */ `next/dist/compiled/react${bundledReactChannel}`,
|
||||
'react/compiler-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime`,
|
||||
'react/jsx-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-runtime`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}`,
|
||||
'react-dom/client$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
'react-dom/server.browser$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ❌ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.browser$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.browser`,
|
||||
'react-server-dom-webpack/server$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.browser`,
|
||||
'react-server-dom-webpack/server.node$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/static$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.browser`
|
||||
};
|
||||
} else if (environmentCondition === 'browser' && reactCondition === 'server') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ❌ */ `next/dist/compiled/react${bundledReactChannel}`,
|
||||
'react/compiler-runtime$': /* ❌ */ `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ❌ */ `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime`,
|
||||
'react/jsx-runtime$': /* ❌ */ `next/dist/compiled/react${bundledReactChannel}/jsx-runtime`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}`,
|
||||
'react-dom/client$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
'react-dom/server.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ❌ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.browser`,
|
||||
'react-server-dom-webpack/server$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.browser`,
|
||||
'react-server-dom-webpack/server.node$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/static$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.browser`
|
||||
};
|
||||
} else if (environmentCondition === 'nodejs' && reactCondition === 'client') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react`,
|
||||
'react/compiler-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react-compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react-jsx-dev-runtime`,
|
||||
'react/jsx-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react-jsx-runtime`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react-dom`,
|
||||
'react-dom/client$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.node`,
|
||||
'react-dom/server.browser$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ✅ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.node`,
|
||||
'react-dom/static.browser$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ❔ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/ssr/react-server-dom-webpack-client`,
|
||||
'react-server-dom-webpack/server$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/server.node$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/static$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.node`
|
||||
};
|
||||
} else if (environmentCondition === 'nodejs' && reactCondition === 'server') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react`,
|
||||
'react/compiler-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-jsx-dev-runtime`,
|
||||
'react/jsx-runtime$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-jsx-runtime`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-dom`,
|
||||
'react-dom/client$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.node`,
|
||||
'react-dom/server.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ❌ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.node`,
|
||||
'react-dom/static.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ❔ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.node`,
|
||||
'react-server-dom-webpack/server$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-server-dom-webpack-server`,
|
||||
'react-server-dom-webpack/server.node$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-server-dom-webpack-server`,
|
||||
'react-server-dom-webpack/static$': /* ✅ */ `next/dist/server/route-modules/app-page/vendored/rsc/react-server-dom-webpack-static`
|
||||
};
|
||||
} else if (environmentCondition === 'edge' && reactCondition === 'client') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ✅ */ `next/dist/compiled/react${bundledReactChannel}`,
|
||||
'react/compiler-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime`,
|
||||
'react/jsx-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-runtime`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}`,
|
||||
'react-dom/client$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ✅ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/server.browser$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ✅ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
'react-dom/static.browser$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.edge`,
|
||||
'react-server-dom-webpack/server$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.edge`,
|
||||
'react-server-dom-webpack/server.node$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/static$': /* ❌ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.edge`
|
||||
};
|
||||
} else if (environmentCondition === 'edge' && reactCondition === 'server') {
|
||||
// prettier-ignore
|
||||
reactAlias = {
|
||||
// file:///./../compiled/react/package.json
|
||||
react$: /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/react.react-server`,
|
||||
'react/compiler-runtime$': /* ❌ */ `next/dist/compiled/react${bundledReactChannel}/compiler-runtime`,
|
||||
'react/jsx-dev-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime.react-server`,
|
||||
'react/jsx-runtime$': /* ✅ */ `next/dist/compiled/react${bundledReactChannel}/jsx-runtime.react-server`,
|
||||
// file:///./../compiled/react-dom/package.json
|
||||
'react-dom$': /* ✅ */ `next/dist/compiled/react-dom${bundledReactChannel}/react-dom.react-server`,
|
||||
'react-dom/client$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/client`,
|
||||
'react-dom/server$': /* ❌ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/server.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/server.browser`,
|
||||
// optimizations to ignore the legacy build of react-dom/server in `server.edge` build
|
||||
'react-dom/server.edge$': /* ❌ */ `next/dist/build/webpack/alias/react-dom-server${bundledReactChannel}.js`,
|
||||
'react-dom/static$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
'react-dom/static.browser$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.browser`,
|
||||
'react-dom/static.edge$': /* ❌ */ `next/dist/compiled/react-dom${bundledReactChannel}/static.edge`,
|
||||
// file:///./../compiled/react-server-dom-webpack/package.json
|
||||
'react-server-dom-webpack/client$': /* ❔ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/client.edge`,
|
||||
'react-server-dom-webpack/server$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.edge`,
|
||||
'react-server-dom-webpack/server.node$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/server.node`,
|
||||
'react-server-dom-webpack/static$': /* ✅ */ `next/dist/compiled/react-server-dom-webpack${bundledReactChannel}/static.edge`
|
||||
};
|
||||
// prettier-ignore
|
||||
reactAlias[`next/dist/compiled/react${bundledReactChannel}$`] = reactAlias[`react$`];
|
||||
// prettier-ignore
|
||||
reactAlias[`next/dist/compiled/react${bundledReactChannel}/compiler-runtime$`] = reactAlias[`react/compiler-runtime$`];
|
||||
// prettier-ignore
|
||||
reactAlias[`next/dist/compiled/react${bundledReactChannel}/jsx-dev-runtime$`] = reactAlias[`react/jsx-dev-runtime$`];
|
||||
// prettier-ignore
|
||||
reactAlias[`next/dist/compiled/react${bundledReactChannel}/jsx-runtime$`] = reactAlias[`react/jsx-runtime$`];
|
||||
// prettier-ignore
|
||||
reactAlias[`next/dist/compiled/react-dom${bundledReactChannel}$`] = reactAlias[`react-dom$`];
|
||||
} else {
|
||||
throw Object.defineProperty(new Error(`Unsupported environment condition "${environmentCondition}" and react condition "${reactCondition}". This is a bug in Next.js.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E717",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
if (reactProductionProfiling) {
|
||||
reactAlias['react-dom/client$'] = `next/dist/compiled/react-dom${bundledReactChannel}/profiling`;
|
||||
}
|
||||
const alias = reactAlias;
|
||||
alias['@vercel/turbopack-ecmascript-runtime/browser/dev/hmr-client/hmr-client.ts'] = `next/dist/client/dev/noop-turbopack-hmr`;
|
||||
return alias;
|
||||
}
|
||||
function getOptimizedModuleAliases() {
|
||||
return {
|
||||
unfetch: require.resolve('next/dist/build/polyfills/fetch/index.js'),
|
||||
'isomorphic-unfetch': require.resolve('next/dist/build/polyfills/fetch/index.js'),
|
||||
'whatwg-fetch': require.resolve('next/dist/build/polyfills/fetch/whatwg-fetch.js'),
|
||||
'object-assign': require.resolve('next/dist/build/polyfills/object-assign.js'),
|
||||
'object.assign/auto': require.resolve('next/dist/build/polyfills/object.assign/auto.js'),
|
||||
'object.assign/implementation': require.resolve('next/dist/build/polyfills/object.assign/implementation.js'),
|
||||
'object.assign/polyfill': require.resolve('next/dist/build/polyfills/object.assign/polyfill.js'),
|
||||
'object.assign/shim': require.resolve('next/dist/build/polyfills/object.assign/shim.js'),
|
||||
url: require.resolve('next/dist/compiled/native-url')
|
||||
};
|
||||
}
|
||||
function getReactProfilingInProduction() {
|
||||
return {
|
||||
'react-dom/client$': 'react-dom/profiling'
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=create-compiler-aliases.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/create-compiler-aliases.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
32
apps/public-web/node_modules/next/dist/build/define-env.d.ts
generated
vendored
Normal file
32
apps/public-web/node_modules/next/dist/build/define-env.d.ts
generated
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { ProxyMatcher } from './analysis/get-page-static-info';
|
||||
import type { Rewrite } from '../lib/load-custom-routes';
|
||||
type BloomFilter = ReturnType<import('../shared/lib/bloom-filter').BloomFilter['export']>;
|
||||
export interface DefineEnvOptions {
|
||||
isTurbopack: boolean;
|
||||
clientRouterFilters?: {
|
||||
staticFilter: BloomFilter;
|
||||
dynamicFilter: BloomFilter;
|
||||
};
|
||||
config: NextConfigComplete;
|
||||
dev: boolean;
|
||||
distDir: string;
|
||||
projectPath: string;
|
||||
fetchCacheKeyPrefix: string | undefined;
|
||||
hasRewrites: boolean;
|
||||
isClient: boolean;
|
||||
isEdgeServer: boolean;
|
||||
isNodeServer: boolean;
|
||||
middlewareMatchers: ProxyMatcher[] | undefined;
|
||||
omitNonDeterministic?: boolean;
|
||||
rewrites: {
|
||||
beforeFiles: Rewrite[];
|
||||
afterFiles: Rewrite[];
|
||||
fallback: Rewrite[];
|
||||
};
|
||||
}
|
||||
interface SerializedDefineEnv {
|
||||
[key: string]: string;
|
||||
}
|
||||
export declare function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir, projectPath, fetchCacheKeyPrefix, hasRewrites, isClient, isEdgeServer, isNodeServer, middlewareMatchers, omitNonDeterministic, rewrites, }: DefineEnvOptions): SerializedDefineEnv;
|
||||
export {};
|
||||
237
apps/public-web/node_modules/next/dist/build/define-env.js
generated
vendored
Normal file
237
apps/public-web/node_modules/next/dist/build/define-env.js
generated
vendored
Normal file
@@ -0,0 +1,237 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "getDefineEnv", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getDefineEnv;
|
||||
}
|
||||
});
|
||||
const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
|
||||
const _needsexperimentalreact = require("../lib/needs-experimental-react");
|
||||
const _ppr = require("../server/lib/experimental/ppr");
|
||||
const _staticenv = require("../lib/static-env");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Serializes the DefineEnv config so that it can be inserted into the code by Webpack/Turbopack, JSON stringifies each value.
|
||||
*/ function serializeDefineEnv(defineEnv) {
|
||||
const defineEnvStringified = Object.fromEntries(Object.entries(defineEnv).map(([key, value])=>[
|
||||
key,
|
||||
JSON.stringify(value)
|
||||
]));
|
||||
return defineEnvStringified;
|
||||
}
|
||||
function getImageConfig(config, dev) {
|
||||
var _config_images, _config_images1, _config_images2;
|
||||
return {
|
||||
'process.env.__NEXT_IMAGE_OPTS': {
|
||||
deviceSizes: config.images.deviceSizes,
|
||||
imageSizes: config.images.imageSizes,
|
||||
qualities: config.images.qualities,
|
||||
path: config.images.path,
|
||||
loader: config.images.loader,
|
||||
dangerouslyAllowSVG: config.images.dangerouslyAllowSVG,
|
||||
unoptimized: config == null ? void 0 : (_config_images = config.images) == null ? void 0 : _config_images.unoptimized,
|
||||
...dev ? {
|
||||
// additional config in dev to allow validating on the client
|
||||
domains: config.images.domains,
|
||||
remotePatterns: (_config_images1 = config.images) == null ? void 0 : _config_images1.remotePatterns,
|
||||
localPatterns: (_config_images2 = config.images) == null ? void 0 : _config_images2.localPatterns,
|
||||
output: config.output
|
||||
} : {}
|
||||
}
|
||||
};
|
||||
}
|
||||
function getDefineEnv({ isTurbopack, clientRouterFilters, config, dev, distDir, projectPath, fetchCacheKeyPrefix, hasRewrites, isClient, isEdgeServer, isNodeServer, middlewareMatchers, omitNonDeterministic, rewrites }) {
|
||||
var _config_experimental, _config_experimental1, _config_experimental2, _config_experimental_staleTimes, _config_experimental_staleTimes1, _config_experimental_staleTimes2, _config_experimental_staleTimes3, _config_i18n, _config_compiler;
|
||||
const nextPublicEnv = (0, _staticenv.getNextPublicEnvironmentVariables)();
|
||||
const nextConfigEnv = (0, _staticenv.getNextConfigEnv)(config);
|
||||
const isPPREnabled = (0, _ppr.checkIsAppPPREnabled)(config.experimental.ppr);
|
||||
const isCacheComponentsEnabled = !!config.cacheComponents;
|
||||
const isUseCacheEnabled = !!config.experimental.useCache;
|
||||
const defineEnv = {
|
||||
// internal field to identify the plugin config
|
||||
__NEXT_DEFINE_ENV: true,
|
||||
...nextPublicEnv,
|
||||
...nextConfigEnv,
|
||||
...!isEdgeServer ? {} : {
|
||||
EdgeRuntime: /**
|
||||
* Cloud providers can set this environment variable to allow users
|
||||
* and library authors to have different implementations based on
|
||||
* the runtime they are running with, if it's not using `edge-runtime`
|
||||
*/ process.env.NEXT_EDGE_RUNTIME_PROVIDER ?? 'edge-runtime',
|
||||
// process should be only { env: {...} } for edge runtime.
|
||||
// For ignore avoid warn on `process.emit` usage but directly omit it.
|
||||
'process.emit': false
|
||||
},
|
||||
'process.turbopack': isTurbopack,
|
||||
'process.env.TURBOPACK': isTurbopack,
|
||||
'process.env.__NEXT_BUNDLER': isTurbopack ? 'Turbopack' : process.env.NEXT_RSPACK ? 'Rspack' : 'Webpack',
|
||||
// minimal mode is enforced when an adapter is configured
|
||||
'process.env.MINIMAL_MODE': Boolean(config.experimental.adapterPath),
|
||||
// TODO: enforce `NODE_ENV` on `process.env`, and add a test:
|
||||
'process.env.NODE_ENV': dev || config.experimental.allowDevelopmentBuild ? 'development' : 'production',
|
||||
'process.env.NEXT_RUNTIME': isEdgeServer ? 'edge' : isNodeServer ? 'nodejs' : '',
|
||||
'process.env.NEXT_MINIMAL': '',
|
||||
'process.env.__NEXT_APP_NAV_FAIL_HANDLING': Boolean(config.experimental.appNavFailHandling),
|
||||
'process.env.__NEXT_PPR': isPPREnabled,
|
||||
'process.env.__NEXT_CACHE_COMPONENTS': isCacheComponentsEnabled,
|
||||
'process.env.__NEXT_USE_CACHE': isUseCacheEnabled,
|
||||
...isClient ? {
|
||||
// TODO use `globalThis.NEXT_DEPLOYMENT_ID` on client to still support accessing
|
||||
// process.env.NEXT_DEPLOYMENT_ID in userland
|
||||
'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.useSkewCookie) ? false : config.deploymentId || false
|
||||
} : ((_config_experimental1 = config.experimental) == null ? void 0 : _config_experimental1.runtimeServerDeploymentId) ? {
|
||||
} : {
|
||||
'process.env.NEXT_DEPLOYMENT_ID': ((_config_experimental2 = config.experimental) == null ? void 0 : _config_experimental2.useSkewCookie) ? false : config.deploymentId || false
|
||||
},
|
||||
// Propagates the `__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING` environment
|
||||
// variable to the client.
|
||||
'process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING': process.env.__NEXT_EXPERIMENTAL_STATIC_SHELL_DEBUGGING || false,
|
||||
'process.env.__NEXT_FETCH_CACHE_KEY_PREFIX': fetchCacheKeyPrefix ?? '',
|
||||
...isTurbopack ? {} : {
|
||||
'process.env.__NEXT_MIDDLEWARE_MATCHERS': middlewareMatchers ?? []
|
||||
},
|
||||
'process.env.__NEXT_MANUAL_CLIENT_BASE_PATH': config.experimental.manualClientBasePath ?? false,
|
||||
'process.env.__NEXT_CLIENT_ROUTER_DYNAMIC_STALETIME': JSON.stringify(isNaN(Number((_config_experimental_staleTimes = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes.dynamic)) ? 0 : (_config_experimental_staleTimes1 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes1.dynamic),
|
||||
'process.env.__NEXT_CLIENT_ROUTER_STATIC_STALETIME': JSON.stringify(isNaN(Number((_config_experimental_staleTimes2 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes2.static)) ? 5 * 60 // 5 minutes
|
||||
: (_config_experimental_staleTimes3 = config.experimental.staleTimes) == null ? void 0 : _config_experimental_staleTimes3.static),
|
||||
'process.env.__NEXT_CLIENT_ROUTER_FILTER_ENABLED': config.experimental.clientRouterFilter ?? true,
|
||||
'process.env.__NEXT_CLIENT_ROUTER_S_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.staticFilter) ?? false,
|
||||
'process.env.__NEXT_CLIENT_ROUTER_D_FILTER': (clientRouterFilters == null ? void 0 : clientRouterFilters.dynamicFilter) ?? false,
|
||||
'process.env.__NEXT_CLIENT_VALIDATE_RSC_REQUEST_HEADERS': Boolean(config.experimental.validateRSCRequestHeaders),
|
||||
'process.env.__NEXT_DYNAMIC_ON_HOVER': Boolean(config.experimental.dynamicOnHover),
|
||||
'process.env.__NEXT_OPTIMISTIC_CLIENT_CACHE': config.experimental.optimisticClientCache ?? true,
|
||||
'process.env.__NEXT_MIDDLEWARE_PREFETCH': config.experimental.proxyPrefetch ?? 'flexible',
|
||||
'process.env.__NEXT_CROSS_ORIGIN': config.crossOrigin,
|
||||
'process.browser': isClient,
|
||||
'process.env.__NEXT_TEST_MODE': process.env.__NEXT_TEST_MODE ?? false,
|
||||
// This is used in client/dev-error-overlay/hot-dev-client.js to replace the dist directory
|
||||
...dev && (isClient ?? isEdgeServer) ? {
|
||||
'process.env.__NEXT_DIST_DIR': distDir
|
||||
} : {},
|
||||
// This is used in devtools to strip the project path in edge runtime,
|
||||
// as there's only a dummy `dir` value (`.`) as edge runtime doesn't have concept of file system.
|
||||
...dev && isEdgeServer ? {
|
||||
'process.env.__NEXT_EDGE_PROJECT_DIR': isTurbopack ? _nodepath.default.relative(process.cwd(), projectPath) : projectPath
|
||||
} : {},
|
||||
'process.env.__NEXT_BASE_PATH': config.basePath,
|
||||
'process.env.__NEXT_CASE_SENSITIVE_ROUTES': Boolean(config.experimental.caseSensitiveRoutes),
|
||||
'process.env.__NEXT_REWRITES': rewrites,
|
||||
'process.env.__NEXT_TRAILING_SLASH': config.trailingSlash,
|
||||
'process.env.__NEXT_DEV_INDICATOR': config.devIndicators !== false,
|
||||
'process.env.__NEXT_DEV_INDICATOR_POSITION': config.devIndicators === false ? 'bottom-left' // This will not be used as the indicator is disabled.
|
||||
: config.devIndicators.position ?? 'bottom-left',
|
||||
'process.env.__NEXT_STRICT_MODE': config.reactStrictMode === null ? false : config.reactStrictMode,
|
||||
'process.env.__NEXT_STRICT_MODE_APP': // When next.config.js does not have reactStrictMode it's enabled by default.
|
||||
config.reactStrictMode === null ? true : config.reactStrictMode,
|
||||
'process.env.__NEXT_OPTIMIZE_CSS': (config.experimental.optimizeCss && !dev) ?? false,
|
||||
'process.env.__NEXT_SCRIPT_WORKERS': (config.experimental.nextScriptWorkers && !dev) ?? false,
|
||||
'process.env.__NEXT_SCROLL_RESTORATION': config.experimental.scrollRestoration ?? false,
|
||||
...getImageConfig(config, dev),
|
||||
'process.env.__NEXT_ROUTER_BASEPATH': config.basePath,
|
||||
'process.env.__NEXT_HAS_REWRITES': hasRewrites,
|
||||
'process.env.__NEXT_CONFIG_OUTPUT': config.output,
|
||||
'process.env.__NEXT_I18N_SUPPORT': !!config.i18n,
|
||||
'process.env.__NEXT_I18N_DOMAINS': ((_config_i18n = config.i18n) == null ? void 0 : _config_i18n.domains) ?? false,
|
||||
'process.env.__NEXT_I18N_CONFIG': config.i18n || '',
|
||||
'process.env.__NEXT_NO_MIDDLEWARE_URL_NORMALIZE': config.skipProxyUrlNormalize,
|
||||
'process.env.__NEXT_EXTERNAL_MIDDLEWARE_REWRITE_RESOLVE': config.experimental.externalProxyRewritesResolve ?? false,
|
||||
'process.env.__NEXT_MANUAL_TRAILING_SLASH': config.skipTrailingSlashRedirect,
|
||||
'process.env.__NEXT_HAS_WEB_VITALS_ATTRIBUTION': (config.experimental.webVitalsAttribution && config.experimental.webVitalsAttribution.length > 0) ?? false,
|
||||
'process.env.__NEXT_WEB_VITALS_ATTRIBUTION': config.experimental.webVitalsAttribution ?? false,
|
||||
'process.env.__NEXT_LINK_NO_TOUCH_START': config.experimental.linkNoTouchStart ?? false,
|
||||
'process.env.__NEXT_ASSET_PREFIX': config.assetPrefix,
|
||||
'process.env.__NEXT_EXPERIMENTAL_AUTH_INTERRUPTS': !!config.experimental.authInterrupts,
|
||||
'process.env.__NEXT_TELEMETRY_DISABLED': Boolean(process.env.NEXT_TELEMETRY_DISABLED),
|
||||
...isNodeServer || isEdgeServer ? {
|
||||
// Fix bad-actors in the npm ecosystem (e.g. `node-formidable`)
|
||||
// This is typically found in unmaintained modules from the
|
||||
// pre-webpack era (common in server-side code)
|
||||
'global.GENTLY': false
|
||||
} : undefined,
|
||||
...isNodeServer || isEdgeServer ? {
|
||||
'process.env.__NEXT_EXPERIMENTAL_REACT': (0, _needsexperimentalreact.needsExperimentalReact)(config)
|
||||
} : undefined,
|
||||
'process.env.__NEXT_MULTI_ZONE_DRAFT_MODE': config.experimental.multiZoneDraftMode ?? false,
|
||||
'process.env.__NEXT_TRUST_HOST_HEADER': config.experimental.trustHostHeader ?? false,
|
||||
'process.env.__NEXT_ALLOWED_REVALIDATE_HEADERS': config.experimental.allowedRevalidateHeaderKeys ?? [],
|
||||
...isNodeServer || isEdgeServer ? {
|
||||
'process.env.__NEXT_RELATIVE_DIST_DIR': config.distDir,
|
||||
'process.env.__NEXT_RELATIVE_PROJECT_DIR': _nodepath.default.relative(process.cwd(), projectPath)
|
||||
} : {},
|
||||
'process.env.__NEXT_BROWSER_DEBUG_INFO_IN_TERMINAL': JSON.stringify(config.experimental.browserDebugInfoInTerminal || false),
|
||||
'process.env.__NEXT_MCP_SERVER': !!config.experimental.mcpServer,
|
||||
// The devtools need to know whether or not to show an option to clear the
|
||||
// bundler cache. This option may be removed later once Turbopack's
|
||||
// filesystem cache feature is more stable.
|
||||
//
|
||||
// This environment value is currently best-effort:
|
||||
// - It's possible to disable the webpack filesystem cache, but it's
|
||||
// unlikely for a user to do that.
|
||||
// - Rspack's filesystem cache is unstable and requires a different
|
||||
// configuration than webpack to enable (which we don't do).
|
||||
//
|
||||
// In the worst case we'll show an option to clear the cache, but it'll be a
|
||||
// no-op that just restarts the development server.
|
||||
'process.env.__NEXT_BUNDLER_HAS_PERSISTENT_CACHE': !isTurbopack || (config.experimental.turbopackFileSystemCacheForDev ?? false),
|
||||
'process.env.__NEXT_REACT_DEBUG_CHANNEL': config.experimental.reactDebugChannel ?? false,
|
||||
'process.env.__NEXT_TRANSITION_INDICATOR': config.experimental.transitionIndicator ?? false
|
||||
};
|
||||
const userDefines = ((_config_compiler = config.compiler) == null ? void 0 : _config_compiler.define) ?? {};
|
||||
for(const key in userDefines){
|
||||
if (defineEnv.hasOwnProperty(key)) {
|
||||
throw Object.defineProperty(new Error(`The \`compiler.define\` option is configured to replace the \`${key}\` variable. This variable is either part of a Next.js built-in or is already configured.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E688",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
defineEnv[key] = userDefines[key];
|
||||
}
|
||||
if (isNodeServer || isEdgeServer) {
|
||||
var _config_compiler1;
|
||||
const userDefinesServer = ((_config_compiler1 = config.compiler) == null ? void 0 : _config_compiler1.defineServer) ?? {};
|
||||
for(const key in userDefinesServer){
|
||||
if (defineEnv.hasOwnProperty(key)) {
|
||||
throw Object.defineProperty(new Error(`The \`compiler.defineServer\` option is configured to replace the \`${key}\` variable. This variable is either part of a Next.js built-in or is already configured.`), "__NEXT_ERROR_CODE", {
|
||||
value: "E689",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
defineEnv[key] = userDefinesServer[key];
|
||||
}
|
||||
}
|
||||
const serializedDefineEnv = serializeDefineEnv(defineEnv);
|
||||
// we delay inlining these values until after the build
|
||||
// with flying shuttle enabled so we can update them
|
||||
// without invalidating entries
|
||||
if (!dev && omitNonDeterministic) {
|
||||
// client uses window. instead of leaving process.env
|
||||
// in case process isn't polyfilled on client already
|
||||
// since by this point it won't be added by webpack
|
||||
const safeKey = (key)=>isClient ? `window.${key.split('.').pop()}` : key;
|
||||
for(const key in nextPublicEnv){
|
||||
serializedDefineEnv[key] = safeKey(key);
|
||||
}
|
||||
for(const key in nextConfigEnv){
|
||||
serializedDefineEnv[key] = safeKey(key);
|
||||
}
|
||||
if (!config.experimental.runtimeServerDeploymentId) {
|
||||
for (const key of [
|
||||
'process.env.NEXT_DEPLOYMENT_ID'
|
||||
]){
|
||||
serializedDefineEnv[key] = safeKey(key);
|
||||
}
|
||||
}
|
||||
}
|
||||
return serializedDefineEnv;
|
||||
}
|
||||
|
||||
//# sourceMappingURL=define-env.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/define-env.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/define-env.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
36
apps/public-web/node_modules/next/dist/build/duration-to-string.d.ts
generated
vendored
Normal file
36
apps/public-web/node_modules/next/dist/build/duration-to-string.d.ts
generated
vendored
Normal file
@@ -0,0 +1,36 @@
|
||||
/**
|
||||
* Converts a duration in seconds to a human-readable string format.
|
||||
* Formats duration based on magnitude for optimal readability:
|
||||
* - >= 2 minutes: show in minutes with 1 decimal place (e.g., "2.5min")
|
||||
* - >= 40 seconds: show in whole seconds (e.g., "45s")
|
||||
* - >= 2 seconds: show in seconds with 1 decimal place (e.g., "3.2s")
|
||||
* - < 2 seconds: show in milliseconds with 1 decimal place (e.g., "1500.0ms")
|
||||
*
|
||||
* @deprecated Use durationToStringWithNanoseconds instead, collect time in nanoseconds using process.hrtime.bigint().
|
||||
* @param compilerDuration - Duration in seconds as a number
|
||||
* @returns Formatted duration string with appropriate unit and precision
|
||||
*/
|
||||
export declare function durationToString(compilerDuration: number): string;
|
||||
/**
|
||||
* Converts a high-resolution time tuple to seconds.
|
||||
*
|
||||
* @param hrtime - High-resolution time tuple of [seconds, nanoseconds]
|
||||
* @returns Duration in seconds as a floating-point number
|
||||
*/
|
||||
export declare function hrtimeToSeconds(hrtime: [number, number]): number;
|
||||
/**
|
||||
* Converts a BigInt nanosecond duration to a human-readable string format.
|
||||
* This is the preferred method for formatting high-precision durations.
|
||||
*
|
||||
* @param hrtime - Duration in nanoseconds as a BigInt (typically from process.hrtime.bigint())
|
||||
* @returns Formatted duration string with appropriate unit and precision
|
||||
*/
|
||||
export declare function hrtimeBigIntDurationToString(hrtime: bigint): string;
|
||||
/**
|
||||
* Converts a high-resolution time tuple to a human-readable string format.
|
||||
*
|
||||
* @deprecated Use hrtimeBigIntDurationToString with process.hrtime.bigint() for better precision.
|
||||
* @param hrtime - High-resolution time tuple of [seconds, nanoseconds]
|
||||
* @returns Formatted duration string with appropriate unit and precision
|
||||
*/
|
||||
export declare function hrtimeDurationToString(hrtime: [number, number]): string;
|
||||
99
apps/public-web/node_modules/next/dist/build/duration-to-string.js
generated
vendored
Normal file
99
apps/public-web/node_modules/next/dist/build/duration-to-string.js
generated
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
// Time thresholds in seconds
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
durationToString: null,
|
||||
hrtimeBigIntDurationToString: null,
|
||||
hrtimeDurationToString: null,
|
||||
hrtimeToSeconds: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
durationToString: function() {
|
||||
return durationToString;
|
||||
},
|
||||
hrtimeBigIntDurationToString: function() {
|
||||
return hrtimeBigIntDurationToString;
|
||||
},
|
||||
hrtimeDurationToString: function() {
|
||||
return hrtimeDurationToString;
|
||||
},
|
||||
hrtimeToSeconds: function() {
|
||||
return hrtimeToSeconds;
|
||||
}
|
||||
});
|
||||
const SECONDS_IN_MINUTE = 60;
|
||||
const MINUTES_THRESHOLD_SECONDS = 120 // 2 minutes
|
||||
;
|
||||
const SECONDS_THRESHOLD_HIGH = 40;
|
||||
const SECONDS_THRESHOLD_LOW = 2;
|
||||
const MILLISECONDS_PER_SECOND = 1000;
|
||||
// Time thresholds and conversion factors for nanoseconds
|
||||
const NANOSECONDS_PER_SECOND = 1000000000;
|
||||
const NANOSECONDS_PER_MILLISECOND = 1000000;
|
||||
const NANOSECONDS_PER_MICROSECOND = 1000;
|
||||
const NANOSECONDS_IN_MINUTE = 60000000000 // 60 * 1_000_000_000
|
||||
;
|
||||
const MINUTES_THRESHOLD_NANOSECONDS = 120000000000 // 2 minutes in nanoseconds
|
||||
;
|
||||
const SECONDS_THRESHOLD_HIGH_NANOSECONDS = 40000000000 // 40 seconds in nanoseconds
|
||||
;
|
||||
const SECONDS_THRESHOLD_LOW_NANOSECONDS = 2000000000 // 2 seconds in nanoseconds
|
||||
;
|
||||
const MILLISECONDS_THRESHOLD_NANOSECONDS = 2000000 // 2 milliseconds in nanoseconds
|
||||
;
|
||||
function durationToString(compilerDuration) {
|
||||
if (compilerDuration > MINUTES_THRESHOLD_SECONDS) {
|
||||
return `${(compilerDuration / SECONDS_IN_MINUTE).toFixed(1)}min`;
|
||||
} else if (compilerDuration > SECONDS_THRESHOLD_HIGH) {
|
||||
return `${compilerDuration.toFixed(0)}s`;
|
||||
} else if (compilerDuration > SECONDS_THRESHOLD_LOW) {
|
||||
return `${compilerDuration.toFixed(1)}s`;
|
||||
} else {
|
||||
return `${(compilerDuration * MILLISECONDS_PER_SECOND).toFixed(1)}ms`;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Converts a nanosecond duration to a human-readable string format.
|
||||
* Formats duration based on magnitude for optimal readability:
|
||||
* - >= 2 minutes: show in minutes with 1 decimal place (e.g., "2.5min")
|
||||
* - >= 40 seconds: show in whole seconds (e.g., "45s")
|
||||
* - >= 2 seconds: show in seconds with 1 decimal place (e.g., "3.2s")
|
||||
* - >= 2 milliseconds: show in whole milliseconds (e.g., "250ms")
|
||||
* - < 2 milliseconds: show in whole microseconds (e.g., "500µs")
|
||||
*
|
||||
* @param durationBigInt - Duration in nanoseconds as a BigInt
|
||||
* @returns Formatted duration string with appropriate unit and precision
|
||||
*/ function durationToStringWithNanoseconds(durationBigInt) {
|
||||
const duration = Number(durationBigInt);
|
||||
if (duration >= MINUTES_THRESHOLD_NANOSECONDS) {
|
||||
return `${(duration / NANOSECONDS_IN_MINUTE).toFixed(1)}min`;
|
||||
} else if (duration >= SECONDS_THRESHOLD_HIGH_NANOSECONDS) {
|
||||
return `${(duration / NANOSECONDS_PER_SECOND).toFixed(0)}s`;
|
||||
} else if (duration >= SECONDS_THRESHOLD_LOW_NANOSECONDS) {
|
||||
return `${(duration / NANOSECONDS_PER_SECOND).toFixed(1)}s`;
|
||||
} else if (duration >= MILLISECONDS_THRESHOLD_NANOSECONDS) {
|
||||
return `${(duration / NANOSECONDS_PER_MILLISECOND).toFixed(0)}ms`;
|
||||
} else {
|
||||
return `${(duration / NANOSECONDS_PER_MICROSECOND).toFixed(0)}µs`;
|
||||
}
|
||||
}
|
||||
function hrtimeToSeconds(hrtime) {
|
||||
// hrtime is a tuple of [seconds, nanoseconds]
|
||||
return hrtime[0] + hrtime[1] / NANOSECONDS_PER_SECOND;
|
||||
}
|
||||
function hrtimeBigIntDurationToString(hrtime) {
|
||||
return durationToStringWithNanoseconds(hrtime);
|
||||
}
|
||||
function hrtimeDurationToString(hrtime) {
|
||||
return durationToString(hrtimeToSeconds(hrtime));
|
||||
}
|
||||
|
||||
//# sourceMappingURL=duration-to-string.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/duration-to-string.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/duration-to-string.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
220
apps/public-web/node_modules/next/dist/build/entries.d.ts
generated
vendored
Normal file
220
apps/public-web/node_modules/next/dist/build/entries.d.ts
generated
vendored
Normal file
@@ -0,0 +1,220 @@
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { webpack } from 'next/dist/compiled/webpack/webpack';
|
||||
import type { ProxyConfig } from './analysis/get-page-static-info';
|
||||
import type { LoadedEnvFiles } from '@next/env';
|
||||
import type { AppLoaderOptions } from './webpack/loaders/next-app-loader';
|
||||
import type { CompilerNameValues } from '../shared/lib/constants';
|
||||
import type { __ApiPreviewProps } from '../server/api-utils';
|
||||
import type { ServerRuntime } from '../types';
|
||||
import type { PageExtensions } from './page-extensions-type';
|
||||
import type { MappedPages } from './build-context';
|
||||
import { PAGE_TYPES } from '../lib/page-types';
|
||||
import type { createValidFileMatcher } from '../server/lib/find-page-file';
|
||||
/**
|
||||
* Collect app pages, layouts, and default files from the app directory
|
||||
* @param appDir - The app directory path
|
||||
* @param validFileMatcher - File matcher object
|
||||
* @returns Object containing appPaths, layoutPaths, and defaultPaths arrays
|
||||
*/
|
||||
export declare function collectAppFiles(appDir: string, validFileMatcher: ReturnType<typeof createValidFileMatcher>): Promise<{
|
||||
appPaths: string[];
|
||||
layoutPaths: string[];
|
||||
defaultPaths: string[];
|
||||
}>;
|
||||
/**
|
||||
* Collect pages from the pages directory
|
||||
* @param pagesDir - The pages directory path
|
||||
* @param validFileMatcher - File matcher object
|
||||
* @returns Array of page file paths
|
||||
*/
|
||||
export declare function collectPagesFiles(pagesDir: string, validFileMatcher: ReturnType<typeof createValidFileMatcher>): Promise<string[]>;
|
||||
export type RouteInfo = {
|
||||
route: string;
|
||||
filePath: string;
|
||||
};
|
||||
export type SlotInfo = {
|
||||
name: string;
|
||||
parent: string;
|
||||
};
|
||||
/**
|
||||
* Create a relative file path from a mapped page path
|
||||
* @param baseDir - The base directory path
|
||||
* @param filePath - The mapped file path (with private prefix)
|
||||
* @param prefix - The directory prefix ('pages' or 'app')
|
||||
* @param isSrcDir - Whether the project uses src directory structure
|
||||
* @returns The relative file path
|
||||
*/
|
||||
export declare function createRelativeFilePath(baseDir: string, filePath: string, prefix: 'pages' | 'app', isSrcDir: boolean): string;
|
||||
/**
|
||||
* Process pages routes from mapped pages
|
||||
* @param mappedPages - The mapped pages object
|
||||
* @param baseDir - The base directory path
|
||||
* @param isSrcDir - Whether the project uses src directory structure
|
||||
* @returns Object containing pageRoutes and pageApiRoutes
|
||||
*/
|
||||
export declare function processPageRoutes(mappedPages: {
|
||||
[page: string]: string;
|
||||
}, baseDir: string, isSrcDir: boolean): {
|
||||
pageRoutes: RouteInfo[];
|
||||
pageApiRoutes: RouteInfo[];
|
||||
};
|
||||
/**
|
||||
* Extract slots from app routes
|
||||
* @param mappedAppPages - The mapped app pages object
|
||||
* @returns Array of slot information
|
||||
*/
|
||||
export declare function extractSlotsFromAppRoutes(mappedAppPages: {
|
||||
[page: string]: string;
|
||||
}): SlotInfo[];
|
||||
/**
|
||||
* Extract slots from default files
|
||||
* @param mappedDefaultFiles - The mapped default files object
|
||||
* @returns Array of slot information
|
||||
*/
|
||||
export declare function extractSlotsFromDefaultFiles(mappedDefaultFiles: {
|
||||
[page: string]: string;
|
||||
}): SlotInfo[];
|
||||
/**
|
||||
* Combine and deduplicate slot arrays using a Set
|
||||
* @param slotArrays - Arrays of slot information to combine
|
||||
* @returns Deduplicated array of slots
|
||||
*/
|
||||
export declare function combineSlots(...slotArrays: SlotInfo[][]): SlotInfo[];
|
||||
/**
|
||||
* Process app routes from mapped app pages
|
||||
* @param mappedAppPages - The mapped app pages object
|
||||
* @param validFileMatcher - File matcher object
|
||||
* @param baseDir - The base directory path
|
||||
* @param isSrcDir - Whether the project uses src directory structure
|
||||
* @returns Array of route information
|
||||
*/
|
||||
export declare function processAppRoutes(mappedAppPages: {
|
||||
[page: string]: string;
|
||||
}, validFileMatcher: ReturnType<typeof createValidFileMatcher>, baseDir: string, isSrcDir: boolean): {
|
||||
appRoutes: RouteInfo[];
|
||||
appRouteHandlers: RouteInfo[];
|
||||
};
|
||||
/**
|
||||
* Process layout routes from mapped app layouts
|
||||
* @param mappedAppLayouts - The mapped app layouts object
|
||||
* @param baseDir - The base directory path
|
||||
* @param isSrcDir - Whether the project uses src directory structure
|
||||
* @returns Array of layout route information
|
||||
*/
|
||||
export declare function processLayoutRoutes(mappedAppLayouts: {
|
||||
[page: string]: string;
|
||||
}, baseDir: string, isSrcDir: boolean): RouteInfo[];
|
||||
type ObjectValue<T> = T extends {
|
||||
[key: string]: infer V;
|
||||
} ? V : never;
|
||||
/**
|
||||
* For a given page path removes the provided extensions.
|
||||
*/
|
||||
export declare function getPageFromPath(pagePath: string, pageExtensions: PageExtensions): string;
|
||||
export declare function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir, }: {
|
||||
absolutePagePath: string;
|
||||
pagesDir: string | undefined;
|
||||
appDir: string | undefined;
|
||||
rootDir: string;
|
||||
}): string;
|
||||
/**
|
||||
* Creates a mapping of route to page file path for a given list of page paths.
|
||||
* For example ['/middleware.ts'] is turned into { '/middleware': `${ROOT_DIR_ALIAS}/middleware.ts` }
|
||||
*/
|
||||
export declare function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, appDirOnly, }: {
|
||||
isDev: boolean;
|
||||
pageExtensions: PageExtensions;
|
||||
pagePaths: string[];
|
||||
pagesType: PAGE_TYPES;
|
||||
pagesDir: string | undefined;
|
||||
appDir: string | undefined;
|
||||
appDirOnly: boolean;
|
||||
}): Promise<MappedPages>;
|
||||
export interface CreateEntrypointsParams {
|
||||
buildId: string;
|
||||
config: NextConfigComplete;
|
||||
envFiles: LoadedEnvFiles;
|
||||
isDev: boolean;
|
||||
pages: MappedPages;
|
||||
pagesDir?: string;
|
||||
previewMode: __ApiPreviewProps;
|
||||
rootDir: string;
|
||||
rootPaths?: MappedPages;
|
||||
appDir?: string;
|
||||
appPaths?: MappedPages;
|
||||
pageExtensions: PageExtensions;
|
||||
hasInstrumentationHook?: boolean;
|
||||
}
|
||||
export declare function getEdgeServerEntry(opts: {
|
||||
rootDir: string;
|
||||
absolutePagePath: string;
|
||||
buildId: string;
|
||||
bundlePath: string;
|
||||
config: NextConfigComplete;
|
||||
isDev: boolean;
|
||||
isServerComponent: boolean;
|
||||
page: string;
|
||||
pages: MappedPages;
|
||||
middleware?: Partial<ProxyConfig>;
|
||||
pagesType: PAGE_TYPES;
|
||||
appDirLoader?: string;
|
||||
hasInstrumentationHook?: boolean;
|
||||
preferredRegion: string | string[] | undefined;
|
||||
middlewareConfig?: ProxyConfig;
|
||||
}): {
|
||||
import: string;
|
||||
layer: "rsc";
|
||||
filename?: undefined;
|
||||
} | {
|
||||
import: string;
|
||||
layer: "middleware";
|
||||
filename: string | undefined;
|
||||
} | {
|
||||
import: string;
|
||||
layer: "api-edge";
|
||||
filename?: undefined;
|
||||
} | {
|
||||
import: string;
|
||||
layer: "ssr" | undefined;
|
||||
filename?: undefined;
|
||||
};
|
||||
export declare function getInstrumentationEntry(opts: {
|
||||
absolutePagePath: string;
|
||||
isEdgeServer: boolean;
|
||||
isDev: boolean;
|
||||
}): {
|
||||
import: string;
|
||||
filename: string;
|
||||
layer: "instrument";
|
||||
};
|
||||
export declare function getAppLoader(): "builtin:next-app-loader" | "next-app-loader";
|
||||
export declare function getAppEntry(opts: Readonly<AppLoaderOptions>): {
|
||||
import: string;
|
||||
layer: "rsc";
|
||||
};
|
||||
export declare function getClientEntry(opts: {
|
||||
absolutePagePath: string;
|
||||
page: string;
|
||||
}): string | string[];
|
||||
export declare function runDependingOnPageType<T>(params: {
|
||||
onClient: () => T;
|
||||
onEdgeServer: () => T;
|
||||
onServer: () => T;
|
||||
page: string;
|
||||
pageRuntime: ServerRuntime;
|
||||
pageType?: PAGE_TYPES;
|
||||
}): void;
|
||||
export declare function createEntrypoints(params: CreateEntrypointsParams): Promise<{
|
||||
client: webpack.EntryObject;
|
||||
server: webpack.EntryObject;
|
||||
edgeServer: webpack.EntryObject;
|
||||
middlewareMatchers: undefined;
|
||||
}>;
|
||||
export declare function finalizeEntrypoint({ name, compilerType, value, isServerComponent, hasAppDir, }: {
|
||||
compilerType: CompilerNameValues;
|
||||
name: string;
|
||||
value: ObjectValue<webpack.EntryObject>;
|
||||
isServerComponent?: boolean;
|
||||
hasAppDir?: boolean;
|
||||
}): ObjectValue<webpack.EntryObject>;
|
||||
export {};
|
||||
798
apps/public-web/node_modules/next/dist/build/entries.js
generated
vendored
Normal file
798
apps/public-web/node_modules/next/dist/build/entries.js
generated
vendored
Normal file
@@ -0,0 +1,798 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
collectAppFiles: null,
|
||||
collectPagesFiles: null,
|
||||
combineSlots: null,
|
||||
createEntrypoints: null,
|
||||
createPagesMapping: null,
|
||||
createRelativeFilePath: null,
|
||||
extractSlotsFromAppRoutes: null,
|
||||
extractSlotsFromDefaultFiles: null,
|
||||
finalizeEntrypoint: null,
|
||||
getAppEntry: null,
|
||||
getAppLoader: null,
|
||||
getClientEntry: null,
|
||||
getEdgeServerEntry: null,
|
||||
getInstrumentationEntry: null,
|
||||
getPageFilePath: null,
|
||||
getPageFromPath: null,
|
||||
processAppRoutes: null,
|
||||
processLayoutRoutes: null,
|
||||
processPageRoutes: null,
|
||||
runDependingOnPageType: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
collectAppFiles: function() {
|
||||
return collectAppFiles;
|
||||
},
|
||||
collectPagesFiles: function() {
|
||||
return collectPagesFiles;
|
||||
},
|
||||
combineSlots: function() {
|
||||
return combineSlots;
|
||||
},
|
||||
createEntrypoints: function() {
|
||||
return createEntrypoints;
|
||||
},
|
||||
createPagesMapping: function() {
|
||||
return createPagesMapping;
|
||||
},
|
||||
createRelativeFilePath: function() {
|
||||
return createRelativeFilePath;
|
||||
},
|
||||
extractSlotsFromAppRoutes: function() {
|
||||
return extractSlotsFromAppRoutes;
|
||||
},
|
||||
extractSlotsFromDefaultFiles: function() {
|
||||
return extractSlotsFromDefaultFiles;
|
||||
},
|
||||
finalizeEntrypoint: function() {
|
||||
return finalizeEntrypoint;
|
||||
},
|
||||
getAppEntry: function() {
|
||||
return getAppEntry;
|
||||
},
|
||||
getAppLoader: function() {
|
||||
return getAppLoader;
|
||||
},
|
||||
getClientEntry: function() {
|
||||
return getClientEntry;
|
||||
},
|
||||
getEdgeServerEntry: function() {
|
||||
return getEdgeServerEntry;
|
||||
},
|
||||
getInstrumentationEntry: function() {
|
||||
return getInstrumentationEntry;
|
||||
},
|
||||
getPageFilePath: function() {
|
||||
return getPageFilePath;
|
||||
},
|
||||
getPageFromPath: function() {
|
||||
return getPageFromPath;
|
||||
},
|
||||
processAppRoutes: function() {
|
||||
return processAppRoutes;
|
||||
},
|
||||
processLayoutRoutes: function() {
|
||||
return processLayoutRoutes;
|
||||
},
|
||||
processPageRoutes: function() {
|
||||
return processPageRoutes;
|
||||
},
|
||||
runDependingOnPageType: function() {
|
||||
return runDependingOnPageType;
|
||||
}
|
||||
});
|
||||
const _path = require("path");
|
||||
const _querystring = require("querystring");
|
||||
const _constants = require("../lib/constants");
|
||||
const _isapiroute = require("../lib/is-api-route");
|
||||
const _isedgeruntime = require("../lib/is-edge-runtime");
|
||||
const _constants1 = require("../shared/lib/constants");
|
||||
const _utils = require("./utils");
|
||||
const _getpagestaticinfo = require("./analysis/get-page-static-info");
|
||||
const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
|
||||
const _normalizepagepath = require("../shared/lib/page-path/normalize-page-path");
|
||||
const _apppaths = require("../shared/lib/router/utils/app-paths");
|
||||
const _nextmiddlewareloader = require("./webpack/loaders/next-middleware-loader");
|
||||
const _isapprouteroute = require("../lib/is-app-route-route");
|
||||
const _getmetadataroute = require("../lib/metadata/get-metadata-route");
|
||||
const _nextrouteloader = require("./webpack/loaders/next-route-loader");
|
||||
const _isinternalcomponent = require("../lib/is-internal-component");
|
||||
const _ismetadataroute = require("../lib/metadata/is-metadata-route");
|
||||
const _routekind = require("../server/route-kind");
|
||||
const _utils1 = require("./webpack/loaders/utils");
|
||||
const _normalizecatchallroutes = require("./normalize-catchall-routes");
|
||||
const _pagetypes = require("../lib/page-types");
|
||||
const _recursivereaddir = require("../lib/recursive-readdir");
|
||||
const _segment = require("../shared/lib/segment");
|
||||
const _ensureleadingslash = require("../shared/lib/page-path/ensure-leading-slash");
|
||||
const _entryconstants = require("../shared/lib/entry-constants");
|
||||
const _getstaticinfoincludinglayouts = require("./get-static-info-including-layouts");
|
||||
async function collectAppFiles(appDir, validFileMatcher) {
|
||||
// Collect app pages, layouts, and default files in a single directory traversal
|
||||
const allAppFiles = await (0, _recursivereaddir.recursiveReadDir)(appDir, {
|
||||
pathnameFilter: (absolutePath)=>validFileMatcher.isAppRouterPage(absolutePath) || validFileMatcher.isRootNotFound(absolutePath) || validFileMatcher.isAppLayoutPage(absolutePath) || validFileMatcher.isAppDefaultPage(absolutePath),
|
||||
ignorePartFilter: (part)=>part.startsWith('_')
|
||||
});
|
||||
// Separate app pages, layouts, and defaults
|
||||
const appPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppRouterPage(absolutePath) || validFileMatcher.isRootNotFound(absolutePath));
|
||||
const layoutPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppLayoutPage(absolutePath));
|
||||
const defaultPaths = allAppFiles.filter((absolutePath)=>validFileMatcher.isAppDefaultPage(absolutePath));
|
||||
return {
|
||||
appPaths,
|
||||
layoutPaths,
|
||||
defaultPaths
|
||||
};
|
||||
}
|
||||
async function collectPagesFiles(pagesDir, validFileMatcher) {
|
||||
return (0, _recursivereaddir.recursiveReadDir)(pagesDir, {
|
||||
pathnameFilter: validFileMatcher.isPageFile
|
||||
});
|
||||
}
|
||||
function createRelativeFilePath(baseDir, filePath, prefix, isSrcDir) {
|
||||
const privatePrefix = prefix === 'pages' ? 'private-next-pages' : 'private-next-app-dir';
|
||||
const srcPrefix = isSrcDir ? 'src/' : '';
|
||||
return (0, _path.join)(baseDir, filePath.replace(new RegExp(`^${privatePrefix}/`), `${srcPrefix}${prefix}/`));
|
||||
}
|
||||
function processPageRoutes(mappedPages, baseDir, isSrcDir) {
|
||||
const pageRoutes = [];
|
||||
const pageApiRoutes = [];
|
||||
for (const [route, filePath] of Object.entries(mappedPages)){
|
||||
const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'pages', isSrcDir);
|
||||
if (route.startsWith('/api/')) {
|
||||
pageApiRoutes.push({
|
||||
route: (0, _normalizepathsep.normalizePathSep)(route),
|
||||
filePath: relativeFilePath
|
||||
});
|
||||
} else {
|
||||
// Filter out _app, _error, _document
|
||||
if ((0, _utils.isReservedPage)(route)) continue;
|
||||
pageRoutes.push({
|
||||
route: (0, _normalizepathsep.normalizePathSep)(route),
|
||||
filePath: relativeFilePath
|
||||
});
|
||||
}
|
||||
}
|
||||
return {
|
||||
pageRoutes,
|
||||
pageApiRoutes
|
||||
};
|
||||
}
|
||||
function extractSlotsFromAppRoutes(mappedAppPages) {
|
||||
const slots = [];
|
||||
for (const [page] of Object.entries(mappedAppPages)){
|
||||
if (page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
|
||||
continue;
|
||||
}
|
||||
const segments = page.split('/');
|
||||
for(let i = segments.length - 1; i >= 0; i--){
|
||||
const segment = segments[i];
|
||||
if ((0, _segment.isParallelRouteSegment)(segment)) {
|
||||
const parentPath = (0, _apppaths.normalizeAppPath)(segments.slice(0, i).join('/'));
|
||||
const slotName = segment.slice(1);
|
||||
// Check if the slot already exists
|
||||
if (slots.some((s)=>s.name === slotName && s.parent === parentPath)) continue;
|
||||
slots.push({
|
||||
name: slotName,
|
||||
parent: parentPath
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return slots;
|
||||
}
|
||||
function extractSlotsFromDefaultFiles(mappedDefaultFiles) {
|
||||
const slots = [];
|
||||
for (const [route] of Object.entries(mappedDefaultFiles)){
|
||||
const segments = route.split('/');
|
||||
for(let i = segments.length - 1; i >= 0; i--){
|
||||
const segment = segments[i];
|
||||
if ((0, _segment.isParallelRouteSegment)(segment)) {
|
||||
const parentPath = (0, _apppaths.normalizeAppPath)(segments.slice(0, i).join('/'));
|
||||
const slotName = segment.slice(1);
|
||||
// Check if the slot already exists
|
||||
if (slots.some((s)=>s.name === slotName && s.parent === parentPath)) continue;
|
||||
slots.push({
|
||||
name: slotName,
|
||||
parent: parentPath
|
||||
});
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return slots;
|
||||
}
|
||||
function combineSlots(...slotArrays) {
|
||||
const slotSet = new Set();
|
||||
const result = [];
|
||||
for (const slots of slotArrays){
|
||||
for (const slot of slots){
|
||||
const key = `${slot.name}:${slot.parent}`;
|
||||
if (!slotSet.has(key)) {
|
||||
slotSet.add(key);
|
||||
result.push(slot);
|
||||
}
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
function processAppRoutes(mappedAppPages, validFileMatcher, baseDir, isSrcDir) {
|
||||
const appRoutes = [];
|
||||
const appRouteHandlers = [];
|
||||
for (const [page, filePath] of Object.entries(mappedAppPages)){
|
||||
if (page === _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY || page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
|
||||
continue;
|
||||
}
|
||||
const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'app', isSrcDir);
|
||||
if (validFileMatcher.isAppRouterRoute(filePath)) {
|
||||
appRouteHandlers.push({
|
||||
route: (0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(page)),
|
||||
filePath: relativeFilePath
|
||||
});
|
||||
} else {
|
||||
appRoutes.push({
|
||||
route: (0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(page)),
|
||||
filePath: relativeFilePath
|
||||
});
|
||||
}
|
||||
}
|
||||
return {
|
||||
appRoutes,
|
||||
appRouteHandlers
|
||||
};
|
||||
}
|
||||
function processLayoutRoutes(mappedAppLayouts, baseDir, isSrcDir) {
|
||||
const layoutRoutes = [];
|
||||
for (const [route, filePath] of Object.entries(mappedAppLayouts)){
|
||||
const relativeFilePath = createRelativeFilePath(baseDir, filePath, 'app', isSrcDir);
|
||||
layoutRoutes.push({
|
||||
route: (0, _ensureleadingslash.ensureLeadingSlash)((0, _apppaths.normalizeAppPath)((0, _normalizepathsep.normalizePathSep)(route)).replace(/\/layout$/, '')),
|
||||
filePath: relativeFilePath
|
||||
});
|
||||
}
|
||||
return layoutRoutes;
|
||||
}
|
||||
function getPageFromPath(pagePath, pageExtensions) {
|
||||
let page = (0, _normalizepathsep.normalizePathSep)(pagePath.replace(new RegExp(`\\.+(${pageExtensions.join('|')})$`), ''));
|
||||
page = page.replace(/\/index$/, '');
|
||||
return page === '' ? '/' : page;
|
||||
}
|
||||
function getPageFilePath({ absolutePagePath, pagesDir, appDir, rootDir }) {
|
||||
if (absolutePagePath.startsWith(_constants.PAGES_DIR_ALIAS) && pagesDir) {
|
||||
return absolutePagePath.replace(_constants.PAGES_DIR_ALIAS, pagesDir);
|
||||
}
|
||||
if (absolutePagePath.startsWith(_constants.APP_DIR_ALIAS) && appDir) {
|
||||
return absolutePagePath.replace(_constants.APP_DIR_ALIAS, appDir);
|
||||
}
|
||||
if (absolutePagePath.startsWith(_constants.ROOT_DIR_ALIAS)) {
|
||||
return absolutePagePath.replace(_constants.ROOT_DIR_ALIAS, rootDir);
|
||||
}
|
||||
return require.resolve(absolutePagePath);
|
||||
}
|
||||
async function createPagesMapping({ isDev, pageExtensions, pagePaths, pagesType, pagesDir, appDir, appDirOnly }) {
|
||||
const isAppRoute = pagesType === 'app';
|
||||
const promises = pagePaths.map(async (pagePath)=>{
|
||||
// Do not process .d.ts files as routes
|
||||
if (pagePath.endsWith('.d.ts') && pageExtensions.includes('ts')) {
|
||||
return;
|
||||
}
|
||||
let pageKey = getPageFromPath(pagePath, pageExtensions);
|
||||
if (isAppRoute) {
|
||||
pageKey = pageKey.replace(/%5F/g, '_');
|
||||
if (pageKey === _constants1.UNDERSCORE_NOT_FOUND_ROUTE) {
|
||||
pageKey = _entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY;
|
||||
}
|
||||
if (pageKey === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE) {
|
||||
pageKey = _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY;
|
||||
}
|
||||
}
|
||||
const normalizedPath = (0, _normalizepathsep.normalizePathSep)((0, _path.join)(pagesType === 'pages' ? _constants.PAGES_DIR_ALIAS : pagesType === 'app' ? _constants.APP_DIR_ALIAS : _constants.ROOT_DIR_ALIAS, pagePath));
|
||||
let route = pagesType === 'app' ? (0, _getmetadataroute.normalizeMetadataRoute)(pageKey) : pageKey;
|
||||
if (pagesType === 'app' && (0, _ismetadataroute.isMetadataRouteFile)(pagePath, pageExtensions, true)) {
|
||||
const filePath = (0, _path.join)(appDir, pagePath);
|
||||
const staticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
|
||||
nextConfig: {},
|
||||
pageFilePath: filePath,
|
||||
isDev,
|
||||
page: pageKey,
|
||||
pageType: pagesType
|
||||
});
|
||||
route = (0, _getmetadataroute.normalizeMetadataPageToRoute)(route, !!(staticInfo.generateImageMetadata || staticInfo.generateSitemaps));
|
||||
}
|
||||
return [
|
||||
route,
|
||||
normalizedPath
|
||||
];
|
||||
});
|
||||
const pages = Object.fromEntries((await Promise.all(promises)).filter((entry)=>entry != null));
|
||||
switch(pagesType){
|
||||
case _pagetypes.PAGE_TYPES.ROOT:
|
||||
{
|
||||
return pages;
|
||||
}
|
||||
case _pagetypes.PAGE_TYPES.APP:
|
||||
{
|
||||
const hasAppPages = Object.keys(pages).length > 0;
|
||||
// Whether to emit App router 500.html entry, which only presents in production and only app router presents
|
||||
const hasAppGlobalError = !isDev && appDirOnly;
|
||||
return {
|
||||
// If there's any app pages existed, add a default /_not-found route as 404.
|
||||
// If there's any custom /_not-found page, it will override the default one.
|
||||
...hasAppPages && {
|
||||
[_entryconstants.UNDERSCORE_NOT_FOUND_ROUTE_ENTRY]: require.resolve('next/dist/client/components/builtin/global-not-found')
|
||||
},
|
||||
...hasAppGlobalError && {
|
||||
[_entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY]: require.resolve('next/dist/client/components/builtin/app-error')
|
||||
},
|
||||
...pages
|
||||
};
|
||||
}
|
||||
case _pagetypes.PAGE_TYPES.PAGES:
|
||||
{
|
||||
if (isDev) {
|
||||
delete pages['/_app'];
|
||||
delete pages['/_error'];
|
||||
delete pages['/_document'];
|
||||
}
|
||||
// In development we always alias these to allow Webpack to fallback to
|
||||
// the correct source file so that HMR can work properly when a file is
|
||||
// added or removed.
|
||||
const root = isDev && pagesDir ? _constants.PAGES_DIR_ALIAS : 'next/dist/pages';
|
||||
// If there are no user pages routes, treat this as app-dir-only mode.
|
||||
// The pages/ folder could be present and the initial appDirOnly is treated as false, but no valid routes are found.
|
||||
if (Object.keys(pages).length === 0 && !appDirOnly) {
|
||||
appDirOnly = true;
|
||||
}
|
||||
return {
|
||||
// Don't add default pages entries if this is an app-router-only build
|
||||
...(isDev || !appDirOnly) && {
|
||||
'/_app': `${root}/_app`,
|
||||
'/_error': `${root}/_error`,
|
||||
'/_document': `${root}/_document`,
|
||||
...pages
|
||||
}
|
||||
};
|
||||
}
|
||||
default:
|
||||
{
|
||||
return {};
|
||||
}
|
||||
}
|
||||
}
|
||||
function getEdgeServerEntry(opts) {
|
||||
var _opts_config_experimental_sri;
|
||||
if (opts.pagesType === 'app' && (0, _isapprouteroute.isAppRouteRoute)(opts.page) && opts.appDirLoader) {
|
||||
const loaderParams = {
|
||||
absolutePagePath: opts.absolutePagePath,
|
||||
page: opts.page,
|
||||
appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
|
||||
preferredRegion: opts.preferredRegion,
|
||||
middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
|
||||
cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {})
|
||||
};
|
||||
return {
|
||||
import: `next-edge-app-route-loader?${(0, _querystring.stringify)(loaderParams)}!`,
|
||||
layer: _constants.WEBPACK_LAYERS.reactServerComponents
|
||||
};
|
||||
}
|
||||
if ((0, _utils.isMiddlewareFile)(opts.page)) {
|
||||
var _opts_middleware;
|
||||
const loaderParams = {
|
||||
absolutePagePath: opts.absolutePagePath,
|
||||
page: opts.page,
|
||||
rootDir: opts.rootDir,
|
||||
matchers: ((_opts_middleware = opts.middleware) == null ? void 0 : _opts_middleware.matchers) ? (0, _nextmiddlewareloader.encodeMatchers)(opts.middleware.matchers) : '',
|
||||
preferredRegion: opts.preferredRegion,
|
||||
middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
|
||||
};
|
||||
return {
|
||||
import: `next-middleware-loader?${(0, _querystring.stringify)(loaderParams)}!`,
|
||||
layer: _constants.WEBPACK_LAYERS.middleware,
|
||||
filename: opts.isDev ? 'middleware.js' : undefined
|
||||
};
|
||||
}
|
||||
if ((0, _isapiroute.isAPIRoute)(opts.page)) {
|
||||
const loaderParams = {
|
||||
absolutePagePath: opts.absolutePagePath,
|
||||
page: opts.page,
|
||||
rootDir: opts.rootDir,
|
||||
preferredRegion: opts.preferredRegion,
|
||||
middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64')
|
||||
};
|
||||
return {
|
||||
import: `next-edge-function-loader?${(0, _querystring.stringify)(loaderParams)}!`,
|
||||
layer: _constants.WEBPACK_LAYERS.apiEdge
|
||||
};
|
||||
}
|
||||
const loaderParams = {
|
||||
absolute500Path: opts.pages['/500'] || '',
|
||||
absoluteAppPath: opts.pages['/_app'],
|
||||
absoluteDocumentPath: opts.pages['/_document'],
|
||||
absoluteErrorPath: opts.pages['/_error'],
|
||||
absolutePagePath: opts.absolutePagePath,
|
||||
dev: opts.isDev,
|
||||
isServerComponent: opts.isServerComponent,
|
||||
page: opts.page,
|
||||
pagesType: opts.pagesType,
|
||||
appDirLoader: Buffer.from(opts.appDirLoader || '').toString('base64'),
|
||||
sriEnabled: !opts.isDev && !!((_opts_config_experimental_sri = opts.config.experimental.sri) == null ? void 0 : _opts_config_experimental_sri.algorithm),
|
||||
cacheHandler: opts.config.cacheHandler,
|
||||
preferredRegion: opts.preferredRegion,
|
||||
middlewareConfig: Buffer.from(JSON.stringify(opts.middlewareConfig || {})).toString('base64'),
|
||||
serverActions: opts.config.experimental.serverActions,
|
||||
cacheHandlers: JSON.stringify(opts.config.cacheHandlers || {})
|
||||
};
|
||||
return {
|
||||
import: `next-edge-ssr-loader?${JSON.stringify(loaderParams)}!`,
|
||||
// The Edge bundle includes the server in its entrypoint, so it has to
|
||||
// be in the SSR layer — we later convert the page request to the RSC layer
|
||||
// via a webpack rule.
|
||||
layer: opts.appDirLoader ? _constants.WEBPACK_LAYERS.serverSideRendering : undefined
|
||||
};
|
||||
}
|
||||
function getInstrumentationEntry(opts) {
|
||||
// the '../' is needed to make sure the file is not chunked
|
||||
const filename = `${opts.isEdgeServer ? 'edge-' : opts.isDev ? '' : '../'}${_constants.INSTRUMENTATION_HOOK_FILENAME}.js`;
|
||||
return {
|
||||
import: opts.absolutePagePath,
|
||||
filename,
|
||||
layer: _constants.WEBPACK_LAYERS.instrument
|
||||
};
|
||||
}
|
||||
function getAppLoader() {
|
||||
return process.env.BUILTIN_APP_LOADER ? `builtin:next-app-loader` : 'next-app-loader';
|
||||
}
|
||||
function getAppEntry(opts) {
|
||||
if (process.env.NEXT_RSPACK && process.env.BUILTIN_APP_LOADER) {
|
||||
;
|
||||
opts.projectRoot = (0, _path.normalize)((0, _path.join)(__dirname, '../../..'));
|
||||
}
|
||||
return {
|
||||
import: `${getAppLoader()}?${(0, _querystring.stringify)(opts)}!`,
|
||||
layer: _constants.WEBPACK_LAYERS.reactServerComponents
|
||||
};
|
||||
}
|
||||
function getClientEntry(opts) {
|
||||
const loaderOptions = {
|
||||
absolutePagePath: opts.absolutePagePath,
|
||||
page: opts.page
|
||||
};
|
||||
const pageLoader = `next-client-pages-loader?${(0, _querystring.stringify)(loaderOptions)}!`;
|
||||
// Make sure next/router is a dependency of _app or else chunk splitting
|
||||
// might cause the router to not be able to load causing hydration
|
||||
// to fail
|
||||
return opts.page === '/_app' ? [
|
||||
pageLoader,
|
||||
require.resolve('../client/router')
|
||||
] : pageLoader;
|
||||
}
|
||||
function runDependingOnPageType(params) {
|
||||
if (params.pageType === _pagetypes.PAGE_TYPES.ROOT && (0, _utils.isInstrumentationHookFile)(params.page)) {
|
||||
params.onServer();
|
||||
params.onEdgeServer();
|
||||
return;
|
||||
}
|
||||
if ((0, _utils.isProxyFile)(params.page)) {
|
||||
params.onServer();
|
||||
return;
|
||||
}
|
||||
if ((0, _utils.isMiddlewareFile)(params.page)) {
|
||||
if (params.pageRuntime === 'nodejs') {
|
||||
params.onServer();
|
||||
return;
|
||||
} else {
|
||||
params.onEdgeServer();
|
||||
return;
|
||||
}
|
||||
}
|
||||
if ((0, _isapiroute.isAPIRoute)(params.page)) {
|
||||
if ((0, _isedgeruntime.isEdgeRuntime)(params.pageRuntime)) {
|
||||
params.onEdgeServer();
|
||||
return;
|
||||
}
|
||||
params.onServer();
|
||||
return;
|
||||
}
|
||||
if (params.page === '/_document') {
|
||||
params.onServer();
|
||||
return;
|
||||
}
|
||||
if (params.page === '/_app' || params.page === '/_error' || params.page === '/404' || params.page === '/500') {
|
||||
params.onClient();
|
||||
params.onServer();
|
||||
return;
|
||||
}
|
||||
if ((0, _isedgeruntime.isEdgeRuntime)(params.pageRuntime)) {
|
||||
params.onClient();
|
||||
params.onEdgeServer();
|
||||
return;
|
||||
}
|
||||
params.onClient();
|
||||
params.onServer();
|
||||
return;
|
||||
}
|
||||
async function createEntrypoints(params) {
|
||||
const { config, pages, pagesDir, isDev, rootDir, rootPaths, appDir, appPaths, pageExtensions } = params;
|
||||
const edgeServer = {};
|
||||
const server = {};
|
||||
const client = {};
|
||||
let middlewareMatchers = undefined;
|
||||
let appPathsPerRoute = {};
|
||||
if (appDir && appPaths) {
|
||||
for(const pathname in appPaths){
|
||||
const normalizedPath = (0, _apppaths.normalizeAppPath)(pathname);
|
||||
const actualPath = appPaths[pathname];
|
||||
if (!appPathsPerRoute[normalizedPath]) {
|
||||
appPathsPerRoute[normalizedPath] = [];
|
||||
}
|
||||
appPathsPerRoute[normalizedPath].push(// TODO-APP: refactor to pass the page path from createPagesMapping instead.
|
||||
getPageFromPath(actualPath, pageExtensions).replace(_constants.APP_DIR_ALIAS, ''));
|
||||
}
|
||||
// TODO: find a better place to do this
|
||||
(0, _normalizecatchallroutes.normalizeCatchAllRoutes)(appPathsPerRoute);
|
||||
// Make sure to sort parallel routes to make the result deterministic.
|
||||
appPathsPerRoute = Object.fromEntries(Object.entries(appPathsPerRoute).map(([k, v])=>[
|
||||
k,
|
||||
v.sort()
|
||||
]));
|
||||
}
|
||||
const getEntryHandler = (mappings, pagesType)=>async (page)=>{
|
||||
const bundleFile = (0, _normalizepagepath.normalizePagePath)(page);
|
||||
const clientBundlePath = _path.posix.join(pagesType, bundleFile);
|
||||
const serverBundlePath = pagesType === _pagetypes.PAGE_TYPES.PAGES ? _path.posix.join('pages', bundleFile) : pagesType === _pagetypes.PAGE_TYPES.APP ? _path.posix.join('app', bundleFile) : bundleFile.slice(1);
|
||||
const absolutePagePath = mappings[page];
|
||||
// Handle paths that have aliases
|
||||
const pageFilePath = getPageFilePath({
|
||||
absolutePagePath,
|
||||
pagesDir,
|
||||
appDir,
|
||||
rootDir
|
||||
});
|
||||
const isInsideAppDir = !!appDir && (absolutePagePath.startsWith(_constants.APP_DIR_ALIAS) || absolutePagePath.startsWith(appDir));
|
||||
const staticInfo = await (0, _getstaticinfoincludinglayouts.getStaticInfoIncludingLayouts)({
|
||||
isInsideAppDir,
|
||||
pageExtensions,
|
||||
pageFilePath,
|
||||
appDir,
|
||||
config,
|
||||
isDev,
|
||||
page
|
||||
});
|
||||
// TODO(timneutkens): remove this
|
||||
const isServerComponent = isInsideAppDir && staticInfo.rsc !== _constants1.RSC_MODULE_TYPES.client;
|
||||
if ((0, _utils.isMiddlewareFile)(page)) {
|
||||
var _staticInfo_middleware;
|
||||
middlewareMatchers = ((_staticInfo_middleware = staticInfo.middleware) == null ? void 0 : _staticInfo_middleware.matchers) ?? [
|
||||
{
|
||||
regexp: '.*',
|
||||
originalSource: '/:path*'
|
||||
}
|
||||
];
|
||||
}
|
||||
const isInstrumentation = (0, _utils.isInstrumentationHookFile)(page) && pagesType === _pagetypes.PAGE_TYPES.ROOT;
|
||||
runDependingOnPageType({
|
||||
page,
|
||||
pageRuntime: staticInfo.runtime,
|
||||
pageType: pagesType,
|
||||
onClient: ()=>{
|
||||
if (isServerComponent || isInsideAppDir) {
|
||||
// We skip the initial entries for server component pages and let the
|
||||
// server compiler inject them instead.
|
||||
} else {
|
||||
client[clientBundlePath] = getClientEntry({
|
||||
absolutePagePath,
|
||||
page
|
||||
});
|
||||
}
|
||||
},
|
||||
onServer: ()=>{
|
||||
if (pagesType === 'app' && appDir) {
|
||||
const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
|
||||
server[serverBundlePath] = getAppEntry({
|
||||
page,
|
||||
name: serverBundlePath,
|
||||
pagePath: absolutePagePath,
|
||||
appDir,
|
||||
appPaths: matchedAppPaths,
|
||||
pageExtensions,
|
||||
basePath: config.basePath,
|
||||
assetPrefix: config.assetPrefix,
|
||||
nextConfigOutput: config.output,
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: (0, _utils1.encodeToBase64)(staticInfo.middleware || {}),
|
||||
isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined
|
||||
});
|
||||
} else if (isInstrumentation) {
|
||||
server[serverBundlePath.replace('src/', '')] = getInstrumentationEntry({
|
||||
absolutePagePath,
|
||||
isEdgeServer: false,
|
||||
isDev: false
|
||||
});
|
||||
} else if ((0, _utils.isMiddlewareFile)(page)) {
|
||||
server[serverBundlePath.replace('src/', '')] = getEdgeServerEntry({
|
||||
...params,
|
||||
rootDir,
|
||||
absolutePagePath: absolutePagePath,
|
||||
bundlePath: clientBundlePath,
|
||||
isDev: false,
|
||||
isServerComponent,
|
||||
page,
|
||||
middleware: staticInfo == null ? void 0 : staticInfo.middleware,
|
||||
pagesType,
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: staticInfo.middleware
|
||||
});
|
||||
} else if ((0, _isapiroute.isAPIRoute)(page)) {
|
||||
server[serverBundlePath] = [
|
||||
(0, _nextrouteloader.getRouteLoaderEntry)({
|
||||
kind: _routekind.RouteKind.PAGES_API,
|
||||
page,
|
||||
absolutePagePath,
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: staticInfo.middleware || {}
|
||||
})
|
||||
];
|
||||
} else if (!(0, _utils.isMiddlewareFile)(page) && !(0, _isinternalcomponent.isInternalComponent)(absolutePagePath) && !(0, _isinternalcomponent.isNonRoutePagesPage)(page)) {
|
||||
server[serverBundlePath] = [
|
||||
(0, _nextrouteloader.getRouteLoaderEntry)({
|
||||
kind: _routekind.RouteKind.PAGES,
|
||||
page,
|
||||
pages,
|
||||
absolutePagePath,
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: staticInfo.middleware ?? {}
|
||||
})
|
||||
];
|
||||
} else {
|
||||
server[serverBundlePath] = [
|
||||
absolutePagePath
|
||||
];
|
||||
}
|
||||
},
|
||||
onEdgeServer: ()=>{
|
||||
let appDirLoader = '';
|
||||
if (isInstrumentation) {
|
||||
edgeServer[serverBundlePath.replace('src/', '')] = getInstrumentationEntry({
|
||||
absolutePagePath,
|
||||
isEdgeServer: true,
|
||||
isDev: false
|
||||
});
|
||||
} else {
|
||||
if (pagesType === 'app') {
|
||||
const matchedAppPaths = appPathsPerRoute[(0, _apppaths.normalizeAppPath)(page)];
|
||||
appDirLoader = getAppEntry({
|
||||
name: serverBundlePath,
|
||||
page,
|
||||
pagePath: absolutePagePath,
|
||||
appDir: appDir,
|
||||
appPaths: matchedAppPaths,
|
||||
pageExtensions,
|
||||
basePath: config.basePath,
|
||||
assetPrefix: config.assetPrefix,
|
||||
nextConfigOutput: config.output,
|
||||
// This isn't used with edge as it needs to be set on the entry module, which will be the `edgeServerEntry` instead.
|
||||
// Still passing it here for consistency.
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: Buffer.from(JSON.stringify(staticInfo.middleware || {})).toString('base64'),
|
||||
isGlobalNotFoundEnabled: config.experimental.globalNotFound ? true : undefined
|
||||
}).import;
|
||||
}
|
||||
edgeServer[serverBundlePath] = getEdgeServerEntry({
|
||||
...params,
|
||||
rootDir,
|
||||
absolutePagePath: absolutePagePath,
|
||||
bundlePath: clientBundlePath,
|
||||
isDev: false,
|
||||
isServerComponent,
|
||||
page,
|
||||
middleware: staticInfo == null ? void 0 : staticInfo.middleware,
|
||||
pagesType,
|
||||
appDirLoader,
|
||||
preferredRegion: staticInfo.preferredRegion,
|
||||
middlewareConfig: staticInfo.middleware
|
||||
});
|
||||
}
|
||||
}
|
||||
});
|
||||
};
|
||||
const promises = [];
|
||||
if (appPaths) {
|
||||
const entryHandler = getEntryHandler(appPaths, _pagetypes.PAGE_TYPES.APP);
|
||||
promises.push(Promise.all(Object.keys(appPaths).map(entryHandler)));
|
||||
}
|
||||
if (rootPaths) {
|
||||
promises.push(Promise.all(Object.keys(rootPaths).map(getEntryHandler(rootPaths, _pagetypes.PAGE_TYPES.ROOT))));
|
||||
}
|
||||
promises.push(Promise.all(Object.keys(pages).map(getEntryHandler(pages, _pagetypes.PAGE_TYPES.PAGES))));
|
||||
await Promise.all(promises);
|
||||
// Optimization: If there's only one instrumentation hook in edge compiler, which means there's no edge server entry.
|
||||
// We remove the edge instrumentation entry from edge compiler as it can be pure server side.
|
||||
if (edgeServer.instrumentation && Object.keys(edgeServer).length === 1) {
|
||||
delete edgeServer.instrumentation;
|
||||
}
|
||||
return {
|
||||
client,
|
||||
server,
|
||||
edgeServer,
|
||||
middlewareMatchers
|
||||
};
|
||||
}
|
||||
function finalizeEntrypoint({ name, compilerType, value, isServerComponent, hasAppDir }) {
|
||||
const entry = typeof value !== 'object' || Array.isArray(value) ? {
|
||||
import: value
|
||||
} : value;
|
||||
const isApi = name.startsWith('pages/api/');
|
||||
const isInstrumentation = (0, _utils.isInstrumentationHookFilename)(name);
|
||||
switch(compilerType){
|
||||
case _constants1.COMPILER_NAMES.server:
|
||||
{
|
||||
const layer = isApi ? _constants.WEBPACK_LAYERS.apiNode : isInstrumentation ? _constants.WEBPACK_LAYERS.instrument : isServerComponent ? _constants.WEBPACK_LAYERS.reactServerComponents : name.startsWith('pages/') ? _constants.WEBPACK_LAYERS.pagesDirNode : undefined;
|
||||
return {
|
||||
publicPath: isApi ? '' : undefined,
|
||||
runtime: isApi ? 'webpack-api-runtime' : 'webpack-runtime',
|
||||
layer,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
case _constants1.COMPILER_NAMES.edgeServer:
|
||||
{
|
||||
return {
|
||||
layer: isApi ? _constants.WEBPACK_LAYERS.apiEdge : (0, _utils.isMiddlewareFilename)(name) || isInstrumentation ? _constants.WEBPACK_LAYERS.middleware : name.startsWith('pages/') ? _constants.WEBPACK_LAYERS.pagesDirEdge : undefined,
|
||||
library: {
|
||||
name: [
|
||||
'_ENTRIES',
|
||||
`middleware_[name]`
|
||||
],
|
||||
type: 'assign'
|
||||
},
|
||||
runtime: _constants1.EDGE_RUNTIME_WEBPACK,
|
||||
asyncChunks: false,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
case _constants1.COMPILER_NAMES.client:
|
||||
{
|
||||
const isAppLayer = hasAppDir && (name === _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP || name === _constants1.APP_CLIENT_INTERNALS || name.startsWith('app/'));
|
||||
if (// Client special cases
|
||||
name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_POLYFILLS && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP && name !== _constants1.CLIENT_STATIC_FILES_RUNTIME_REACT_REFRESH) {
|
||||
if (isAppLayer) {
|
||||
return {
|
||||
dependOn: _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN_APP,
|
||||
layer: _constants.WEBPACK_LAYERS.appPagesBrowser,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
return {
|
||||
dependOn: name.startsWith('pages/') && name !== 'pages/_app' ? 'pages/_app' : _constants1.CLIENT_STATIC_FILES_RUNTIME_MAIN,
|
||||
layer: _constants.WEBPACK_LAYERS.pagesDirBrowser,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
if (isAppLayer) {
|
||||
return {
|
||||
layer: _constants.WEBPACK_LAYERS.appPagesBrowser,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
return {
|
||||
layer: _constants.WEBPACK_LAYERS.pagesDirBrowser,
|
||||
...entry
|
||||
};
|
||||
}
|
||||
default:
|
||||
return compilerType;
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=entries.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/entries.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/entries.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
apps/public-web/node_modules/next/dist/build/generate-build-id.d.ts
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/generate-build-id.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export declare function generateBuildId(generate: () => string | null | Promise<string | null>, fallback: () => string): Promise<string>;
|
||||
31
apps/public-web/node_modules/next/dist/build/generate-build-id.js
generated
vendored
Normal file
31
apps/public-web/node_modules/next/dist/build/generate-build-id.js
generated
vendored
Normal file
@@ -0,0 +1,31 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "generateBuildId", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return generateBuildId;
|
||||
}
|
||||
});
|
||||
async function generateBuildId(generate, fallback) {
|
||||
let buildId = await generate();
|
||||
// If there's no buildId defined we'll fall back
|
||||
if (buildId === null) {
|
||||
// We also create a new buildId if it contains the word `ad` to avoid false
|
||||
// positives with ad blockers
|
||||
while(!buildId || /ad/i.test(buildId)){
|
||||
buildId = fallback();
|
||||
}
|
||||
}
|
||||
if (typeof buildId !== 'string') {
|
||||
throw Object.defineProperty(new Error('generateBuildId did not return a string. https://nextjs.org/docs/messages/generatebuildid-not-a-string'), "__NEXT_ERROR_CODE", {
|
||||
value: "E455",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
return buildId.trim();
|
||||
}
|
||||
|
||||
//# sourceMappingURL=generate-build-id.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/generate-build-id.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/generate-build-id.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/generate-build-id.ts"],"sourcesContent":["export async function generateBuildId(\n generate: () => string | null | Promise<string | null>,\n fallback: () => string\n): Promise<string> {\n let buildId = await generate()\n // If there's no buildId defined we'll fall back\n if (buildId === null) {\n // We also create a new buildId if it contains the word `ad` to avoid false\n // positives with ad blockers\n while (!buildId || /ad/i.test(buildId)) {\n buildId = fallback()\n }\n }\n\n if (typeof buildId !== 'string') {\n throw new Error(\n 'generateBuildId did not return a string. https://nextjs.org/docs/messages/generatebuildid-not-a-string'\n )\n }\n\n return buildId.trim()\n}\n"],"names":["generateBuildId","generate","fallback","buildId","test","Error","trim"],"mappings":";;;;+BAAsBA;;;eAAAA;;;AAAf,eAAeA,gBACpBC,QAAsD,EACtDC,QAAsB;IAEtB,IAAIC,UAAU,MAAMF;IACpB,gDAAgD;IAChD,IAAIE,YAAY,MAAM;QACpB,2EAA2E;QAC3E,6BAA6B;QAC7B,MAAO,CAACA,WAAW,MAAMC,IAAI,CAACD,SAAU;YACtCA,UAAUD;QACZ;IACF;IAEA,IAAI,OAAOC,YAAY,UAAU;QAC/B,MAAM,qBAEL,CAFK,IAAIE,MACR,2GADI,qBAAA;mBAAA;wBAAA;0BAAA;QAEN;IACF;IAEA,OAAOF,QAAQG,IAAI;AACrB","ignoreList":[0]}
|
||||
28
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.d.ts
generated
vendored
Normal file
28
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.d.ts
generated
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { CustomRoutes } from '../lib/load-custom-routes';
|
||||
import type { DynamicManifestRoute } from './utils';
|
||||
import type { RoutesManifest } from './index';
|
||||
export interface GenerateRoutesManifestOptions {
|
||||
pageKeys: {
|
||||
pages: string[];
|
||||
app?: string[];
|
||||
};
|
||||
config: NextConfigComplete;
|
||||
redirects: CustomRoutes['redirects'];
|
||||
headers: CustomRoutes['headers'];
|
||||
rewrites: CustomRoutes['rewrites'];
|
||||
restrictedRedirectPaths: string[];
|
||||
isAppPPREnabled: boolean;
|
||||
appType: 'pages' | 'app' | 'hybrid';
|
||||
}
|
||||
export interface GenerateRoutesManifestResult {
|
||||
routesManifest: RoutesManifest;
|
||||
dynamicRoutes: Array<DynamicManifestRoute>;
|
||||
sourcePages: Map<string, string>;
|
||||
}
|
||||
/**
|
||||
* Generates the routes manifest from the given page keys and configuration.
|
||||
* This function extracts the route manifest generation logic to be reusable
|
||||
* across different build contexts (webpack build, turbopack build, analyze, etc.)
|
||||
*/
|
||||
export declare function generateRoutesManifest(options: GenerateRoutesManifestOptions): GenerateRoutesManifestResult;
|
||||
91
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.js
generated
vendored
Normal file
91
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.js
generated
vendored
Normal file
@@ -0,0 +1,91 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "generateRoutesManifest", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return generateRoutesManifest;
|
||||
}
|
||||
});
|
||||
const _approuterheaders = require("../client/components/app-router-headers");
|
||||
const _constants = require("../lib/constants");
|
||||
const _utils = require("../shared/lib/router/utils");
|
||||
const _buildcustomroute = require("../lib/build-custom-route");
|
||||
const _utils1 = require("./utils");
|
||||
const _sortableroutes = require("../shared/lib/router/utils/sortable-routes");
|
||||
function generateRoutesManifest(options) {
|
||||
const { pageKeys, config, redirects, headers, rewrites, restrictedRedirectPaths, isAppPPREnabled, appType } = options;
|
||||
const sortedRoutes = (0, _sortableroutes.sortPages)([
|
||||
...pageKeys.pages,
|
||||
...pageKeys.app ?? []
|
||||
]);
|
||||
const staticRoutes = [];
|
||||
const dynamicRoutes = [];
|
||||
/**
|
||||
* A map of all the pages to their sourcePage value. This is only used for
|
||||
* routes that have PPR enabled and clientSegmentEnabled is true.
|
||||
*/ const sourcePages = new Map();
|
||||
for (const route of sortedRoutes){
|
||||
if ((0, _utils.isDynamicRoute)(route)) {
|
||||
dynamicRoutes.push((0, _utils1.pageToRoute)(route, // This property is only relevant when PPR is enabled.
|
||||
undefined));
|
||||
} else if (!(0, _utils1.isReservedPage)(route) || // don't consider /api reserved here
|
||||
route.match(/^\/(api(\/|$))/)) {
|
||||
staticRoutes.push((0, _utils1.pageToRoute)(route));
|
||||
}
|
||||
}
|
||||
const routesManifest = {
|
||||
version: 3,
|
||||
pages404: true,
|
||||
appType,
|
||||
caseSensitive: !!config.experimental.caseSensitiveRoutes,
|
||||
basePath: config.basePath,
|
||||
redirects: redirects.map((r)=>(0, _buildcustomroute.buildCustomRoute)('redirect', r, restrictedRedirectPaths)),
|
||||
headers: headers.map((r)=>(0, _buildcustomroute.buildCustomRoute)('header', r)),
|
||||
rewrites: {
|
||||
beforeFiles: rewrites.beforeFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
|
||||
afterFiles: rewrites.afterFiles.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r)),
|
||||
fallback: rewrites.fallback.map((r)=>(0, _buildcustomroute.buildCustomRoute)('rewrite', r))
|
||||
},
|
||||
dynamicRoutes,
|
||||
staticRoutes,
|
||||
dataRoutes: [],
|
||||
i18n: config.i18n || undefined,
|
||||
rsc: {
|
||||
header: _approuterheaders.RSC_HEADER,
|
||||
// This vary header is used as a default. It is technically re-assigned in `base-server`,
|
||||
// and may include an additional Vary option for `Next-URL`.
|
||||
varyHeader: `${_approuterheaders.RSC_HEADER}, ${_approuterheaders.NEXT_ROUTER_STATE_TREE_HEADER}, ${_approuterheaders.NEXT_ROUTER_PREFETCH_HEADER}, ${_approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER}`,
|
||||
prefetchHeader: _approuterheaders.NEXT_ROUTER_PREFETCH_HEADER,
|
||||
didPostponeHeader: _approuterheaders.NEXT_DID_POSTPONE_HEADER,
|
||||
contentTypeHeader: _approuterheaders.RSC_CONTENT_TYPE_HEADER,
|
||||
suffix: _constants.RSC_SUFFIX,
|
||||
prefetchSegmentHeader: _approuterheaders.NEXT_ROUTER_SEGMENT_PREFETCH_HEADER,
|
||||
prefetchSegmentSuffix: _constants.RSC_SEGMENT_SUFFIX,
|
||||
prefetchSegmentDirSuffix: _constants.RSC_SEGMENTS_DIR_SUFFIX,
|
||||
clientParamParsing: config.cacheComponents ?? false,
|
||||
clientParamParsingOrigins: config.experimental.clientParamParsingOrigins,
|
||||
dynamicRSCPrerender: isAppPPREnabled && config.cacheComponents === true
|
||||
},
|
||||
rewriteHeaders: {
|
||||
pathHeader: _approuterheaders.NEXT_REWRITTEN_PATH_HEADER,
|
||||
queryHeader: _approuterheaders.NEXT_REWRITTEN_QUERY_HEADER
|
||||
},
|
||||
skipProxyUrlNormalize: config.skipProxyUrlNormalize,
|
||||
ppr: isAppPPREnabled ? {
|
||||
chain: {
|
||||
headers: {
|
||||
[_constants.NEXT_RESUME_HEADER]: '1'
|
||||
}
|
||||
}
|
||||
} : undefined
|
||||
};
|
||||
return {
|
||||
routesManifest,
|
||||
dynamicRoutes,
|
||||
sourcePages
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=generate-routes-manifest.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/generate-routes-manifest.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
1
apps/public-web/node_modules/next/dist/build/get-babel-config-file.d.ts
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/get-babel-config-file.d.ts
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
export declare function getBabelConfigFile(dir: string): string | undefined;
|
||||
35
apps/public-web/node_modules/next/dist/build/get-babel-config-file.js
generated
vendored
Normal file
35
apps/public-web/node_modules/next/dist/build/get-babel-config-file.js
generated
vendored
Normal file
@@ -0,0 +1,35 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "getBabelConfigFile", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getBabelConfigFile;
|
||||
}
|
||||
});
|
||||
const _path = require("path");
|
||||
const _fs = require("fs");
|
||||
const BABEL_CONFIG_FILES = [
|
||||
'.babelrc',
|
||||
'.babelrc.json',
|
||||
'.babelrc.js',
|
||||
'.babelrc.mjs',
|
||||
'.babelrc.cjs',
|
||||
'babel.config.js',
|
||||
'babel.config.json',
|
||||
'babel.config.mjs',
|
||||
'babel.config.cjs'
|
||||
];
|
||||
function getBabelConfigFile(dir) {
|
||||
for (const filename of BABEL_CONFIG_FILES){
|
||||
const configFilePath = (0, _path.join)(dir, filename);
|
||||
const exists = (0, _fs.existsSync)(configFilePath);
|
||||
if (!exists) {
|
||||
continue;
|
||||
}
|
||||
return configFilePath;
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=get-babel-config-file.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/get-babel-config-file.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/get-babel-config-file.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/get-babel-config-file.ts"],"sourcesContent":["import { join } from 'path'\nimport { existsSync } from 'fs'\n\nconst BABEL_CONFIG_FILES = [\n '.babelrc',\n '.babelrc.json',\n '.babelrc.js',\n '.babelrc.mjs',\n '.babelrc.cjs',\n 'babel.config.js',\n 'babel.config.json',\n 'babel.config.mjs',\n 'babel.config.cjs',\n]\n\nexport function getBabelConfigFile(dir: string): string | undefined {\n for (const filename of BABEL_CONFIG_FILES) {\n const configFilePath = join(dir, filename)\n const exists = existsSync(configFilePath)\n if (!exists) {\n continue\n }\n return configFilePath\n }\n}\n"],"names":["getBabelConfigFile","BABEL_CONFIG_FILES","dir","filename","configFilePath","join","exists","existsSync"],"mappings":";;;;+BAegBA;;;eAAAA;;;sBAfK;oBACM;AAE3B,MAAMC,qBAAqB;IACzB;IACA;IACA;IACA;IACA;IACA;IACA;IACA;IACA;CACD;AAEM,SAASD,mBAAmBE,GAAW;IAC5C,KAAK,MAAMC,YAAYF,mBAAoB;QACzC,MAAMG,iBAAiBC,IAAAA,UAAI,EAACH,KAAKC;QACjC,MAAMG,SAASC,IAAAA,cAAU,EAACH;QAC1B,IAAI,CAACE,QAAQ;YACX;QACF;QACA,OAAOF;IACT;AACF","ignoreList":[0]}
|
||||
16
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.d.ts
generated
vendored
Normal file
16
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.d.ts
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
import type { ReactCompilerOptions } from '../server/config-shared';
|
||||
declare const getBabelLoader: (useSWCLoader: boolean | undefined, babelConfigFile: string | undefined, isServer: boolean, distDir: string, pagesDir: string | undefined, cwd: string, srcDir: string, dev: boolean, isClient: boolean, reactCompilerOptions: boolean | ReactCompilerOptions | undefined, reactCompilerExclude: ((excludePath: string) => boolean) | undefined) => {
|
||||
loader: string;
|
||||
options: import("./babel/loader/types").NextBabelLoaderOptionDefaultPresets;
|
||||
} | undefined;
|
||||
/**
|
||||
* Get a separate babel loader for the react compiler, only used if Babel is not
|
||||
* configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.
|
||||
* Note from react compiler:
|
||||
* > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.
|
||||
*/
|
||||
declare const getReactCompilerLoader: (reactCompilerOptions: boolean | ReactCompilerOptions | undefined, cwd: string, isServer: boolean, reactCompilerExclude: ((excludePath: string) => boolean) | undefined, isDev: boolean) => {
|
||||
loader: string;
|
||||
options: import("./babel/loader/types").NextBabelLoaderOptionStandalone;
|
||||
} | undefined;
|
||||
export { getBabelLoader, getReactCompilerLoader };
|
||||
109
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.js
generated
vendored
Normal file
109
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.js
generated
vendored
Normal file
@@ -0,0 +1,109 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
getBabelLoader: null,
|
||||
getReactCompilerLoader: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
getBabelLoader: function() {
|
||||
return getBabelLoader;
|
||||
},
|
||||
getReactCompilerLoader: function() {
|
||||
return getReactCompilerLoader;
|
||||
}
|
||||
});
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("path"));
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
function getReactCompiler() {
|
||||
try {
|
||||
return require.resolve('babel-plugin-react-compiler');
|
||||
} catch {
|
||||
throw Object.defineProperty(new Error('Failed to load the `babel-plugin-react-compiler`. It is required to use the React Compiler. Please install it.'), "__NEXT_ERROR_CODE", {
|
||||
value: "E78",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
const getReactCompilerPlugins = (maybeOptions, isServer, isDev)=>{
|
||||
if (!maybeOptions || isServer) {
|
||||
return undefined;
|
||||
}
|
||||
const environment = {
|
||||
enableNameAnonymousFunctions: isDev
|
||||
};
|
||||
const options = typeof maybeOptions === 'boolean' ? {} : maybeOptions;
|
||||
const compilerOptions = {
|
||||
...options,
|
||||
environment
|
||||
};
|
||||
return [
|
||||
[
|
||||
getReactCompiler(),
|
||||
compilerOptions
|
||||
]
|
||||
];
|
||||
};
|
||||
const getBabelLoader = (useSWCLoader, babelConfigFile, isServer, distDir, pagesDir, cwd, srcDir, dev, isClient, reactCompilerOptions, reactCompilerExclude)=>{
|
||||
if (!useSWCLoader) {
|
||||
// Make sure these options are kept in sync with
|
||||
// `packages/next/src/build/get-babel-loader-config.ts`
|
||||
const options = {
|
||||
transformMode: 'default',
|
||||
configFile: babelConfigFile,
|
||||
isServer,
|
||||
distDir,
|
||||
pagesDir,
|
||||
cwd,
|
||||
srcDir: _path.default.dirname(srcDir),
|
||||
development: dev,
|
||||
hasReactRefresh: dev && isClient,
|
||||
hasJsxRuntime: true,
|
||||
reactCompilerPlugins: getReactCompilerPlugins(reactCompilerOptions, isServer, dev),
|
||||
reactCompilerExclude
|
||||
};
|
||||
return {
|
||||
loader: require.resolve('./babel/loader/index'),
|
||||
options
|
||||
};
|
||||
}
|
||||
return undefined;
|
||||
};
|
||||
/**
|
||||
* Get a separate babel loader for the react compiler, only used if Babel is not
|
||||
* configured through e.g. .babelrc. If user have babel config, this should be configured in the babel loader itself.
|
||||
* Note from react compiler:
|
||||
* > For best results, compiler must run as the first plugin in your Babel pipeline so it receives input as close to the original source as possible.
|
||||
*/ const getReactCompilerLoader = (reactCompilerOptions, cwd, isServer, reactCompilerExclude, isDev)=>{
|
||||
const reactCompilerPlugins = getReactCompilerPlugins(reactCompilerOptions, isServer, isDev);
|
||||
if (!reactCompilerPlugins) {
|
||||
return undefined;
|
||||
}
|
||||
const babelLoaderOptions = {
|
||||
transformMode: 'standalone',
|
||||
cwd,
|
||||
reactCompilerPlugins,
|
||||
isServer
|
||||
};
|
||||
if (reactCompilerExclude) {
|
||||
babelLoaderOptions.reactCompilerExclude = reactCompilerExclude;
|
||||
}
|
||||
return {
|
||||
loader: require.resolve('./babel/loader/index'),
|
||||
options: babelLoaderOptions
|
||||
};
|
||||
};
|
||||
|
||||
//# sourceMappingURL=get-babel-loader-config.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/get-babel-loader-config.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
12
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.d.ts
generated
vendored
Normal file
12
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.d.ts
generated
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { PageStaticInfo } from './analysis/get-page-static-info';
|
||||
import type { PageExtensions } from './page-extensions-type';
|
||||
export declare function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, pageFilePath, appDir, config: nextConfig, isDev, page, }: {
|
||||
isInsideAppDir: boolean;
|
||||
pageExtensions: PageExtensions;
|
||||
pageFilePath: string;
|
||||
appDir: string | undefined;
|
||||
config: NextConfigComplete;
|
||||
isDev: boolean;
|
||||
page: string;
|
||||
}): Promise<PageStaticInfo>;
|
||||
81
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.js
generated
vendored
Normal file
81
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.js
generated
vendored
Normal file
@@ -0,0 +1,81 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, "getStaticInfoIncludingLayouts", {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return getStaticInfoIncludingLayouts;
|
||||
}
|
||||
});
|
||||
const _path = require("path");
|
||||
const _fs = /*#__PURE__*/ _interop_require_default(require("fs"));
|
||||
const _utils = require("./utils");
|
||||
const _getpagestaticinfo = require("./analysis/get-page-static-info");
|
||||
const _pagetypes = require("../lib/page-types");
|
||||
const _isapppageroute = require("../lib/is-app-page-route");
|
||||
const _entryconstants = require("../shared/lib/entry-constants");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
async function getStaticInfoIncludingLayouts({ isInsideAppDir, pageExtensions, pageFilePath, appDir, config: nextConfig, isDev, page }) {
|
||||
// TODO: sync types for pages: PAGE_TYPES, ROUTER_TYPE, 'app' | 'pages', etc.
|
||||
const pageType = isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES;
|
||||
const pageStaticInfo = await (0, _getpagestaticinfo.getPageStaticInfo)({
|
||||
nextConfig,
|
||||
pageFilePath,
|
||||
isDev,
|
||||
page,
|
||||
pageType
|
||||
});
|
||||
if (pageStaticInfo.type === _pagetypes.PAGE_TYPES.PAGES || !appDir) {
|
||||
return pageStaticInfo;
|
||||
}
|
||||
// Skip inheritance for global-error pages - always use default config
|
||||
if (page === _entryconstants.UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {
|
||||
return pageStaticInfo;
|
||||
}
|
||||
const segments = [
|
||||
pageStaticInfo
|
||||
];
|
||||
// inherit from layout files only if it's a page route and not a builtin page
|
||||
if ((0, _isapppageroute.isAppPageRoute)(page) && !(0, _utils.isAppBuiltinPage)(pageFilePath)) {
|
||||
const layoutFiles = [];
|
||||
const potentialLayoutFiles = pageExtensions.map((ext)=>'layout.' + ext);
|
||||
let dir = (0, _path.dirname)(pageFilePath);
|
||||
// Uses startsWith to not include directories further up.
|
||||
while(dir.startsWith(appDir)){
|
||||
for (const potentialLayoutFile of potentialLayoutFiles){
|
||||
const layoutFile = (0, _path.join)(dir, potentialLayoutFile);
|
||||
if (!_fs.default.existsSync(layoutFile)) {
|
||||
continue;
|
||||
}
|
||||
layoutFiles.push(layoutFile);
|
||||
}
|
||||
// Walk up the directory tree
|
||||
dir = (0, _path.join)(dir, '..');
|
||||
}
|
||||
for (const layoutFile of layoutFiles){
|
||||
const layoutStaticInfo = await (0, _getpagestaticinfo.getAppPageStaticInfo)({
|
||||
nextConfig,
|
||||
pageFilePath: layoutFile,
|
||||
isDev,
|
||||
page,
|
||||
pageType: isInsideAppDir ? _pagetypes.PAGE_TYPES.APP : _pagetypes.PAGE_TYPES.PAGES
|
||||
});
|
||||
segments.unshift(layoutStaticInfo);
|
||||
}
|
||||
}
|
||||
const config = (0, _utils.reduceAppConfig)(segments);
|
||||
return {
|
||||
...pageStaticInfo,
|
||||
config,
|
||||
runtime: config.runtime,
|
||||
preferredRegion: config.preferredRegion,
|
||||
maxDuration: config.maxDuration
|
||||
};
|
||||
}
|
||||
|
||||
//# sourceMappingURL=get-static-info-including-layouts.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/get-static-info-including-layouts.js.map
generated
vendored
Normal file
@@ -0,0 +1 @@
|
||||
{"version":3,"sources":["../../src/build/get-static-info-including-layouts.ts"],"sourcesContent":["import type { NextConfigComplete } from '../server/config-shared'\nimport type { PageStaticInfo } from './analysis/get-page-static-info'\nimport { join, dirname } from 'path'\nimport fs from 'fs'\nimport type { __ApiPreviewProps } from '../server/api-utils'\nimport { reduceAppConfig, isAppBuiltinPage } from './utils'\nimport {\n getAppPageStaticInfo,\n getPageStaticInfo,\n} from './analysis/get-page-static-info'\nimport type { PageExtensions } from './page-extensions-type'\n\nimport { PAGE_TYPES } from '../lib/page-types'\nimport { isAppPageRoute } from '../lib/is-app-page-route'\n\nimport { UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY } from '../shared/lib/entry-constants'\n\nexport async function getStaticInfoIncludingLayouts({\n isInsideAppDir,\n pageExtensions,\n pageFilePath,\n appDir,\n config: nextConfig,\n isDev,\n page,\n}: {\n isInsideAppDir: boolean\n pageExtensions: PageExtensions\n pageFilePath: string\n appDir: string | undefined\n config: NextConfigComplete\n isDev: boolean\n page: string\n}): Promise<PageStaticInfo> {\n // TODO: sync types for pages: PAGE_TYPES, ROUTER_TYPE, 'app' | 'pages', etc.\n const pageType = isInsideAppDir ? PAGE_TYPES.APP : PAGE_TYPES.PAGES\n\n const pageStaticInfo = await getPageStaticInfo({\n nextConfig,\n pageFilePath,\n isDev,\n page,\n pageType,\n })\n\n if (pageStaticInfo.type === PAGE_TYPES.PAGES || !appDir) {\n return pageStaticInfo\n }\n\n // Skip inheritance for global-error pages - always use default config\n if (page === UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY) {\n return pageStaticInfo\n }\n\n const segments = [pageStaticInfo]\n\n // inherit from layout files only if it's a page route and not a builtin page\n if (isAppPageRoute(page) && !isAppBuiltinPage(pageFilePath)) {\n const layoutFiles = []\n const potentialLayoutFiles = pageExtensions.map((ext) => 'layout.' + ext)\n let dir = dirname(pageFilePath)\n\n // Uses startsWith to not include directories further up.\n while (dir.startsWith(appDir)) {\n for (const potentialLayoutFile of potentialLayoutFiles) {\n const layoutFile = join(dir, potentialLayoutFile)\n if (!fs.existsSync(layoutFile)) {\n continue\n }\n layoutFiles.push(layoutFile)\n }\n // Walk up the directory tree\n dir = join(dir, '..')\n }\n\n for (const layoutFile of layoutFiles) {\n const layoutStaticInfo = await getAppPageStaticInfo({\n nextConfig,\n pageFilePath: layoutFile,\n isDev,\n page,\n pageType: isInsideAppDir ? PAGE_TYPES.APP : PAGE_TYPES.PAGES,\n })\n\n segments.unshift(layoutStaticInfo)\n }\n }\n\n const config = reduceAppConfig(segments)\n\n return {\n ...pageStaticInfo,\n config,\n runtime: config.runtime,\n preferredRegion: config.preferredRegion,\n maxDuration: config.maxDuration,\n }\n}\n"],"names":["getStaticInfoIncludingLayouts","isInsideAppDir","pageExtensions","pageFilePath","appDir","config","nextConfig","isDev","page","pageType","PAGE_TYPES","APP","PAGES","pageStaticInfo","getPageStaticInfo","type","UNDERSCORE_GLOBAL_ERROR_ROUTE_ENTRY","segments","isAppPageRoute","isAppBuiltinPage","layoutFiles","potentialLayoutFiles","map","ext","dir","dirname","startsWith","potentialLayoutFile","layoutFile","join","fs","existsSync","push","layoutStaticInfo","getAppPageStaticInfo","unshift","reduceAppConfig","runtime","preferredRegion","maxDuration"],"mappings":";;;;+BAiBsBA;;;eAAAA;;;sBAfQ;2DACf;uBAEmC;mCAI3C;2BAGoB;gCACI;gCAEqB;;;;;;AAE7C,eAAeA,8BAA8B,EAClDC,cAAc,EACdC,cAAc,EACdC,YAAY,EACZC,MAAM,EACNC,QAAQC,UAAU,EAClBC,KAAK,EACLC,IAAI,EASL;IACC,6EAA6E;IAC7E,MAAMC,WAAWR,iBAAiBS,qBAAU,CAACC,GAAG,GAAGD,qBAAU,CAACE,KAAK;IAEnE,MAAMC,iBAAiB,MAAMC,IAAAA,oCAAiB,EAAC;QAC7CR;QACAH;QACAI;QACAC;QACAC;IACF;IAEA,IAAII,eAAeE,IAAI,KAAKL,qBAAU,CAACE,KAAK,IAAI,CAACR,QAAQ;QACvD,OAAOS;IACT;IAEA,sEAAsE;IACtE,IAAIL,SAASQ,mDAAmC,EAAE;QAChD,OAAOH;IACT;IAEA,MAAMI,WAAW;QAACJ;KAAe;IAEjC,6EAA6E;IAC7E,IAAIK,IAAAA,8BAAc,EAACV,SAAS,CAACW,IAAAA,uBAAgB,EAAChB,eAAe;QAC3D,MAAMiB,cAAc,EAAE;QACtB,MAAMC,uBAAuBnB,eAAeoB,GAAG,CAAC,CAACC,MAAQ,YAAYA;QACrE,IAAIC,MAAMC,IAAAA,aAAO,EAACtB;QAElB,yDAAyD;QACzD,MAAOqB,IAAIE,UAAU,CAACtB,QAAS;YAC7B,KAAK,MAAMuB,uBAAuBN,qBAAsB;gBACtD,MAAMO,aAAaC,IAAAA,UAAI,EAACL,KAAKG;gBAC7B,IAAI,CAACG,WAAE,CAACC,UAAU,CAACH,aAAa;oBAC9B;gBACF;gBACAR,YAAYY,IAAI,CAACJ;YACnB;YACA,6BAA6B;YAC7BJ,MAAMK,IAAAA,UAAI,EAACL,KAAK;QAClB;QAEA,KAAK,MAAMI,cAAcR,YAAa;YACpC,MAAMa,mBAAmB,MAAMC,IAAAA,uCAAoB,EAAC;gBAClD5B;gBACAH,cAAcyB;gBACdrB;gBACAC;gBACAC,UAAUR,iBAAiBS,qBAAU,CAACC,GAAG,GAAGD,qBAAU,CAACE,KAAK;YAC9D;YAEAK,SAASkB,OAAO,CAACF;QACnB;IACF;IAEA,MAAM5B,SAAS+B,IAAAA,sBAAe,EAACnB;IAE/B,OAAO;QACL,GAAGJ,cAAc;QACjBR;QACAgC,SAAShC,OAAOgC,OAAO;QACvBC,iBAAiBjC,OAAOiC,eAAe;QACvCC,aAAalC,OAAOkC,WAAW;IACjC;AACF","ignoreList":[0]}
|
||||
8
apps/public-web/node_modules/next/dist/build/handle-entrypoints.d.ts
generated
vendored
Normal file
8
apps/public-web/node_modules/next/dist/build/handle-entrypoints.d.ts
generated
vendored
Normal file
@@ -0,0 +1,8 @@
|
||||
import type { TurbopackManifestLoader } from '../shared/lib/turbopack/manifest-loader';
|
||||
import type { Entrypoints, PageRoute, AppRoute, RawEntrypoints } from './swc/types';
|
||||
export declare function rawEntrypointsToEntrypoints(entrypointsOp: RawEntrypoints): Promise<Entrypoints>;
|
||||
export declare function handleRouteType({ page, route, manifestLoader, }: {
|
||||
page: string;
|
||||
route: PageRoute | AppRoute;
|
||||
manifestLoader: TurbopackManifestLoader;
|
||||
}): Promise<void>;
|
||||
176
apps/public-web/node_modules/next/dist/build/handle-entrypoints.js
generated
vendored
Normal file
176
apps/public-web/node_modules/next/dist/build/handle-entrypoints.js
generated
vendored
Normal file
@@ -0,0 +1,176 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
handleRouteType: null,
|
||||
rawEntrypointsToEntrypoints: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
handleRouteType: function() {
|
||||
return handleRouteType;
|
||||
},
|
||||
rawEntrypointsToEntrypoints: function() {
|
||||
return rawEntrypointsToEntrypoints;
|
||||
}
|
||||
});
|
||||
const _entrykey = require("../shared/lib/turbopack/entry-key");
|
||||
const _log = /*#__PURE__*/ _interop_require_wildcard(require("./output/log"));
|
||||
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 = {
|
||||
__proto__: null
|
||||
};
|
||||
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;
|
||||
}
|
||||
async function rawEntrypointsToEntrypoints(entrypointsOp) {
|
||||
const page = new Map();
|
||||
const app = new Map();
|
||||
for (const [pathname, route] of entrypointsOp.routes){
|
||||
switch(route.type){
|
||||
case 'page':
|
||||
case 'page-api':
|
||||
page.set(pathname, route);
|
||||
break;
|
||||
case 'app-page':
|
||||
{
|
||||
for (const p of route.pages){
|
||||
app.set(p.originalName, {
|
||||
type: 'app-page',
|
||||
...p
|
||||
});
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'app-route':
|
||||
{
|
||||
app.set(route.originalName, route);
|
||||
break;
|
||||
}
|
||||
case 'conflict':
|
||||
_log.info(`skipping ${pathname} (${route.type})`);
|
||||
break;
|
||||
default:
|
||||
route;
|
||||
}
|
||||
}
|
||||
return {
|
||||
global: {
|
||||
app: entrypointsOp.pagesAppEndpoint,
|
||||
document: entrypointsOp.pagesDocumentEndpoint,
|
||||
error: entrypointsOp.pagesErrorEndpoint,
|
||||
instrumentation: entrypointsOp.instrumentation,
|
||||
middleware: entrypointsOp.middleware
|
||||
},
|
||||
page,
|
||||
app
|
||||
};
|
||||
}
|
||||
async function handleRouteType({ page, route, manifestLoader }) {
|
||||
const shouldCreateWebpackStats = process.env.TURBOPACK_STATS != null;
|
||||
switch(route.type){
|
||||
case 'page':
|
||||
{
|
||||
const serverKey = (0, _entrykey.getEntryKey)('pages', 'server', page);
|
||||
await manifestLoader.loadClientBuildManifest(page);
|
||||
await manifestLoader.loadBuildManifest(page);
|
||||
await manifestLoader.loadPagesManifest(page);
|
||||
const middlewareManifestWritten = await manifestLoader.loadMiddlewareManifest(page, 'pages');
|
||||
if (!middlewareManifestWritten) {
|
||||
manifestLoader.deleteMiddlewareManifest(serverKey);
|
||||
}
|
||||
await manifestLoader.loadFontManifest('/_app', 'pages');
|
||||
await manifestLoader.loadFontManifest(page, 'pages');
|
||||
if (shouldCreateWebpackStats) {
|
||||
await manifestLoader.loadWebpackStats(page, 'pages');
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'page-api':
|
||||
{
|
||||
const key = (0, _entrykey.getEntryKey)('pages', 'server', page);
|
||||
await manifestLoader.loadPagesManifest(page);
|
||||
const middlewareManifestWritten = await manifestLoader.loadMiddlewareManifest(page, 'pages');
|
||||
if (!middlewareManifestWritten) {
|
||||
manifestLoader.deleteMiddlewareManifest(key);
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'app-page':
|
||||
{
|
||||
const key = (0, _entrykey.getEntryKey)('app', 'server', page);
|
||||
const middlewareManifestWritten = await manifestLoader.loadMiddlewareManifest(page, 'app');
|
||||
if (!middlewareManifestWritten) {
|
||||
manifestLoader.deleteMiddlewareManifest(key);
|
||||
}
|
||||
manifestLoader.loadBuildManifest(page, 'app');
|
||||
manifestLoader.loadAppPathsManifest(page);
|
||||
manifestLoader.loadActionManifest(page);
|
||||
manifestLoader.loadFontManifest(page, 'app');
|
||||
if (shouldCreateWebpackStats) {
|
||||
manifestLoader.loadWebpackStats(page, 'app');
|
||||
}
|
||||
break;
|
||||
}
|
||||
case 'app-route':
|
||||
{
|
||||
const key = (0, _entrykey.getEntryKey)('app', 'server', page);
|
||||
manifestLoader.loadAppPathsManifest(page);
|
||||
const middlewareManifestWritten = manifestLoader.loadMiddlewareManifest(page, 'app');
|
||||
if (!middlewareManifestWritten) {
|
||||
manifestLoader.deleteMiddlewareManifest(key);
|
||||
}
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
throw Object.defineProperty(new Error(`unknown route type ${route.type} for ${page}`), "__NEXT_ERROR_CODE", {
|
||||
value: "E316",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=handle-entrypoints.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/handle-entrypoints.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/handle-entrypoints.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
19
apps/public-web/node_modules/next/dist/build/handle-externals.d.ts
generated
vendored
Normal file
19
apps/public-web/node_modules/next/dist/build/handle-externals.d.ts
generated
vendored
Normal file
@@ -0,0 +1,19 @@
|
||||
import type { WebpackLayerName } from '../lib/constants';
|
||||
import type { NextConfigComplete } from '../server/config-shared';
|
||||
import type { ResolveOptions } from 'webpack';
|
||||
export declare function isResourceInPackages(resource: string, packageNames?: string[], packageDirMapping?: Map<string, string>): boolean;
|
||||
export declare function resolveExternal(dir: string, esmExternalsConfig: NextConfigComplete['experimental']['esmExternals'], context: string, request: string, isEsmRequested: boolean, getResolve: (options: ResolveOptions) => (resolveContext: string, resolveRequest: string) => Promise<[string | null, boolean]>, isLocalCallback?: (res: string) => any, baseResolveCheck?: boolean, esmResolveOptions?: any, nodeResolveOptions?: any, baseEsmResolveOptions?: any, baseResolveOptions?: any): Promise<{
|
||||
localRes: any;
|
||||
res?: undefined;
|
||||
isEsm?: undefined;
|
||||
} | {
|
||||
res: string | null;
|
||||
isEsm: boolean;
|
||||
localRes?: undefined;
|
||||
}>;
|
||||
export declare function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPackages, dir, }: {
|
||||
config: NextConfigComplete;
|
||||
optOutBundlingPackageRegex: RegExp;
|
||||
transpiledPackages: string[];
|
||||
dir: string;
|
||||
}): (context: string, request: string, dependencyType: string, layer: WebpackLayerName | null, getResolve: (options: any) => (resolveContext: string, resolveRequest: string) => Promise<[string | null, boolean]>) => Promise<any>;
|
||||
290
apps/public-web/node_modules/next/dist/build/handle-externals.js
generated
vendored
Normal file
290
apps/public-web/node_modules/next/dist/build/handle-externals.js
generated
vendored
Normal file
@@ -0,0 +1,290 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
0 && (module.exports = {
|
||||
isResourceInPackages: null,
|
||||
makeExternalHandler: null,
|
||||
resolveExternal: null
|
||||
});
|
||||
function _export(target, all) {
|
||||
for(var name in all)Object.defineProperty(target, name, {
|
||||
enumerable: true,
|
||||
get: all[name]
|
||||
});
|
||||
}
|
||||
_export(exports, {
|
||||
isResourceInPackages: function() {
|
||||
return isResourceInPackages;
|
||||
},
|
||||
makeExternalHandler: function() {
|
||||
return makeExternalHandler;
|
||||
},
|
||||
resolveExternal: function() {
|
||||
return resolveExternal;
|
||||
}
|
||||
});
|
||||
const _requirehook = require("../server/require-hook");
|
||||
const _constants = require("../shared/lib/constants");
|
||||
const _path = /*#__PURE__*/ _interop_require_default(require("../shared/lib/isomorphic/path"));
|
||||
const _webpackconfig = require("./webpack-config");
|
||||
const _utils = require("./utils");
|
||||
const _normalizepathsep = require("../shared/lib/page-path/normalize-path-sep");
|
||||
function _interop_require_default(obj) {
|
||||
return obj && obj.__esModule ? obj : {
|
||||
default: obj
|
||||
};
|
||||
}
|
||||
const reactPackagesRegex = /^(react|react-dom|react-server-dom-webpack)($|\/)/;
|
||||
const pathSeparators = '[/\\\\]';
|
||||
const optionalEsmPart = `((${pathSeparators}esm)?${pathSeparators})`;
|
||||
const externalFileEnd = '(\\.external(\\.js)?)$';
|
||||
const nextDist = `next${pathSeparators}dist`;
|
||||
const externalPattern = new RegExp(`${nextDist}${optionalEsmPart}.*${externalFileEnd}`);
|
||||
const nodeModulesRegex = /node_modules[/\\].*\.[mc]?js$/;
|
||||
function isResourceInPackages(resource, packageNames, packageDirMapping) {
|
||||
if (!packageNames) return false;
|
||||
return packageNames.some((p)=>packageDirMapping && packageDirMapping.has(p) ? resource.startsWith(packageDirMapping.get(p) + _path.default.sep) : resource.includes(_path.default.sep + _path.default.join('node_modules', p.replace(/\//g, _path.default.sep)) + _path.default.sep));
|
||||
}
|
||||
async function resolveExternal(dir, esmExternalsConfig, context, request, isEsmRequested, getResolve, isLocalCallback, baseResolveCheck = true, esmResolveOptions = _webpackconfig.NODE_ESM_RESOLVE_OPTIONS, nodeResolveOptions = _webpackconfig.NODE_RESOLVE_OPTIONS, baseEsmResolveOptions = _webpackconfig.NODE_BASE_ESM_RESOLVE_OPTIONS, baseResolveOptions = _webpackconfig.NODE_BASE_RESOLVE_OPTIONS) {
|
||||
const esmExternals = !!esmExternalsConfig;
|
||||
const looseEsmExternals = esmExternalsConfig === 'loose';
|
||||
let res = null;
|
||||
let isEsm = false;
|
||||
const preferEsmOptions = esmExternals && isEsmRequested ? [
|
||||
true,
|
||||
false
|
||||
] : [
|
||||
false
|
||||
];
|
||||
for (const preferEsm of preferEsmOptions){
|
||||
const resolveOptions = preferEsm ? esmResolveOptions : nodeResolveOptions;
|
||||
const resolve = getResolve(resolveOptions);
|
||||
// Resolve the import with the webpack provided context, this
|
||||
// ensures we're resolving the correct version when multiple
|
||||
// exist.
|
||||
try {
|
||||
;
|
||||
[res, isEsm] = await resolve(context, request);
|
||||
} catch (err) {
|
||||
res = null;
|
||||
}
|
||||
if (!res) {
|
||||
continue;
|
||||
}
|
||||
// ESM externals can only be imported (and not required).
|
||||
// Make an exception in loose mode.
|
||||
if (!isEsmRequested && isEsm && !looseEsmExternals) {
|
||||
continue;
|
||||
}
|
||||
if (isLocalCallback) {
|
||||
return {
|
||||
localRes: isLocalCallback(res)
|
||||
};
|
||||
}
|
||||
// Bundled Node.js code is relocated without its node_modules tree.
|
||||
// This means we need to make sure its request resolves to the same
|
||||
// package that'll be available at runtime. If it's not identical,
|
||||
// we need to bundle the code (even if it _should_ be external).
|
||||
if (baseResolveCheck) {
|
||||
let baseRes;
|
||||
let baseIsEsm;
|
||||
try {
|
||||
const baseResolve = getResolve(isEsm ? baseEsmResolveOptions : baseResolveOptions);
|
||||
[baseRes, baseIsEsm] = await baseResolve(dir, request);
|
||||
} catch (err) {
|
||||
baseRes = null;
|
||||
baseIsEsm = false;
|
||||
}
|
||||
// Same as above: if the package, when required from the root,
|
||||
// would be different from what the real resolution would use, we
|
||||
// cannot externalize it.
|
||||
// if request is pointing to a symlink it could point to the same file,
|
||||
// the resolver will resolve symlinks so this is handled
|
||||
if (baseRes !== res || isEsm !== baseIsEsm) {
|
||||
res = null;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return {
|
||||
res,
|
||||
isEsm
|
||||
};
|
||||
}
|
||||
function makeExternalHandler({ config, optOutBundlingPackageRegex, transpiledPackages, dir }) {
|
||||
var _config_experimental;
|
||||
let resolvedExternalPackageDirs;
|
||||
const looseEsmExternals = ((_config_experimental = config.experimental) == null ? void 0 : _config_experimental.esmExternals) === 'loose';
|
||||
return async function handleExternals(context, request, dependencyType, layer, getResolve) {
|
||||
// We need to externalize internal requests for files intended to
|
||||
// not be bundled.
|
||||
const isLocal = request.startsWith('.') || // Always check for unix-style path, as webpack sometimes
|
||||
// normalizes as posix.
|
||||
_path.default.posix.isAbsolute(request) || // When on Windows, we also want to check for Windows-specific
|
||||
// absolute paths.
|
||||
process.platform === 'win32' && _path.default.win32.isAbsolute(request);
|
||||
// make sure import "next" shows a warning when imported
|
||||
// in pages/components
|
||||
if (request === 'next') {
|
||||
return `commonjs next/dist/lib/import-next-warning`;
|
||||
}
|
||||
const isAppLayer = (0, _utils.isWebpackBundledLayer)(layer);
|
||||
// Relative requires don't need custom resolution, because they
|
||||
// are relative to requests we've already resolved here.
|
||||
// Absolute requires (require('/foo')) are extremely uncommon, but
|
||||
// also have no need for customization as they're already resolved.
|
||||
if (!isLocal) {
|
||||
if (/^next$/.test(request)) {
|
||||
return `commonjs ${request}`;
|
||||
}
|
||||
if (reactPackagesRegex.test(request) && !isAppLayer) {
|
||||
return `commonjs ${request}`;
|
||||
}
|
||||
// Handle Bun builtins as external modules
|
||||
if (request === 'bun' || request.startsWith('bun:')) {
|
||||
return `commonjs ${request}`;
|
||||
}
|
||||
const notExternalModules = /^(?:private-next-pages\/|next\/(?:dist\/pages\/|(?:app|cache|document|link|form|head|image|legacy\/image|constants|dynamic|script|navigation|headers|router|compat\/router|server)$)|string-hash|private-next-rsc-action-validate|private-next-rsc-action-client-wrapper|private-next-rsc-server-reference|private-next-rsc-cache-wrapper|private-next-rsc-track-dynamic-import$)/;
|
||||
if (notExternalModules.test(request)) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
// @swc/helpers should not be external as it would
|
||||
// require hoisting the package which we can't rely on
|
||||
if (request.includes('@swc/helpers')) {
|
||||
return;
|
||||
}
|
||||
// BARREL_OPTIMIZATION_PREFIX is a special marker that tells Next.js to
|
||||
// optimize the import by removing unused exports. This has to be compiled.
|
||||
if (request.startsWith(_constants.BARREL_OPTIMIZATION_PREFIX)) {
|
||||
return;
|
||||
}
|
||||
// When in esm externals mode, and using import, we resolve with
|
||||
// ESM resolving options.
|
||||
// Also disable esm request when appDir is enabled
|
||||
const isEsmRequested = dependencyType === 'esm';
|
||||
// Don't bundle @vercel/og nodejs bundle for nodejs runtime.
|
||||
// TODO-APP: bundle route.js with different layer that externals common node_module deps.
|
||||
// Make sure @vercel/og is loaded as ESM for Node.js runtime
|
||||
if ((0, _utils.shouldUseReactServerCondition)(layer) && request === 'next/dist/compiled/@vercel/og/index.node.js') {
|
||||
return `module ${request}`;
|
||||
}
|
||||
// Specific Next.js imports that should remain external
|
||||
// TODO-APP: Investigate if we can remove this.
|
||||
if (request.startsWith('next/dist/')) {
|
||||
// Non external that needs to be transpiled
|
||||
// Image loader needs to be transpiled
|
||||
if (/^next[\\/]dist[\\/]shared[\\/]lib[\\/]image-loader/.test(request)) {
|
||||
return;
|
||||
}
|
||||
if (/^next[\\/]dist[\\/]compiled[\\/]next-server/.test(request)) {
|
||||
return `commonjs ${request}`;
|
||||
}
|
||||
if (/^next[\\/]dist[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.c?js$/.test(request)) {
|
||||
return `commonjs ${request}`;
|
||||
}
|
||||
if (/^next[\\/]dist[\\/]esm[\\/]shared[\\/](?!lib[\\/]router[\\/]router)/.test(request) || /^next[\\/]dist[\\/]compiled[\\/].*\.mjs$/.test(request)) {
|
||||
return `module ${request}`;
|
||||
}
|
||||
return resolveNextExternal(request);
|
||||
}
|
||||
// TODO-APP: Let's avoid this resolve call as much as possible, and eventually get rid of it.
|
||||
const resolveResult = await resolveExternal(dir, config.experimental.esmExternals, context, request, isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
|
||||
if ('localRes' in resolveResult) {
|
||||
return resolveResult.localRes;
|
||||
}
|
||||
// Forcedly resolve the styled-jsx installed by next.js,
|
||||
// since `resolveExternal` cannot find the styled-jsx dep with pnpm
|
||||
if (request === 'styled-jsx/style') {
|
||||
resolveResult.res = _requirehook.defaultOverrides['styled-jsx/style'];
|
||||
}
|
||||
const { res, isEsm } = resolveResult;
|
||||
// If the request cannot be resolved we need to have
|
||||
// webpack "bundle" it so it surfaces the not found error.
|
||||
if (!res) {
|
||||
return;
|
||||
}
|
||||
const isOptOutBundling = optOutBundlingPackageRegex.test(res);
|
||||
// Apply bundling rules to all app layers.
|
||||
// Since handleExternals only handle the server layers, we don't need to exclude client here
|
||||
if (!isOptOutBundling && isAppLayer) {
|
||||
return;
|
||||
}
|
||||
// ESM externals can only be imported (and not required).
|
||||
// Make an exception in loose mode.
|
||||
if (!isEsmRequested && isEsm && !looseEsmExternals && !isLocal) {
|
||||
throw Object.defineProperty(new Error(`ESM packages (${request}) need to be imported. Use 'import' to reference the package instead. https://nextjs.org/docs/messages/import-esm-externals`), "__NEXT_ERROR_CODE", {
|
||||
value: "E310",
|
||||
enumerable: false,
|
||||
configurable: true
|
||||
});
|
||||
}
|
||||
const externalType = isEsm ? 'module' : 'commonjs';
|
||||
// Default pages have to be transpiled
|
||||
if (// This is the @babel/plugin-transform-runtime "helpers: true" option
|
||||
/node_modules[/\\]@babel[/\\]runtime[/\\]/.test(res)) {
|
||||
return;
|
||||
}
|
||||
// Webpack itself has to be compiled because it doesn't always use module relative paths
|
||||
if (/node_modules[/\\]webpack/.test(res) || /node_modules[/\\]css-loader/.test(res)) {
|
||||
return;
|
||||
}
|
||||
// If a package should be transpiled by Next.js, we skip making it external.
|
||||
// It doesn't matter what the extension is, as we'll transpile it anyway.
|
||||
if (transpiledPackages && !resolvedExternalPackageDirs) {
|
||||
resolvedExternalPackageDirs = new Map();
|
||||
// We need to resolve all the external package dirs initially.
|
||||
for (const pkg of transpiledPackages){
|
||||
const pkgRes = await resolveExternal(dir, config.experimental.esmExternals, context, pkg + '/package.json', isEsmRequested, getResolve, isLocal ? resolveNextExternal : undefined);
|
||||
if (pkgRes.res) {
|
||||
resolvedExternalPackageDirs.set(pkg, _path.default.dirname(pkgRes.res));
|
||||
}
|
||||
}
|
||||
}
|
||||
const resolvedBundlingOptOutRes = resolveBundlingOptOutPackages({
|
||||
resolvedRes: res,
|
||||
config,
|
||||
resolvedExternalPackageDirs,
|
||||
isAppLayer,
|
||||
externalType,
|
||||
isOptOutBundling,
|
||||
request,
|
||||
transpiledPackages
|
||||
});
|
||||
if (resolvedBundlingOptOutRes) {
|
||||
return resolvedBundlingOptOutRes;
|
||||
}
|
||||
// if here, we default to bundling the file
|
||||
return;
|
||||
};
|
||||
}
|
||||
function resolveBundlingOptOutPackages({ resolvedRes, config, resolvedExternalPackageDirs, isAppLayer, externalType, isOptOutBundling, request, transpiledPackages }) {
|
||||
if (nodeModulesRegex.test(resolvedRes)) {
|
||||
const shouldBundlePages = !isAppLayer && config.bundlePagesRouterDependencies && !isOptOutBundling;
|
||||
const shouldBeBundled = shouldBundlePages || isResourceInPackages(resolvedRes, transpiledPackages, resolvedExternalPackageDirs);
|
||||
if (!shouldBeBundled) {
|
||||
return `${externalType} ${request}` // Externalize if not bundled or opted out
|
||||
;
|
||||
}
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @param localRes the full path to the file
|
||||
* @returns the externalized path
|
||||
* @description returns an externalized path if the file is a Next.js file and ends with either `.shared-runtime.js` or `.external.js`
|
||||
* This is used to ensure that files used across the rendering runtime(s) and the user code are one and the same. The logic in this function
|
||||
* will rewrite the require to the correct bundle location depending on the layer at which the file is being used.
|
||||
*/ function resolveNextExternal(localRes) {
|
||||
const isExternal = externalPattern.test(localRes);
|
||||
// if the file ends with .external, we need to make it a commonjs require in all cases
|
||||
// this is used mainly to share the async local storage across the routing, rendering and user layers.
|
||||
if (isExternal) {
|
||||
// it's important we return the path that starts with `next/dist/` here instead of the absolute path
|
||||
// otherwise NFT will get tripped up
|
||||
return `commonjs ${(0, _normalizepathsep.normalizePathSep)(localRes.replace(/.*?next[/\\]dist/, 'next/dist'))}`;
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=handle-externals.js.map
|
||||
1
apps/public-web/node_modules/next/dist/build/handle-externals.js.map
generated
vendored
Normal file
1
apps/public-web/node_modules/next/dist/build/handle-externals.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user