create project
This commit is contained in:
ismailsosic
562
kitabcitab/node_modules/next/dist/build/webpack/plugins/middleware-plugin.js
generated
vendored
Normal file
562
kitabcitab/node_modules/next/dist/build/webpack/plugins/middleware-plugin.js
generated
vendored
Normal file
@@ -0,0 +1,562 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.handleWebpackExternalForEdgeRuntime = handleWebpackExternalForEdgeRuntime;
|
||||
exports.default = void 0;
|
||||
var _routeRegex = require("../../../shared/lib/router/utils/route-regex");
|
||||
var _getModuleBuildInfo = require("../loaders/get-module-build-info");
|
||||
var _utils = require("../../../shared/lib/router/utils");
|
||||
var _webpack = require("next/dist/compiled/webpack/webpack");
|
||||
var _micromatch = require("next/dist/compiled/micromatch");
|
||||
var _constants = require("../../../shared/lib/constants");
|
||||
var _getPageStaticInfo = require("../../analysis/get-page-static-info");
|
||||
var _shared = require("../../../trace/shared");
|
||||
var _events = require("../../../telemetry/events");
|
||||
var _appPaths = require("../../../shared/lib/router/utils/app-paths");
|
||||
class MiddlewarePlugin {
|
||||
constructor({ dev , sriEnabled , hasFontLoaders }){
|
||||
this.dev = dev;
|
||||
this.sriEnabled = sriEnabled;
|
||||
this.hasFontLoaders = hasFontLoaders;
|
||||
}
|
||||
apply(compiler) {
|
||||
compiler.hooks.compilation.tap(NAME, (compilation, params)=>{
|
||||
const { hooks } = params.normalModuleFactory;
|
||||
/**
|
||||
* This is the static code analysis phase.
|
||||
*/ const codeAnalyzer = getCodeAnalyzer({
|
||||
dev: this.dev,
|
||||
compiler,
|
||||
compilation
|
||||
});
|
||||
hooks.parser.for("javascript/auto").tap(NAME, codeAnalyzer);
|
||||
hooks.parser.for("javascript/dynamic").tap(NAME, codeAnalyzer);
|
||||
hooks.parser.for("javascript/esm").tap(NAME, codeAnalyzer);
|
||||
/**
|
||||
* Extract all metadata for the entry points in a Map object.
|
||||
*/ const metadataByEntry = new Map();
|
||||
compilation.hooks.finishModules.tapPromise(NAME, getExtractMetadata({
|
||||
compilation,
|
||||
compiler,
|
||||
dev: this.dev,
|
||||
metadataByEntry
|
||||
}));
|
||||
/**
|
||||
* Emit the middleware manifest.
|
||||
*/ compilation.hooks.processAssets.tap({
|
||||
name: "NextJsMiddlewareManifest",
|
||||
stage: _webpack.webpack.Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
|
||||
}, getCreateAssets({
|
||||
compilation,
|
||||
metadataByEntry,
|
||||
opts: {
|
||||
sriEnabled: this.sriEnabled,
|
||||
hasFontLoaders: this.hasFontLoaders
|
||||
}
|
||||
}));
|
||||
});
|
||||
}
|
||||
}
|
||||
exports.default = MiddlewarePlugin;
|
||||
const NAME = "MiddlewarePlugin";
|
||||
/**
|
||||
* Checks the value of usingIndirectEval and when it is a set of modules it
|
||||
* check if any of the modules is actually being used. If the value is
|
||||
* simply truthy it will return true.
|
||||
*/ function isUsingIndirectEvalAndUsedByExports(args) {
|
||||
const { moduleGraph , runtime , module , usingIndirectEval , wp } = args;
|
||||
if (typeof usingIndirectEval === "boolean") {
|
||||
return usingIndirectEval;
|
||||
}
|
||||
const exportsInfo = moduleGraph.getExportsInfo(module);
|
||||
for (const exportName of usingIndirectEval){
|
||||
if (exportsInfo.getUsed(exportName, runtime) !== wp.UsageState.Unused) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
function getEntryFiles(entryFiles, meta, opts) {
|
||||
const files = [];
|
||||
if (meta.edgeSSR) {
|
||||
if (meta.edgeSSR.isServerComponent) {
|
||||
files.push(`server/${_constants.FLIGHT_MANIFEST}.js`);
|
||||
files.push(`server/${_constants.FLIGHT_SERVER_CSS_MANIFEST}.js`);
|
||||
if (opts.sriEnabled) {
|
||||
files.push(`server/${_constants.SUBRESOURCE_INTEGRITY_MANIFEST}.js`);
|
||||
}
|
||||
files.push(...entryFiles.filter((file)=>file.startsWith("pages/") && !file.endsWith(".hot-update.js")).map((file)=>"server/" + // TODO-APP: seems this should be removed.
|
||||
file.replace(".js", _constants.NEXT_CLIENT_SSR_ENTRY_SUFFIX + ".js")));
|
||||
}
|
||||
files.push(`server/${_constants.MIDDLEWARE_BUILD_MANIFEST}.js`, `server/${_constants.MIDDLEWARE_REACT_LOADABLE_MANIFEST}.js`);
|
||||
if (opts.hasFontLoaders) {
|
||||
files.push(`server/${_constants.FONT_LOADER_MANIFEST}.js`);
|
||||
}
|
||||
}
|
||||
files.push(...entryFiles.filter((file)=>!file.endsWith(".hot-update.js")).map((file)=>"server/" + file));
|
||||
return files;
|
||||
}
|
||||
function getCreateAssets(params) {
|
||||
const { compilation , metadataByEntry , opts } = params;
|
||||
return (assets)=>{
|
||||
const middlewareManifest = {
|
||||
sortedMiddleware: [],
|
||||
middleware: {},
|
||||
functions: {},
|
||||
version: 2
|
||||
};
|
||||
for (const entrypoint of compilation.entrypoints.values()){
|
||||
var ref, ref1, ref2, ref3, ref4;
|
||||
if (!entrypoint.name) {
|
||||
continue;
|
||||
}
|
||||
// There should always be metadata for the entrypoint.
|
||||
const metadata = metadataByEntry.get(entrypoint.name);
|
||||
const page = (metadata == null ? void 0 : (ref = metadata.edgeMiddleware) == null ? void 0 : ref.page) || (metadata == null ? void 0 : (ref1 = metadata.edgeSSR) == null ? void 0 : ref1.page) || (metadata == null ? void 0 : (ref2 = metadata.edgeApiFunction) == null ? void 0 : ref2.page);
|
||||
if (!page) {
|
||||
continue;
|
||||
}
|
||||
const { namedRegex } = (0, _routeRegex).getNamedMiddlewareRegex(((ref3 = metadata.edgeSSR) == null ? void 0 : ref3.isAppDir) ? (0, _appPaths).normalizeAppPath(page) : page, {
|
||||
catchAll: !metadata.edgeSSR && !metadata.edgeApiFunction
|
||||
});
|
||||
const matchers = (metadata == null ? void 0 : (ref4 = metadata.edgeMiddleware) == null ? void 0 : ref4.matchers) ?? [
|
||||
{
|
||||
regexp: namedRegex
|
||||
},
|
||||
];
|
||||
const edgeFunctionDefinition = {
|
||||
env: Array.from(metadata.env),
|
||||
files: getEntryFiles(entrypoint.getFiles(), metadata, opts),
|
||||
name: entrypoint.name,
|
||||
page: page,
|
||||
matchers,
|
||||
wasm: Array.from(metadata.wasmBindings, ([name, filePath])=>({
|
||||
name,
|
||||
filePath
|
||||
})),
|
||||
assets: Array.from(metadata.assetBindings, ([name, filePath])=>({
|
||||
name,
|
||||
filePath
|
||||
})),
|
||||
...metadata.regions && {
|
||||
regions: metadata.regions
|
||||
}
|
||||
};
|
||||
if (metadata.edgeApiFunction || metadata.edgeSSR) {
|
||||
middlewareManifest.functions[page] = edgeFunctionDefinition;
|
||||
} else {
|
||||
middlewareManifest.middleware[page] = edgeFunctionDefinition;
|
||||
}
|
||||
}
|
||||
middlewareManifest.sortedMiddleware = (0, _utils).getSortedRoutes(Object.keys(middlewareManifest.middleware));
|
||||
assets[_constants.MIDDLEWARE_MANIFEST] = new _webpack.sources.RawSource(JSON.stringify(middlewareManifest, null, 2));
|
||||
};
|
||||
}
|
||||
function buildWebpackError({ message , loc , compilation , entryModule , parser }) {
|
||||
const error = new compilation.compiler.webpack.WebpackError(message);
|
||||
error.name = NAME;
|
||||
const module = entryModule ?? (parser == null ? void 0 : parser.state.current);
|
||||
if (module) {
|
||||
error.module = module;
|
||||
}
|
||||
error.loc = loc;
|
||||
return error;
|
||||
}
|
||||
function isInMiddlewareLayer(parser) {
|
||||
var ref;
|
||||
return ((ref = parser.state.module) == null ? void 0 : ref.layer) === "middleware";
|
||||
}
|
||||
function isProcessEnvMemberExpression(memberExpression) {
|
||||
var ref, ref5, ref6;
|
||||
return ((ref = memberExpression.object) == null ? void 0 : ref.type) === "Identifier" && memberExpression.object.name === "process" && (((ref5 = memberExpression.property) == null ? void 0 : ref5.type) === "Literal" && memberExpression.property.value === "env" || ((ref6 = memberExpression.property) == null ? void 0 : ref6.type) === "Identifier" && memberExpression.property.name === "env");
|
||||
}
|
||||
function isNodeJsModule(moduleName) {
|
||||
return require("module").builtinModules.includes(moduleName);
|
||||
}
|
||||
function isDynamicCodeEvaluationAllowed(fileName, edgeFunctionConfig, rootDir) {
|
||||
const name = fileName.replace(rootDir ?? "", "");
|
||||
return (0, _micromatch).isMatch(name, (edgeFunctionConfig == null ? void 0 : edgeFunctionConfig.unstable_allowDynamicGlobs) ?? []);
|
||||
}
|
||||
function buildUnsupportedApiError({ apiName , loc , ...rest }) {
|
||||
return buildWebpackError({
|
||||
message: `A Node.js API is used (${apiName} at line: ${loc.start.line}) which is not supported in the Edge Runtime.
|
||||
Learn more: https://nextjs.org/docs/api-reference/edge-runtime`,
|
||||
loc,
|
||||
...rest
|
||||
});
|
||||
}
|
||||
function registerUnsupportedApiHooks(parser, compilation) {
|
||||
for (const expression of _constants.EDGE_UNSUPPORTED_NODE_APIS){
|
||||
const warnForUnsupportedApi = (node)=>{
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return;
|
||||
}
|
||||
compilation.warnings.push(buildUnsupportedApiError({
|
||||
compilation,
|
||||
parser,
|
||||
apiName: expression,
|
||||
...node
|
||||
}));
|
||||
return true;
|
||||
};
|
||||
parser.hooks.call.for(expression).tap(NAME, warnForUnsupportedApi);
|
||||
parser.hooks.expression.for(expression).tap(NAME, warnForUnsupportedApi);
|
||||
parser.hooks.callMemberChain.for(expression).tap(NAME, warnForUnsupportedApi);
|
||||
parser.hooks.expressionMemberChain.for(expression).tap(NAME, warnForUnsupportedApi);
|
||||
}
|
||||
const warnForUnsupportedProcessApi = (node, [callee])=>{
|
||||
if (!isInMiddlewareLayer(parser) || callee === "env") {
|
||||
return;
|
||||
}
|
||||
compilation.warnings.push(buildUnsupportedApiError({
|
||||
compilation,
|
||||
parser,
|
||||
apiName: `process.${callee}`,
|
||||
...node
|
||||
}));
|
||||
return true;
|
||||
};
|
||||
parser.hooks.callMemberChain.for("process").tap(NAME, warnForUnsupportedProcessApi);
|
||||
parser.hooks.expressionMemberChain.for("process").tap(NAME, warnForUnsupportedProcessApi);
|
||||
}
|
||||
function getCodeAnalyzer(params) {
|
||||
return (parser)=>{
|
||||
const { dev , compiler: { webpack: wp } , compilation , } = params;
|
||||
const { hooks } = parser;
|
||||
/**
|
||||
* For an expression this will check the graph to ensure it is being used
|
||||
* by exports. Then it will store in the module buildInfo a boolean to
|
||||
* express that it contains dynamic code and, if it is available, the
|
||||
* module path that is using it.
|
||||
*/ const handleExpression = ()=>{
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return;
|
||||
}
|
||||
wp.optimize.InnerGraph.onUsage(parser.state, (used = true)=>{
|
||||
const buildInfo = (0, _getModuleBuildInfo).getModuleBuildInfo(parser.state.module);
|
||||
if (buildInfo.usingIndirectEval === true || used === false) {
|
||||
return;
|
||||
}
|
||||
if (!buildInfo.usingIndirectEval || used === true) {
|
||||
buildInfo.usingIndirectEval = used;
|
||||
return;
|
||||
}
|
||||
buildInfo.usingIndirectEval = new Set([
|
||||
...Array.from(buildInfo.usingIndirectEval),
|
||||
...Array.from(used),
|
||||
]);
|
||||
});
|
||||
};
|
||||
/**
|
||||
* This expression handler allows to wrap a dynamic code expression with a
|
||||
* function call where we can warn about dynamic code not being allowed
|
||||
* but actually execute the expression.
|
||||
*/ const handleWrapExpression = (expr)=>{
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return;
|
||||
}
|
||||
const { ConstDependency } = wp.dependencies;
|
||||
const dep1 = new ConstDependency("__next_eval__(function() { return ", expr.range[0]);
|
||||
dep1.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep1);
|
||||
const dep2 = new ConstDependency("})", expr.range[1]);
|
||||
dep2.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep2);
|
||||
handleExpression();
|
||||
return true;
|
||||
};
|
||||
/**
|
||||
* This expression handler allows to wrap a WebAssembly.compile invocation with a
|
||||
* function call where we can warn about WASM code generation not being allowed
|
||||
* but actually execute the expression.
|
||||
*/ const handleWrapWasmCompileExpression = (expr)=>{
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return;
|
||||
}
|
||||
const { ConstDependency } = wp.dependencies;
|
||||
const dep1 = new ConstDependency("__next_webassembly_compile__(function() { return ", expr.range[0]);
|
||||
dep1.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep1);
|
||||
const dep2 = new ConstDependency("})", expr.range[1]);
|
||||
dep2.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep2);
|
||||
handleExpression();
|
||||
};
|
||||
/**
|
||||
* This expression handler allows to wrap a WebAssembly.instatiate invocation with a
|
||||
* function call where we can warn about WASM code generation not being allowed
|
||||
* but actually execute the expression.
|
||||
*
|
||||
* Note that we don't update `usingIndirectEval`, i.e. we don't abort a production build
|
||||
* since we can't determine statically if the first parameter is a module (legit use) or
|
||||
* a buffer (dynamic code generation).
|
||||
*/ const handleWrapWasmInstantiateExpression = (expr)=>{
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return;
|
||||
}
|
||||
if (dev) {
|
||||
const { ConstDependency } = wp.dependencies;
|
||||
const dep1 = new ConstDependency("__next_webassembly_instantiate__(function() { return ", expr.range[0]);
|
||||
dep1.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep1);
|
||||
const dep2 = new ConstDependency("})", expr.range[1]);
|
||||
dep2.loc = expr.loc;
|
||||
parser.state.module.addPresentationalDependency(dep2);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Declares an environment variable that is being used in this module
|
||||
* through this static analysis.
|
||||
*/ const addUsedEnvVar = (envVarName)=>{
|
||||
const buildInfo = (0, _getModuleBuildInfo).getModuleBuildInfo(parser.state.module);
|
||||
if (buildInfo.nextUsedEnvVars === undefined) {
|
||||
buildInfo.nextUsedEnvVars = new Set();
|
||||
}
|
||||
buildInfo.nextUsedEnvVars.add(envVarName);
|
||||
};
|
||||
/**
|
||||
* A handler for calls to `process.env` where we identify the name of the
|
||||
* ENV variable being assigned and store it in the module info.
|
||||
*/ const handleCallMemberChain = (_, members)=>{
|
||||
if (members.length >= 2 && members[0] === "env") {
|
||||
addUsedEnvVar(members[1]);
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Handler to store original source location of static and dynamic imports into module's buildInfo.
|
||||
*/ const handleImport = (node)=>{
|
||||
var ref;
|
||||
if (isInMiddlewareLayer(parser) && ((ref = node.source) == null ? void 0 : ref.value) && (node == null ? void 0 : node.loc)) {
|
||||
var ref7;
|
||||
const { module , source } = parser.state;
|
||||
const buildInfo = (0, _getModuleBuildInfo).getModuleBuildInfo(module);
|
||||
if (!buildInfo.importLocByPath) {
|
||||
buildInfo.importLocByPath = new Map();
|
||||
}
|
||||
const importedModule = (ref7 = node.source.value) == null ? void 0 : ref7.toString();
|
||||
buildInfo.importLocByPath.set(importedModule, {
|
||||
sourcePosition: {
|
||||
...node.loc.start,
|
||||
source: module.identifier()
|
||||
},
|
||||
sourceContent: source.toString()
|
||||
});
|
||||
if (!dev && isNodeJsModule(importedModule)) {
|
||||
compilation.warnings.push(buildWebpackError({
|
||||
message: `A Node.js module is loaded ('${importedModule}' at line ${node.loc.start.line}) which is not supported in the Edge Runtime.
|
||||
Learn More: https://nextjs.org/docs/messages/node-module-in-edge-runtime`,
|
||||
compilation,
|
||||
parser,
|
||||
...node
|
||||
}));
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* A noop handler to skip analyzing some cases.
|
||||
* Order matters: for it to work, it must be registered first
|
||||
*/ const skip = ()=>isInMiddlewareLayer(parser) ? true : undefined;
|
||||
for (const prefix of [
|
||||
"",
|
||||
"global."
|
||||
]){
|
||||
hooks.expression.for(`${prefix}Function.prototype`).tap(NAME, skip);
|
||||
hooks.expression.for(`${prefix}Function.bind`).tap(NAME, skip);
|
||||
hooks.call.for(`${prefix}eval`).tap(NAME, handleWrapExpression);
|
||||
hooks.call.for(`${prefix}Function`).tap(NAME, handleWrapExpression);
|
||||
hooks.new.for(`${prefix}Function`).tap(NAME, handleWrapExpression);
|
||||
hooks.call.for(`${prefix}WebAssembly.compile`).tap(NAME, handleWrapWasmCompileExpression);
|
||||
hooks.call.for(`${prefix}WebAssembly.instantiate`).tap(NAME, handleWrapWasmInstantiateExpression);
|
||||
}
|
||||
hooks.callMemberChain.for("process").tap(NAME, handleCallMemberChain);
|
||||
hooks.expressionMemberChain.for("process").tap(NAME, handleCallMemberChain);
|
||||
hooks.importCall.tap(NAME, handleImport);
|
||||
hooks.import.tap(NAME, handleImport);
|
||||
/**
|
||||
* Support static analyzing environment variables through
|
||||
* destructuring `process.env` or `process["env"]`:
|
||||
*
|
||||
* const { MY_ENV, "MY-ENV": myEnv } = process.env
|
||||
* ^^^^^^ ^^^^^^
|
||||
*/ hooks.declarator.tap(NAME, (declarator)=>{
|
||||
var ref, ref8;
|
||||
if (((ref = declarator.init) == null ? void 0 : ref.type) === "MemberExpression" && isProcessEnvMemberExpression(declarator.init) && ((ref8 = declarator.id) == null ? void 0 : ref8.type) === "ObjectPattern") {
|
||||
for (const property of declarator.id.properties){
|
||||
if (property.type === "RestElement") continue;
|
||||
if (property.key.type === "Literal" && typeof property.key.value === "string") {
|
||||
addUsedEnvVar(property.key.value);
|
||||
} else if (property.key.type === "Identifier") {
|
||||
addUsedEnvVar(property.key.name);
|
||||
}
|
||||
}
|
||||
if (!isInMiddlewareLayer(parser)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
});
|
||||
if (!dev) {
|
||||
// do not issue compilation warning on dev: invoking code will provide details
|
||||
registerUnsupportedApiHooks(parser, compilation);
|
||||
}
|
||||
};
|
||||
}
|
||||
async function findEntryEdgeFunctionConfig(entryDependency, resolver) {
|
||||
var ref;
|
||||
if (entryDependency == null ? void 0 : (ref = entryDependency.request) == null ? void 0 : ref.startsWith("next-")) {
|
||||
const absolutePagePath = new URL(entryDependency.request, "http://example.org").searchParams.get("absolutePagePath") ?? "";
|
||||
const pageFilePath = await new Promise((resolve)=>resolver.resolve({}, "/", absolutePagePath, {}, (err, path)=>resolve(err || path)));
|
||||
if (typeof pageFilePath === "string") {
|
||||
return {
|
||||
file: pageFilePath,
|
||||
config: (await (0, _getPageStaticInfo).getPageStaticInfo({
|
||||
nextConfig: {},
|
||||
pageFilePath,
|
||||
isDev: false
|
||||
})).middleware
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
function getExtractMetadata(params) {
|
||||
const { dev , compilation , metadataByEntry , compiler } = params;
|
||||
const { webpack: wp } = compiler;
|
||||
return async ()=>{
|
||||
metadataByEntry.clear();
|
||||
const resolver = compilation.resolverFactory.get("normal");
|
||||
const telemetry = _shared.traceGlobals.get("telemetry");
|
||||
for (const [entryName, entry] of compilation.entries){
|
||||
var ref;
|
||||
if (entry.options.runtime !== _constants.EDGE_RUNTIME_WEBPACK) {
|
||||
continue;
|
||||
}
|
||||
const entryDependency = (ref = entry.dependencies) == null ? void 0 : ref[0];
|
||||
const edgeFunctionConfig = await findEntryEdgeFunctionConfig(entryDependency, resolver);
|
||||
const { rootDir } = (0, _getModuleBuildInfo).getModuleBuildInfo(compilation.moduleGraph.getResolvedModule(entryDependency));
|
||||
const { moduleGraph } = compilation;
|
||||
const modules = new Set();
|
||||
const addEntriesFromDependency = (dependency)=>{
|
||||
const module = moduleGraph.getModule(dependency);
|
||||
if (module) {
|
||||
modules.add(module);
|
||||
}
|
||||
};
|
||||
entry.dependencies.forEach(addEntriesFromDependency);
|
||||
entry.includeDependencies.forEach(addEntriesFromDependency);
|
||||
const entryMetadata = {
|
||||
env: new Set(),
|
||||
wasmBindings: new Map(),
|
||||
assetBindings: new Map()
|
||||
};
|
||||
let ogImageGenerationCount = 0;
|
||||
for (const module1 of modules){
|
||||
var ref9;
|
||||
const buildInfo = (0, _getModuleBuildInfo).getModuleBuildInfo(module1);
|
||||
/**
|
||||
* Check if it uses the image generation feature.
|
||||
*/ if (!dev) {
|
||||
const resource = module1.resource;
|
||||
const hasOGImageGeneration = resource && /[\\/]node_modules[\\/]@vercel[\\/]og[\\/]dist[\\/]index.js$/.test(resource);
|
||||
if (hasOGImageGeneration) {
|
||||
ogImageGenerationCount++;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* When building for production checks if the module is using `eval`
|
||||
* and in such case produces a compilation error. The module has to
|
||||
* be in use.
|
||||
*/ if (!dev && buildInfo.usingIndirectEval && isUsingIndirectEvalAndUsedByExports({
|
||||
module: module1,
|
||||
moduleGraph,
|
||||
runtime: wp.util.runtime.getEntryRuntime(compilation, entryName),
|
||||
usingIndirectEval: buildInfo.usingIndirectEval,
|
||||
wp
|
||||
})) {
|
||||
var ref10;
|
||||
const id = module1.identifier();
|
||||
if (/node_modules[\\/]regenerator-runtime[\\/]runtime\.js/.test(id)) {
|
||||
continue;
|
||||
}
|
||||
if (edgeFunctionConfig == null ? void 0 : (ref10 = edgeFunctionConfig.config) == null ? void 0 : ref10.unstable_allowDynamicGlobs) {
|
||||
telemetry.record({
|
||||
eventName: "NEXT_EDGE_ALLOW_DYNAMIC_USED",
|
||||
payload: {
|
||||
...edgeFunctionConfig,
|
||||
file: edgeFunctionConfig.file.replace(rootDir ?? "", ""),
|
||||
fileWithDynamicCode: module1.userRequest.replace(rootDir ?? "", "")
|
||||
}
|
||||
});
|
||||
}
|
||||
if (!isDynamicCodeEvaluationAllowed(module1.userRequest, edgeFunctionConfig == null ? void 0 : edgeFunctionConfig.config, rootDir)) {
|
||||
compilation.errors.push(buildWebpackError({
|
||||
message: `Dynamic Code Evaluation (e. g. 'eval', 'new Function', 'WebAssembly.compile') not allowed in Edge Runtime ${typeof buildInfo.usingIndirectEval !== "boolean" ? `\nUsed by ${Array.from(buildInfo.usingIndirectEval).join(", ")}` : ""}\nLearn More: https://nextjs.org/docs/messages/edge-dynamic-code-evaluation`,
|
||||
entryModule: module1,
|
||||
compilation
|
||||
}));
|
||||
}
|
||||
}
|
||||
if (edgeFunctionConfig == null ? void 0 : (ref9 = edgeFunctionConfig.config) == null ? void 0 : ref9.regions) {
|
||||
entryMetadata.regions = edgeFunctionConfig.config.regions;
|
||||
}
|
||||
/**
|
||||
* The entry module has to be either a page or a middleware and hold
|
||||
* the corresponding metadata.
|
||||
*/ if (buildInfo == null ? void 0 : buildInfo.nextEdgeSSR) {
|
||||
entryMetadata.edgeSSR = buildInfo.nextEdgeSSR;
|
||||
} else if (buildInfo == null ? void 0 : buildInfo.nextEdgeMiddleware) {
|
||||
entryMetadata.edgeMiddleware = buildInfo.nextEdgeMiddleware;
|
||||
} else if (buildInfo == null ? void 0 : buildInfo.nextEdgeApiFunction) {
|
||||
entryMetadata.edgeApiFunction = buildInfo.nextEdgeApiFunction;
|
||||
}
|
||||
/**
|
||||
* If there are env vars found in the module, append them to the set
|
||||
* of env vars for the entry.
|
||||
*/ if ((buildInfo == null ? void 0 : buildInfo.nextUsedEnvVars) !== undefined) {
|
||||
for (const envName of buildInfo.nextUsedEnvVars){
|
||||
entryMetadata.env.add(envName);
|
||||
}
|
||||
}
|
||||
/**
|
||||
* If the module is a WASM module we read the binding information and
|
||||
* append it to the entry wasm bindings.
|
||||
*/ if (buildInfo == null ? void 0 : buildInfo.nextWasmMiddlewareBinding) {
|
||||
entryMetadata.wasmBindings.set(buildInfo.nextWasmMiddlewareBinding.name, buildInfo.nextWasmMiddlewareBinding.filePath);
|
||||
}
|
||||
if (buildInfo == null ? void 0 : buildInfo.nextAssetMiddlewareBinding) {
|
||||
entryMetadata.assetBindings.set(buildInfo.nextAssetMiddlewareBinding.name, buildInfo.nextAssetMiddlewareBinding.filePath);
|
||||
}
|
||||
/**
|
||||
* Append to the list of modules to process outgoingConnections from
|
||||
* the module that is being processed.
|
||||
*/ for (const conn of moduleGraph.getOutgoingConnections(module1)){
|
||||
if (conn.module) {
|
||||
modules.add(conn.module);
|
||||
}
|
||||
}
|
||||
}
|
||||
telemetry.record({
|
||||
eventName: _events.EVENT_BUILD_FEATURE_USAGE,
|
||||
payload: {
|
||||
featureName: "vercelImageGeneration",
|
||||
invocationCount: ogImageGenerationCount
|
||||
}
|
||||
});
|
||||
metadataByEntry.set(entryName, entryMetadata);
|
||||
}
|
||||
};
|
||||
}
|
||||
async function handleWebpackExternalForEdgeRuntime({ request , context , contextInfo , getResolve }) {
|
||||
if (contextInfo.issuerLayer === "middleware" && isNodeJsModule(request)) {
|
||||
// allows user to provide and use their polyfills, as we do with buffer.
|
||||
try {
|
||||
await getResolve()(context, request);
|
||||
} catch {
|
||||
return `root globalThis.__import_unsupported('${request}')`;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//# sourceMappingURL=middleware-plugin.js.map
|
||||
Reference in New Issue
Block a user