vibebusiness 1.2.73 → 1.2.77

package/.next/standalone/node_modules/webpack/lib/config/normalization.js

@@ -0,0 +1,681 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const util = require("util");
+
+/** @typedef {import("../../declarations/WebpackOptions").CacheOptionsNormalized} CacheOptions */
+/** @typedef {import("../../declarations/WebpackOptions").EntryDescriptionNormalized} EntryDescriptionNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStatic} EntryStatic */
+/** @typedef {import("../../declarations/WebpackOptions").EntryStaticNormalized} EntryStaticNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").Externals} Externals */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryName} LibraryName */
+/** @typedef {import("../../declarations/WebpackOptions").LibraryOptions} LibraryOptions */
+/** @typedef {import("../../declarations/WebpackOptions").ModuleOptionsNormalized} ModuleOptionsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationNormalized} OptimizationNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunk} OptimizationRuntimeChunk */
+/** @typedef {import("../../declarations/WebpackOptions").OptimizationRuntimeChunkNormalized} OptimizationRuntimeChunkNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").OutputNormalized} OutputNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").PluginsNormalized} PluginsNormalized */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptions} WebpackOptions */
+/** @typedef {import("../../declarations/WebpackOptions").WebpackOptionsNormalized} WebpackOptionsNormalized */
+/** @typedef {import("../WebpackError")} WebpackError */
+
+/**
+ * @typedef {object} WebpackOptionsInterception
+ * @property {WebpackOptionsNormalized["devtool"]=} devtool
+ */
+
+const handledDeprecatedNoEmitOnErrors = util.deprecate(
+	/**
+	 * @param {boolean} noEmitOnErrors no emit on errors
+	 * @param {boolean | undefined} emitOnErrors emit on errors
+	 * @returns {boolean} emit on errors
+	 */
+	(noEmitOnErrors, emitOnErrors) => {
+		if (emitOnErrors !== undefined && !noEmitOnErrors === !emitOnErrors) {
+			throw new Error(
+				"Conflicting use of 'optimization.noEmitOnErrors' and 'optimization.emitOnErrors'. Remove deprecated 'optimization.noEmitOnErrors' from config."
+			);
+		}
+		return !noEmitOnErrors;
+	},
+	"optimization.noEmitOnErrors is deprecated in favor of optimization.emitOnErrors",
+	"DEP_WEBPACK_CONFIGURATION_OPTIMIZATION_NO_EMIT_ON_ERRORS"
+);
+
+/**
+ * @template T
+ * @template R
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @returns {R} result value
+ */
+const nestedConfig = (value, fn) =>
+	value === undefined ? fn(/** @type {T} */ ({})) : fn(value);
+
+/**
+ * @template T
+ * @param {T | undefined} value value or not
+ * @returns {T} result value
+ */
+const cloneObject = (value) => /** @type {T} */ ({ ...value });
+/**
+ * @template T
+ * @template R
+ * @param {T | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @returns {R | undefined} result value
+ */
+const optionalNestedConfig = (value, fn) =>
+	value === undefined ? undefined : fn(value);
+
+/**
+ * @template T
+ * @template R
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
+ */
+const nestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : fn([]));
+
+/**
+ * @template T
+ * @template R
+ * @param {T[] | undefined} value array or not
+ * @param {(value: T[]) => R[]} fn nested handler
+ * @returns {R[] | undefined} cloned value
+ */
+const optionalNestedArray = (value, fn) =>
+	Array.isArray(value) ? fn(value) : undefined;
+
+/**
+ * @template T
+ * @template R
+ * @param {Record<string, T> | undefined} value value or not
+ * @param {(value: T) => R} fn nested handler
+ * @param {Record<string, (value: T) => R>=} customKeys custom nested handler for some keys
+ * @returns {Record<string, R>} result value
+ */
+const keyedNestedConfig = (value, fn, customKeys) => {
+	/* eslint-disable no-sequences */
+	const result =
+		value === undefined
+			? {}
+			: Object.keys(value).reduce(
+					(obj, key) => (
+						(obj[key] = (
+							customKeys && key in customKeys ? customKeys[key] : fn
+						)(value[key])),
+						obj
+					),
+					/** @type {Record<string, R>} */ ({})
+				);
+	/* eslint-enable no-sequences */
+	if (customKeys) {
+		for (const key of Object.keys(customKeys)) {
+			if (!(key in result)) {
+				result[key] = customKeys[key](/** @type {T} */ ({}));
+			}
+		}
+	}
+	return result;
+};
+
+/**
+ * @param {WebpackOptions} config input config
+ * @returns {WebpackOptionsNormalized} normalized options
+ */
+const getNormalizedWebpackOptions = (config) => ({
+	amd: config.amd,
+	bail: config.bail,
+	cache:
+		/** @type {NonNullable<CacheOptions>} */
+		(
+			optionalNestedConfig(config.cache, (cache) => {
+				if (cache === false) return false;
+				if (cache === true) {
+					return {
+						type: "memory",
+						maxGenerations: undefined
+					};
+				}
+				switch (cache.type) {
+					case "filesystem":
+						return {
+							type: "filesystem",
+							allowCollectingMemory: cache.allowCollectingMemory,
+							maxMemoryGenerations: cache.maxMemoryGenerations,
+							maxAge: cache.maxAge,
+							profile: cache.profile,
+							buildDependencies: cloneObject(cache.buildDependencies),
+							cacheDirectory: cache.cacheDirectory,
+							cacheLocation: cache.cacheLocation,
+							hashAlgorithm: cache.hashAlgorithm,
+							compression: cache.compression,
+							idleTimeout: cache.idleTimeout,
+							idleTimeoutForInitialStore: cache.idleTimeoutForInitialStore,
+							idleTimeoutAfterLargeChanges: cache.idleTimeoutAfterLargeChanges,
+							name: cache.name,
+							store: cache.store,
+							version: cache.version,
+							readonly: cache.readonly
+						};
+					case undefined:
+					case "memory":
+						return {
+							type: "memory",
+							maxGenerations: cache.maxGenerations
+						};
+					default:
+						// @ts-expect-error Property 'type' does not exist on type 'never'. ts(2339)
+						throw new Error(`Not implemented cache.type ${cache.type}`);
+				}
+			})
+		),
+	context: config.context,
+	dependencies: config.dependencies,
+	devServer: optionalNestedConfig(config.devServer, (devServer) => {
+		if (devServer === false) return false;
+		return { ...devServer };
+	}),
+	devtool: config.devtool,
+	dotenv: config.dotenv,
+	entry:
+		config.entry === undefined
+			? { main: {} }
+			: typeof config.entry === "function"
+				? (
+						(fn) => () =>
+							Promise.resolve().then(fn).then(getNormalizedEntryStatic)
+					)(config.entry)
+				: getNormalizedEntryStatic(config.entry),
+	experiments: nestedConfig(config.experiments, (experiments) => ({
+		...experiments,
+		buildHttp: optionalNestedConfig(experiments.buildHttp, (options) =>
+			Array.isArray(options) ? { allowedUris: options } : options
+		),
+		lazyCompilation: optionalNestedConfig(
+			experiments.lazyCompilation,
+			(options) => (options === true ? {} : options)
+		)
+	})),
+	externals: /** @type {NonNullable<Externals>} */ (config.externals),
+	externalsPresets: cloneObject(config.externalsPresets),
+	externalsType: config.externalsType,
+	ignoreWarnings: config.ignoreWarnings
+		? config.ignoreWarnings.map((ignore) => {
+				if (typeof ignore === "function") return ignore;
+				const i = ignore instanceof RegExp ? { message: ignore } : ignore;
+				return (warning, { requestShortener }) => {
+					if (!i.message && !i.module && !i.file) return false;
+					if (i.message && !i.message.test(warning.message)) {
+						return false;
+					}
+					if (
+						i.module &&
+						(!(/** @type {WebpackError} */ (warning).module) ||
+							!i.module.test(
+								/** @type {WebpackError} */
+								(warning).module.readableIdentifier(requestShortener)
+							))
+					) {
+						return false;
+					}
+					if (
+						i.file &&
+						(!(/** @type {WebpackError} */ (warning).file) ||
+							!i.file.test(/** @type {WebpackError} */ (warning).file))
+					) {
+						return false;
+					}
+					return true;
+				};
+			})
+		: undefined,
+	infrastructureLogging: cloneObject(config.infrastructureLogging),
+	loader: cloneObject(config.loader),
+	mode: config.mode,
+	module:
+		/** @type {ModuleOptionsNormalized} */
+		(
+			nestedConfig(config.module, (module) => ({
+				noParse: module.noParse,
+				unsafeCache: module.unsafeCache,
+				parser: keyedNestedConfig(module.parser, cloneObject, {
+					javascript: (parserOptions) => ({
+						// TODO webpack 6 remove from `ModuleOptions`, keep only `*ByModuleType`
+						unknownContextRequest: module.unknownContextRequest,
+						unknownContextRegExp: module.unknownContextRegExp,
+						unknownContextRecursive: module.unknownContextRecursive,
+						unknownContextCritical: module.unknownContextCritical,
+						exprContextRequest: module.exprContextRequest,
+						exprContextRegExp: module.exprContextRegExp,
+						exprContextRecursive: module.exprContextRecursive,
+						exprContextCritical: module.exprContextCritical,
+						wrappedContextRegExp: module.wrappedContextRegExp,
+						wrappedContextRecursive: module.wrappedContextRecursive,
+						wrappedContextCritical: module.wrappedContextCritical,
+						strictExportPresence: module.strictExportPresence,
+						strictThisContextOnImports: module.strictThisContextOnImports,
+						...parserOptions
+					})
+				}),
+				generator: cloneObject(module.generator),
+				defaultRules: optionalNestedArray(module.defaultRules, (r) => [...r]),
+				rules: nestedArray(module.rules, (r) => [...r])
+			}))
+		),
+	name: config.name,
+	node: nestedConfig(
+		config.node,
+		(node) =>
+			node && {
+				...node
+			}
+	),
+	optimization: nestedConfig(config.optimization, (optimization) => ({
+		...optimization,
+		runtimeChunk: getNormalizedOptimizationRuntimeChunk(
+			optimization.runtimeChunk
+		),
+		splitChunks: nestedConfig(
+			optimization.splitChunks,
+			(splitChunks) =>
+				splitChunks && {
+					...splitChunks,
+					defaultSizeTypes: splitChunks.defaultSizeTypes
+						? [...splitChunks.defaultSizeTypes]
+						: ["..."],
+					cacheGroups: cloneObject(splitChunks.cacheGroups)
+				}
+		),
+		minimizer:
+			optimization.minimizer !== undefined
+				? /** @type {OptimizationNormalized["minimizer"]} */ (
+						nestedArray(optimization.minimizer, (p) => p.filter(Boolean))
+					)
+				: optimization.minimizer,
+		emitOnErrors:
+			optimization.noEmitOnErrors !== undefined
+				? handledDeprecatedNoEmitOnErrors(
+						optimization.noEmitOnErrors,
+						optimization.emitOnErrors
+					)
+				: optimization.emitOnErrors
+	})),
+	output: nestedConfig(config.output, (output) => {
+		const { library } = output;
+		const libraryAsName = /** @type {LibraryName} */ (library);
+		const libraryBase =
+			typeof library === "object" &&
+			library &&
+			!Array.isArray(library) &&
+			"type" in library
+				? library
+				: libraryAsName || output.libraryTarget
+					? /** @type {LibraryOptions} */ ({
+							name: libraryAsName
+						})
+					: undefined;
+		/** @type {OutputNormalized} */
+		const result = {
+			assetModuleFilename: output.assetModuleFilename,
+			asyncChunks: output.asyncChunks,
+			charset: output.charset,
+			chunkFilename: output.chunkFilename,
+			chunkFormat: output.chunkFormat,
+			chunkLoading: output.chunkLoading,
+			chunkLoadingGlobal: output.chunkLoadingGlobal,
+			chunkLoadTimeout: output.chunkLoadTimeout,
+			cssFilename: output.cssFilename,
+			cssChunkFilename: output.cssChunkFilename,
+			clean: output.clean,
+			compareBeforeEmit: output.compareBeforeEmit,
+			crossOriginLoading: output.crossOriginLoading,
+			devtoolFallbackModuleFilenameTemplate:
+				output.devtoolFallbackModuleFilenameTemplate,
+			devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
+			devtoolNamespace: output.devtoolNamespace,
+			environment: cloneObject(output.environment),
+			enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
+				? [...output.enabledChunkLoadingTypes]
+				: ["..."],
+			enabledLibraryTypes: output.enabledLibraryTypes
+				? [...output.enabledLibraryTypes]
+				: ["..."],
+			enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
+				? [...output.enabledWasmLoadingTypes]
+				: ["..."],
+			filename: output.filename,
+			globalObject: output.globalObject,
+			hashDigest: output.hashDigest,
+			hashDigestLength: output.hashDigestLength,
+			hashFunction: output.hashFunction,
+			hashSalt: output.hashSalt,
+			hotUpdateChunkFilename: output.hotUpdateChunkFilename,
+			hotUpdateGlobal: output.hotUpdateGlobal,
+			hotUpdateMainFilename: output.hotUpdateMainFilename,
+			ignoreBrowserWarnings: output.ignoreBrowserWarnings,
+			iife: output.iife,
+			importFunctionName: output.importFunctionName,
+			importMetaName: output.importMetaName,
+			scriptType: output.scriptType,
+			// TODO webpack6 remove `libraryTarget`/`auxiliaryComment`/`amdContainer`/etc in favor of the `library` option
+			library: libraryBase && {
+				type:
+					output.libraryTarget !== undefined
+						? output.libraryTarget
+						: libraryBase.type,
+				auxiliaryComment:
+					output.auxiliaryComment !== undefined
+						? output.auxiliaryComment
+						: libraryBase.auxiliaryComment,
+				amdContainer:
+					output.amdContainer !== undefined
+						? output.amdContainer
+						: libraryBase.amdContainer,
+				export:
+					output.libraryExport !== undefined
+						? output.libraryExport
+						: libraryBase.export,
+				name: libraryBase.name,
+				umdNamedDefine:
+					output.umdNamedDefine !== undefined
+						? output.umdNamedDefine
+						: libraryBase.umdNamedDefine
+			},
+			module: output.module,
+			path: output.path,
+			pathinfo: output.pathinfo,
+			publicPath: output.publicPath,
+			sourceMapFilename: output.sourceMapFilename,
+			sourcePrefix: output.sourcePrefix,
+			strictModuleErrorHandling: output.strictModuleErrorHandling,
+			strictModuleExceptionHandling: output.strictModuleExceptionHandling,
+			trustedTypes: optionalNestedConfig(
+				output.trustedTypes,
+				(trustedTypes) => {
+					if (trustedTypes === true) return {};
+					if (typeof trustedTypes === "string") {
+						return { policyName: trustedTypes };
+					}
+					return { ...trustedTypes };
+				}
+			),
+			uniqueName: output.uniqueName,
+			wasmLoading: output.wasmLoading,
+			webassemblyModuleFilename: output.webassemblyModuleFilename,
+			workerPublicPath: output.workerPublicPath,
+			workerChunkLoading: output.workerChunkLoading,
+			workerWasmLoading: output.workerWasmLoading
+		};
+		return result;
+	}),
+	parallelism: config.parallelism,
+	performance: optionalNestedConfig(config.performance, (performance) => {
+		if (performance === false) return false;
+		return {
+			...performance
+		};
+	}),
+	plugins: /** @type {PluginsNormalized} */ (
+		nestedArray(config.plugins, (p) => p.filter(Boolean))
+	),
+	profile: config.profile,
+	recordsInputPath:
+		config.recordsInputPath !== undefined
+			? config.recordsInputPath
+			: config.recordsPath,
+	recordsOutputPath:
+		config.recordsOutputPath !== undefined
+			? config.recordsOutputPath
+			: config.recordsPath,
+	resolve: nestedConfig(config.resolve, (resolve) => ({
+		...resolve,
+		byDependency: keyedNestedConfig(resolve.byDependency, cloneObject)
+	})),
+	resolveLoader: cloneObject(config.resolveLoader),
+	snapshot: nestedConfig(config.snapshot, (snapshot) => ({
+		resolveBuildDependencies: optionalNestedConfig(
+			snapshot.resolveBuildDependencies,
+			(resolveBuildDependencies) => ({
+				timestamp: resolveBuildDependencies.timestamp,
+				hash: resolveBuildDependencies.hash
+			})
+		),
+		buildDependencies: optionalNestedConfig(
+			snapshot.buildDependencies,
+			(buildDependencies) => ({
+				timestamp: buildDependencies.timestamp,
+				hash: buildDependencies.hash
+			})
+		),
+		resolve: optionalNestedConfig(snapshot.resolve, (resolve) => ({
+			timestamp: resolve.timestamp,
+			hash: resolve.hash
+		})),
+		module: optionalNestedConfig(snapshot.module, (module) => ({
+			timestamp: module.timestamp,
+			hash: module.hash
+		})),
+		contextModule: optionalNestedConfig(
+			snapshot.contextModule,
+			(contextModule) => ({
+				timestamp: contextModule.timestamp,
+				hash: contextModule.hash
+			})
+		),
+		immutablePaths: optionalNestedArray(snapshot.immutablePaths, (p) => [...p]),
+		managedPaths: optionalNestedArray(snapshot.managedPaths, (p) => [...p]),
+		unmanagedPaths: optionalNestedArray(snapshot.unmanagedPaths, (p) => [...p])
+	})),
+	stats: nestedConfig(config.stats, (stats) => {
+		if (stats === false) {
+			return {
+				preset: "none"
+			};
+		}
+		if (stats === true) {
+			return {
+				preset: "normal"
+			};
+		}
+		if (typeof stats === "string") {
+			return {
+				preset: stats
+			};
+		}
+		return {
+			...stats
+		};
+	}),
+	target: config.target,
+	watch: config.watch,
+	watchOptions: cloneObject(config.watchOptions)
+});
+
+/**
+ * @param {EntryStatic} entry static entry options
+ * @returns {EntryStaticNormalized} normalized static entry options
+ */
+const getNormalizedEntryStatic = (entry) => {
+	if (typeof entry === "string") {
+		return {
+			main: {
+				import: [entry]
+			}
+		};
+	}
+	if (Array.isArray(entry)) {
+		return {
+			main: {
+				import: entry
+			}
+		};
+	}
+	/** @type {EntryStaticNormalized} */
+	const result = {};
+	for (const key of Object.keys(entry)) {
+		const value = entry[key];
+		if (typeof value === "string") {
+			result[key] = {
+				import: [value]
+			};
+		} else if (Array.isArray(value)) {
+			result[key] = {
+				import: value
+			};
+		} else {
+			result[key] = {
+				import:
+					/** @type {EntryDescriptionNormalized["import"]} */
+					(
+						value.import &&
+							(Array.isArray(value.import) ? value.import : [value.import])
+					),
+				filename: value.filename,
+				layer: value.layer,
+				runtime: value.runtime,
+				baseUri: value.baseUri,
+				publicPath: value.publicPath,
+				chunkLoading: value.chunkLoading,
+				asyncChunks: value.asyncChunks,
+				wasmLoading: value.wasmLoading,
+				dependOn:
+					/** @type {EntryDescriptionNormalized["dependOn"]} */
+					(
+						value.dependOn &&
+							(Array.isArray(value.dependOn)
+								? value.dependOn
+								: [value.dependOn])
+					),
+				library: value.library
+			};
+		}
+	}
+	return result;
+};
+
+/**
+ * @param {OptimizationRuntimeChunk=} runtimeChunk runtimeChunk option
+ * @returns {OptimizationRuntimeChunkNormalized=} normalized runtimeChunk option
+ */
+const getNormalizedOptimizationRuntimeChunk = (runtimeChunk) => {
+	if (runtimeChunk === undefined) return;
+	if (runtimeChunk === false) return false;
+	if (runtimeChunk === "single") {
+		return {
+			name: () => "runtime"
+		};
+	}
+	if (runtimeChunk === true || runtimeChunk === "multiple") {
+		return {
+			name: (entrypoint) => `runtime~${entrypoint.name}`
+		};
+	}
+	const { name } = runtimeChunk;
+	return {
+		name:
+			typeof name === "function"
+				? /** @type {Exclude<OptimizationRuntimeChunkNormalized, false>["name"]} */
+					(name)
+				: () => /** @type {string} */ (name)
+	};
+};
+
+/**
+ * @param {WebpackOptionsNormalized} options options to be intercepted
+ * @returns {{ options: WebpackOptionsNormalized, interception?: WebpackOptionsInterception }} options and interception
+ */
+const applyWebpackOptionsInterception = (options) => {
+	// Return origin options when backCompat is disabled
+	if (options.experiments.futureDefaults) {
+		return {
+			options
+		};
+	}
+
+	// TODO webpack6 - remove compatibility logic and move `devtools` fully into `devtool` with multi-type support
+	let _devtool = options.devtool;
+	/** @type {WebpackOptionsNormalized["devtool"]} */
+	let cached;
+
+	const devtoolBackCompat = () => {
+		if (Array.isArray(_devtool)) {
+			if (cached) return cached;
+			// Prefer `all`, then `javascript`, then `css`
+			const match = ["all", "javascript", "css"]
+				.map((type) =>
+					/** @type {Extract<WebpackOptionsNormalized["devtool"], EXPECTED_ANY[]>} */ (
+						_devtool
+					).find((item) => item.type === type)
+				)
+				.find(Boolean);
+
+			// If `devtool: []` is specified, return `false` here
+			return (cached = match ? match.use : false);
+		}
+		return _devtool;
+	};
+
+	/** @type {ProxyHandler<WebpackOptionsNormalized>} */
+	const handler = Object.create(null);
+	handler.get = (target, prop, receiver) => {
+		if (prop === "devtool") {
+			return devtoolBackCompat();
+		}
+		return Reflect.get(target, prop, receiver);
+	};
+	handler.set = (target, prop, value, receiver) => {
+		if (prop === "devtool") {
+			_devtool = value;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.set(target, prop, value, receiver);
+	};
+	handler.deleteProperty = (target, prop) => {
+		if (prop === "devtool") {
+			_devtool = undefined;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.deleteProperty(target, prop);
+	};
+	handler.defineProperty = (target, prop, descriptor) => {
+		if (prop === "devtool") {
+			_devtool = descriptor.value;
+			cached = undefined;
+			return true;
+		}
+		return Reflect.defineProperty(target, prop, descriptor);
+	};
+	handler.getOwnPropertyDescriptor = (target, prop) => {
+		if (prop === "devtool") {
+			return {
+				configurable: true,
+				enumerable: true,
+				value: devtoolBackCompat(),
+				writable: true
+			};
+		}
+		return Reflect.getOwnPropertyDescriptor(target, prop);
+	};
+
+	return {
+		options: new Proxy(options, handler),
+		interception: {
+			get devtool() {
+				return _devtool;
+			}
+		}
+	};
+};
+
+module.exports.applyWebpackOptionsInterception =
+	applyWebpackOptionsInterception;
+module.exports.getNormalizedWebpackOptions = getNormalizedWebpackOptions;