vibebusiness 1.2.72 → 1.2.75

package/.next/standalone/node_modules/enhanced-resolve/lib/TsconfigPathsPlugin.js

@@ -0,0 +1,560 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Natsu @xiaoxiaojx
+*/
+
+"use strict";
+
+const { aliasResolveHandler } = require("./AliasUtils");
+const { modulesResolveHandler } = require("./ModulesUtils");
+const { readJson } = require("./util/fs");
+const {
+	PathType: _PathType,
+	cachedDirname: dirname,
+	cachedJoin: join,
+	isSubPath,
+	normalize,
+} = require("./util/path");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./AliasUtils").AliasOption} AliasOption */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveContext} ResolveContext */
+/** @typedef {import("./Resolver").FileSystem} FileSystem */
+/** @typedef {import("./Resolver").TsconfigPathsData} TsconfigPathsData */
+/** @typedef {import("./Resolver").TsconfigPathsMap} TsconfigPathsMap */
+/** @typedef {import("./ResolverFactory").TsconfigOptions} TsconfigOptions */
+
+/**
+ * @typedef {object} TsconfigCompilerOptions
+ * @property {string=} baseUrl Base URL for resolving paths
+ * @property {{ [key: string]: string[] }=} paths TypeScript paths mapping
+ */
+
+/**
+ * @typedef {object} TsconfigReference
+ * @property {string} path Path to the referenced project
+ */
+
+/**
+ * @typedef {object} Tsconfig
+ * @property {TsconfigCompilerOptions=} compilerOptions Compiler options
+ * @property {string | string[]=} extends Extended configuration paths
+ * @property {TsconfigReference[]=} references Project references
+ */
+
+const DEFAULT_CONFIG_FILE = "tsconfig.json";
+
+/**
+ * @param {string} pattern Path pattern
+ * @returns {number} Length of the prefix
+ */
+function getPrefixLength(pattern) {
+	const prefixLength = pattern.indexOf("*");
+	if (prefixLength === -1) {
+		return pattern.length;
+	}
+	return pattern.slice(0, Math.max(0, prefixLength)).length;
+}
+
+/**
+ * Sort path patterns.
+ * If a module name can be matched with multiple patterns then pattern with the longest prefix will be picked.
+ * @param {string[]} arr Array of path patterns
+ * @returns {string[]} Array of path patterns sorted by longest prefix
+ */
+function sortByLongestPrefix(arr) {
+	return [...arr].sort((a, b) => getPrefixLength(b) - getPrefixLength(a));
+}
+
+/**
+ * Merge two tsconfig objects
+ * @param {Tsconfig | null} base base config
+ * @param {Tsconfig | null} config config to merge
+ * @returns {Tsconfig} merged config
+ */
+function mergeTsconfigs(base, config) {
+	base = base || {};
+	config = config || {};
+
+	return {
+		...base,
+		...config,
+		compilerOptions: {
+			.../** @type {TsconfigCompilerOptions} */ (base.compilerOptions),
+			.../** @type {TsconfigCompilerOptions} */ (config.compilerOptions),
+		},
+	};
+}
+
+/**
+ * Substitute ${configDir} template variable in path
+ * @param {string} pathValue the path value
+ * @param {string} configDir the config directory
+ * @returns {string} the path with substituted template
+ */
+function substituteConfigDir(pathValue, configDir) {
+	return pathValue.replace(/\$\{configDir\}/g, configDir);
+}
+
+/**
+ * Convert tsconfig paths to resolver options
+ * @param {string} configDir Config file directory
+ * @param {{ [key: string]: string[] }} paths TypeScript paths mapping
+ * @param {string=} baseUrl Base URL for resolving paths (relative to configDir)
+ * @returns {TsconfigPathsData} the resolver options
+ */
+function tsconfigPathsToResolveOptions(configDir, paths, baseUrl) {
+	// Calculate absolute base URL
+	const absoluteBaseUrl = !baseUrl ? configDir : join(configDir, baseUrl);
+
+	/** @type {string[]} */
+	const sortedKeys = sortByLongestPrefix(Object.keys(paths));
+	/** @type {AliasOption[]} */
+	const alias = [];
+	/** @type {string[]} */
+	const modules = [];
+
+	for (const pattern of sortedKeys) {
+		const mappings = paths[pattern];
+		// Substitute ${configDir} in path mappings
+		const absolutePaths = mappings.map((mapping) => {
+			const substituted = substituteConfigDir(mapping, configDir);
+			return join(absoluteBaseUrl, substituted);
+		});
+
+		if (absolutePaths.length > 0) {
+			if (pattern === "*") {
+				modules.push(
+					...absolutePaths
+						.map((dir) => {
+							if (/[/\\]\*$/.test(dir)) {
+								return dir.replace(/[/\\]\*$/, "");
+							}
+							return "";
+						})
+						.filter(Boolean),
+				);
+			} else {
+				alias.push({ name: pattern, alias: absolutePaths });
+			}
+		}
+	}
+
+	if (absoluteBaseUrl && !modules.includes(absoluteBaseUrl)) {
+		modules.push(absoluteBaseUrl);
+	}
+
+	return {
+		alias,
+		modules,
+	};
+}
+
+/**
+ * Get the base context for the current project
+ * @param {string} context the context
+ * @param {string=} baseUrl base URL for resolving paths
+ * @returns {string} the base context
+ */
+function getAbsoluteBaseUrl(context, baseUrl) {
+	return !baseUrl ? context : join(context, baseUrl);
+}
+
+module.exports = class TsconfigPathsPlugin {
+	/**
+	 * @param {true | string | TsconfigOptions} configFileOrOptions tsconfig file path or options object
+	 */
+	constructor(configFileOrOptions) {
+		if (
+			typeof configFileOrOptions === "object" &&
+			configFileOrOptions !== null
+		) {
+			// Options object format
+			this.configFile = configFileOrOptions.configFile || DEFAULT_CONFIG_FILE;
+			/** @type {string[] | "auto"} */
+			if (Array.isArray(configFileOrOptions.references)) {
+				/** @type {TsconfigReference[] | "auto"} */
+				this.references = configFileOrOptions.references.map((ref) => ({
+					path: ref,
+				}));
+			} else if (configFileOrOptions.references === "auto") {
+				this.references = "auto";
+			} else {
+				this.references = [];
+			}
+		} else {
+			this.configFile =
+				configFileOrOptions === true
+					? DEFAULT_CONFIG_FILE
+					: /** @type {string} */ (configFileOrOptions);
+			/** @type {TsconfigReference[] | "auto"} */
+			this.references = [];
+		}
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const aliasTarget = resolver.ensureHook("internal-resolve");
+		const moduleTarget = resolver.ensureHook("module");
+
+		resolver
+			.getHook("raw-resolve")
+			.tapAsync(
+				"TsconfigPathsPlugin",
+				async (request, resolveContext, callback) => {
+					try {
+						const tsconfigPathsMap = await this._getTsconfigPathsMap(
+							resolver,
+							request,
+							resolveContext,
+						);
+
+						if (!tsconfigPathsMap) return callback();
+
+						const selectedData = this._selectPathsDataForContext(
+							request.path,
+							tsconfigPathsMap,
+						);
+
+						if (!selectedData) return callback();
+
+						aliasResolveHandler(
+							resolver,
+							selectedData.alias,
+							aliasTarget,
+							request,
+							resolveContext,
+							callback,
+						);
+					} catch (err) {
+						callback(/** @type {Error} */ (err));
+					}
+				},
+			);
+
+		resolver
+			.getHook("raw-module")
+			.tapAsync(
+				"TsconfigPathsPlugin",
+				async (request, resolveContext, callback) => {
+					try {
+						const tsconfigPathsMap = await this._getTsconfigPathsMap(
+							resolver,
+							request,
+							resolveContext,
+						);
+
+						if (!tsconfigPathsMap) return callback();
+
+						const selectedData = this._selectPathsDataForContext(
+							request.path,
+							tsconfigPathsMap,
+						);
+
+						if (!selectedData) return callback();
+
+						modulesResolveHandler(
+							resolver,
+							selectedData.modules,
+							moduleTarget,
+							request,
+							resolveContext,
+							callback,
+						);
+					} catch (err) {
+						callback(/** @type {Error} */ (err));
+					}
+				},
+			);
+	}
+
+	/**
+	 * Get TsconfigPathsMap for the request (with caching)
+	 * @param {Resolver} resolver the resolver
+	 * @param {ResolveRequest} request the request
+	 * @param {ResolveContext} resolveContext the resolve context
+	 * @returns {Promise<TsconfigPathsMap | null>} the tsconfig paths map or null
+	 */
+	async _getTsconfigPathsMap(resolver, request, resolveContext) {
+		if (typeof request.tsconfigPathsMap === "undefined") {
+			try {
+				const absTsconfigPath = join(
+					request.path || process.cwd(),
+					this.configFile,
+				);
+				const result = await this._loadTsconfigPathsMap(
+					resolver.fileSystem,
+					absTsconfigPath,
+				);
+
+				request.tsconfigPathsMap = result;
+			} catch (err) {
+				request.tsconfigPathsMap = null;
+				throw err;
+			}
+		}
+
+		if (!request.tsconfigPathsMap) {
+			return null;
+		}
+
+		for (const fileDependency of request.tsconfigPathsMap.fileDependencies) {
+			if (resolveContext.fileDependencies) {
+				resolveContext.fileDependencies.add(fileDependency);
+			}
+		}
+		return request.tsconfigPathsMap;
+	}
+
+	/**
+	 * Load tsconfig.json and build complete TsconfigPathsMap
+	 * Includes main project paths and all referenced projects
+	 * @param {FileSystem} fileSystem the file system
+	 * @param {string} absTsconfigPath absolute path to tsconfig.json
+	 * @returns {Promise<TsconfigPathsMap>} the complete tsconfig paths map
+	 */
+	async _loadTsconfigPathsMap(fileSystem, absTsconfigPath) {
+		/** @type {Set<string>} */
+		const fileDependencies = new Set();
+		const config = await this._loadTsconfig(
+			fileSystem,
+			absTsconfigPath,
+			fileDependencies,
+		);
+
+		const compilerOptions = config.compilerOptions || {};
+		const mainContext = dirname(absTsconfigPath);
+
+		const main = tsconfigPathsToResolveOptions(
+			mainContext,
+			compilerOptions.paths || {},
+			compilerOptions.baseUrl,
+		);
+		/** @type {{ [baseUrl: string]: TsconfigPathsData }} */
+		const refs = {};
+
+		let referencesToUse = null;
+		if (this.references === "auto") {
+			referencesToUse = config.references;
+		} else if (Array.isArray(this.references)) {
+			referencesToUse = this.references;
+		}
+
+		if (Array.isArray(referencesToUse)) {
+			await this._loadTsconfigReferences(
+				fileSystem,
+				mainContext,
+				referencesToUse,
+				fileDependencies,
+				refs,
+			);
+		}
+
+		return { main, mainContext, refs, fileDependencies };
+	}
+
+	/**
+	 * Select the correct TsconfigPathsData based on request.path (context-aware)
+	 * Matches the behavior of tsconfig-paths-webpack-plugin
+	 * @param {string | false} requestPath the request path
+	 * @param {TsconfigPathsMap} tsconfigPathsMap the tsconfig paths map
+	 * @returns {TsconfigPathsData | null} the selected paths data
+	 */
+	_selectPathsDataForContext(requestPath, tsconfigPathsMap) {
+		const { main, mainContext, refs } = tsconfigPathsMap;
+		if (!requestPath) {
+			return main;
+		}
+
+		// Combine main and refs into a single map: context path -> TsconfigPathsData
+		const allContexts = {
+			[mainContext]: main,
+			...refs,
+		};
+
+		let longestMatch = null;
+		let longestMatchLength = 0;
+
+		for (const [context, data] of Object.entries(allContexts)) {
+			if (context === requestPath) {
+				return data;
+			}
+			if (
+				isSubPath(context, requestPath) &&
+				context.length > longestMatchLength
+			) {
+				longestMatch = data;
+				longestMatchLength = context.length;
+			}
+		}
+
+		if (longestMatch) {
+			return longestMatch;
+		}
+
+		return null;
+	}
+
+	/**
+	 * Load tsconfig from extends path
+	 * @param {FileSystem} fileSystem the file system
+	 * @param {string} configFilePath current config file path
+	 * @param {string} extendedConfigValue extends value
+	 * @param {Set<string>} fileDependencies the file dependencies
+	 * @returns {Promise<Tsconfig>} the extended tsconfig
+	 */
+	async _loadTsconfigFromExtends(
+		fileSystem,
+		configFilePath,
+		extendedConfigValue,
+		fileDependencies,
+	) {
+		const currentDir = dirname(configFilePath);
+
+		// Substitute ${configDir} in extends path
+		extendedConfigValue = substituteConfigDir(extendedConfigValue, currentDir);
+
+		if (
+			typeof extendedConfigValue === "string" &&
+			!extendedConfigValue.includes(".json")
+		) {
+			extendedConfigValue += ".json";
+		}
+
+		let extendedConfigPath = join(currentDir, extendedConfigValue);
+
+		const exists = await new Promise((resolve) => {
+			fileSystem.readFile(extendedConfigPath, (err) => {
+				resolve(!err);
+			});
+		});
+		if (!exists && extendedConfigValue.includes("/")) {
+			extendedConfigPath = join(
+				currentDir,
+				normalize(`node_modules/${extendedConfigValue}`),
+			);
+		}
+
+		const config = await this._loadTsconfig(
+			fileSystem,
+			extendedConfigPath,
+			fileDependencies,
+		);
+		const compilerOptions = config.compilerOptions || { baseUrl: undefined };
+
+		if (compilerOptions.baseUrl) {
+			const extendsDir = dirname(extendedConfigValue);
+			compilerOptions.baseUrl = getAbsoluteBaseUrl(
+				extendsDir,
+				compilerOptions.baseUrl,
+			);
+		}
+
+		delete config.references;
+
+		return /** @type {Tsconfig} */ (config);
+	}
+
+	/**
+	 * Load referenced tsconfig projects and store in referenceMatchMap
+	 * Simple implementation matching tsconfig-paths-webpack-plugin:
+	 * Just load each reference and store independently
+	 * @param {FileSystem} fileSystem the file system
+	 * @param {string} context the context
+	 * @param {TsconfigReference[]} references array of references
+	 * @param {Set<string>} fileDependencies the file dependencies
+	 * @param {{ [baseUrl: string]: TsconfigPathsData }} referenceMatchMap the map to populate
+	 * @returns {Promise<void>}
+	 */
+	async _loadTsconfigReferences(
+		fileSystem,
+		context,
+		references,
+		fileDependencies,
+		referenceMatchMap,
+	) {
+		for (const ref of references) {
+			// Substitute ${configDir} in reference path
+			const refPath = substituteConfigDir(ref.path, context);
+			const refConfigPath = join(join(context, refPath), DEFAULT_CONFIG_FILE);
+
+			try {
+				const refConfig = await this._loadTsconfig(
+					fileSystem,
+					refConfigPath,
+					fileDependencies,
+				);
+
+				if (refConfig.compilerOptions && refConfig.compilerOptions.paths) {
+					const refContext = dirname(refConfigPath);
+
+					referenceMatchMap[refContext] = tsconfigPathsToResolveOptions(
+						refContext,
+						refConfig.compilerOptions.paths || {},
+						refConfig.compilerOptions.baseUrl,
+					);
+				}
+
+				if (this.references === "auto" && Array.isArray(refConfig.references)) {
+					await this._loadTsconfigReferences(
+						fileSystem,
+						dirname(refConfigPath),
+						refConfig.references,
+						fileDependencies,
+						referenceMatchMap,
+					);
+				}
+			} catch (_err) {
+				continue;
+			}
+		}
+	}
+
+	/**
+	 * Load tsconfig.json with extends support
+	 * @param {FileSystem} fileSystem the file system
+	 * @param {string} configFilePath absolute path to tsconfig.json
+	 * @param {Set<string>} fileDependencies the file dependencies
+	 * @returns {Promise<Tsconfig>} the merged tsconfig
+	 */
+	async _loadTsconfig(fileSystem, configFilePath, fileDependencies) {
+		const config = await readJson(fileSystem, configFilePath);
+		fileDependencies.add(configFilePath);
+
+		let result = config;
+
+		const extendedConfig = config.extends;
+		if (extendedConfig) {
+			let base;
+
+			if (Array.isArray(extendedConfig)) {
+				base = {};
+				for (const extendedConfigElement of extendedConfig) {
+					const extendedTsconfig = await this._loadTsconfigFromExtends(
+						fileSystem,
+						configFilePath,
+						extendedConfigElement,
+						fileDependencies,
+					);
+					base = mergeTsconfigs(base, extendedTsconfig);
+				}
+			} else {
+				base = await this._loadTsconfigFromExtends(
+					fileSystem,
+					configFilePath,
+					extendedConfig,
+					fileDependencies,
+				);
+			}
+
+			result = /** @type {Tsconfig} */ (mergeTsconfigs(base, config));
+		}
+
+		return result;
+	}
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/UnsafeCachePlugin.js

@@ -0,0 +1,114 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {import("./Resolver").ResolveContextYield} ResolveContextYield */
+/** @typedef {{ [k: string]: undefined | ResolveRequest | ResolveRequest[] }} Cache */
+
+/**
+ * @param {string} type type of cache
+ * @param {ResolveRequest} request request
+ * @param {boolean} withContext cache with context?
+ * @returns {string} cache id
+ */
+function getCacheId(type, request, withContext) {
+	return JSON.stringify({
+		type,
+		context: withContext ? request.context : "",
+		path: request.path,
+		query: request.query,
+		fragment: request.fragment,
+		request: request.request,
+	});
+}
+
+module.exports = class UnsafeCachePlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {(request: ResolveRequest) => boolean} filterPredicate filterPredicate
+	 * @param {Cache} cache cache
+	 * @param {boolean} withContext withContext
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, filterPredicate, cache, withContext, target) {
+		this.source = source;
+		this.filterPredicate = filterPredicate;
+		this.withContext = withContext;
+		this.cache = cache;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("UnsafeCachePlugin", (request, resolveContext, callback) => {
+				if (!this.filterPredicate(request)) return callback();
+				const isYield = typeof resolveContext.yield === "function";
+				const cacheId = getCacheId(
+					isYield ? "yield" : "default",
+					request,
+					this.withContext,
+				);
+				const cacheEntry = this.cache[cacheId];
+				if (cacheEntry) {
+					if (isYield) {
+						const yield_ =
+							/** @type {ResolveContextYield} */
+							(resolveContext.yield);
+						if (Array.isArray(cacheEntry)) {
+							for (const result of cacheEntry) yield_(result);
+						} else {
+							yield_(cacheEntry);
+						}
+						return callback(null, null);
+					}
+					return callback(null, /** @type {ResolveRequest} */ (cacheEntry));
+				}
+
+				/** @type {ResolveContextYield | undefined} */
+				let yieldFn;
+				/** @type {ResolveContextYield | undefined} */
+				let yield_;
+				/** @type {ResolveRequest[]} */
+				const yieldResult = [];
+				if (isYield) {
+					yieldFn = resolveContext.yield;
+					yield_ = (result) => {
+						yieldResult.push(result);
+					};
+				}
+
+				resolver.doResolve(
+					target,
+					request,
+					null,
+					yield_ ? { ...resolveContext, yield: yield_ } : resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+						if (isYield) {
+							if (result) yieldResult.push(result);
+							for (const result of yieldResult) {
+								/** @type {ResolveContextYield} */
+								(yieldFn)(result);
+							}
+							this.cache[cacheId] = yieldResult;
+							return callback(null, null);
+						}
+						if (result) return callback(null, (this.cache[cacheId] = result));
+						callback();
+					},
+				);
+			});
+	}
+};