@soda-gql/common 0.11.10 → 0.11.12

package/dist/utils-Rs7YbafF.cjs

@@ -0,0 +1,431 @@
+const require_canonical_id = require('./canonical-id-DHdeYIsT.cjs');
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+let neverthrow = require("neverthrow");
+
+//#region packages/common/src/utils/path.ts
+/**
+* File extensions to try when resolving module specifiers.
+* Ordered to match TypeScript's module resolution order.
+* @see https://www.typescriptlang.org/docs/handbook/module-resolution.html
+*/
+const MODULE_EXTENSION_CANDIDATES = [
+	".ts",
+	".tsx",
+	".mts",
+	".cts",
+	".js",
+	".mjs",
+	".cjs",
+	".jsx"
+];
+/**
+* Mapping from JS extensions to their corresponding TS extensions.
+* Used for ESM-style imports where .js is written but .ts is the actual source.
+*/
+const JS_TO_TS_EXTENSION_MAP = {
+	".js": [".ts", ".tsx"],
+	".mjs": [".mts"],
+	".cjs": [".cts"],
+	".jsx": [".tsx"]
+};
+/**
+* Parse a JS extension from a specifier for ESM-style import resolution.
+* Returns the base path (without extension), the JS extension, and corresponding TS extensions.
+*
+* @param specifier - The import specifier to parse
+* @returns Object with base, jsExtension, and tsExtensions, or null if no JS extension found
+*
+* @example
+* parseJsExtension("./foo.js") // { base: "./foo", jsExtension: ".js", tsExtensions: [".ts", ".tsx"] }
+* parseJsExtension("./foo.mjs") // { base: "./foo", jsExtension: ".mjs", tsExtensions: [".mts"] }
+* parseJsExtension("./foo") // null
+* parseJsExtension("./foo.ts") // null
+*/
+const parseJsExtension = (specifier) => {
+	for (const [ext, tsExts] of Object.entries(JS_TO_TS_EXTENSION_MAP)) {
+		if (specifier.endsWith(ext)) {
+			return {
+				base: specifier.slice(0, -ext.length),
+				jsExtension: ext,
+				tsExtensions: tsExts
+			};
+		}
+	}
+	return null;
+};
+/**
+* Normalize path to use forward slashes (cross-platform).
+* Ensures consistent path handling across platforms.
+*/
+const normalizePath = (value) => (0, node_path.normalize)(value).replace(/\\/g, "/");
+/**
+* Resolve a relative import specifier to an absolute file path.
+* Tries the specifier as-is, with extensions, and as a directory with index files.
+*
+* @param from - Absolute path to the importing file
+* @param specifier - Relative module specifier (must start with '.')
+* @returns Absolute POSIX path to the resolved file, or null if not found
+*/
+const resolveRelativeImportWithExistenceCheck = ({ filePath, specifier }) => {
+	const jsExtInfo = parseJsExtension(specifier);
+	if (jsExtInfo) {
+		const baseWithoutExt = (0, node_path.resolve)((0, node_path.dirname)(filePath), jsExtInfo.base);
+		for (const ext of jsExtInfo.tsExtensions) {
+			const candidate = `${baseWithoutExt}${ext}`;
+			if ((0, node_fs.existsSync)(candidate)) {
+				return normalizePath(candidate);
+			}
+		}
+		const jsCandidate = `${baseWithoutExt}${jsExtInfo.jsExtension}`;
+		if ((0, node_fs.existsSync)(jsCandidate)) {
+			try {
+				const stat = (0, node_fs.statSync)(jsCandidate);
+				if (stat.isFile()) {
+					return normalizePath(jsCandidate);
+				}
+			} catch {}
+		}
+		return null;
+	}
+	const base = (0, node_path.resolve)((0, node_path.dirname)(filePath), specifier);
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = `${base}${ext}`;
+		if ((0, node_fs.existsSync)(candidate)) {
+			return normalizePath(candidate);
+		}
+	}
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = (0, node_path.join)(base, `index${ext}`);
+		if ((0, node_fs.existsSync)(candidate)) {
+			return normalizePath(candidate);
+		}
+	}
+	if ((0, node_fs.existsSync)(base)) {
+		try {
+			const stat = (0, node_fs.statSync)(base);
+			if (stat.isFile()) {
+				return normalizePath(base);
+			}
+		} catch {}
+	}
+	return null;
+};
+/**
+* Resolve a relative import specifier to an absolute file path.
+* Tries the specifier as-is, with extensions, and as a directory with index files.
+*
+* @param from - Absolute path to the importing file
+* @param specifier - Relative module specifier (must start with '.')
+* @returns Absolute POSIX path to the resolved file, or null if not found
+*/
+const resolveRelativeImportWithReferences = ({ filePath, specifier, references }) => {
+	const jsExtInfo = parseJsExtension(specifier);
+	if (jsExtInfo) {
+		const baseWithoutExt = (0, node_path.resolve)((0, node_path.dirname)(filePath), jsExtInfo.base);
+		for (const ext of jsExtInfo.tsExtensions) {
+			const candidate = `${baseWithoutExt}${ext}`;
+			if (references.has(candidate)) {
+				return normalizePath(candidate);
+			}
+		}
+		const jsCandidate = `${baseWithoutExt}${jsExtInfo.jsExtension}`;
+		if (references.has(jsCandidate)) {
+			return normalizePath(jsCandidate);
+		}
+		return null;
+	}
+	const base = (0, node_path.resolve)((0, node_path.dirname)(filePath), specifier);
+	if (references.has(base)) {
+		return normalizePath(base);
+	}
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = `${base}${ext}`;
+		if (references.has(candidate)) {
+			return normalizePath(candidate);
+		}
+	}
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = (0, node_path.join)(base, `index${ext}`);
+		if (references.has(candidate)) {
+			return normalizePath(candidate);
+		}
+	}
+	return null;
+};
+/**
+* Check if a module specifier is relative (starts with '.' or '..')
+*/
+const isRelativeSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../");
+/**
+* Check if a module specifier is external (package name, not relative)
+*/
+const isExternalSpecifier = (specifier) => !isRelativeSpecifier(specifier);
+
+//#endregion
+//#region packages/common/src/utils/alias-resolver.ts
+/**
+* Match a specifier against a tsconfig path pattern.
+* Returns the captured wildcard portion or null if no match.
+*
+* Pattern rules:
+* - Exact match: "@/utils" matches "@/utils" exactly, captures ""
+* - Wildcard: "@/*" matches "@/foo", captures "foo"
+* - Wildcard with suffix: "*.js" matches "foo.js", captures "foo"
+*/
+const matchPattern = (specifier, pattern) => {
+	const starIndex = pattern.indexOf("*");
+	if (starIndex === -1) {
+		return specifier === pattern ? "" : null;
+	}
+	const prefix = pattern.slice(0, starIndex);
+	const suffix = pattern.slice(starIndex + 1);
+	if (!specifier.startsWith(prefix)) {
+		return null;
+	}
+	if (suffix && !specifier.endsWith(suffix)) {
+		return null;
+	}
+	const captured = specifier.slice(prefix.length, suffix ? specifier.length - suffix.length : undefined);
+	return captured;
+};
+/**
+* Apply a captured wildcard to a target path.
+*/
+const applyCapture = (target, captured) => {
+	const starIndex = target.indexOf("*");
+	if (starIndex === -1) {
+		return target;
+	}
+	return target.slice(0, starIndex) + captured + target.slice(starIndex + 1);
+};
+/**
+* Try to resolve a path to an actual file, applying extension resolution.
+* Handles ESM-style imports with JS extensions.
+*/
+const resolveToFile = (basePath) => {
+	const jsExtInfo = parseJsExtension(basePath);
+	if (jsExtInfo) {
+		const baseWithoutExt = basePath.slice(0, -jsExtInfo.jsExtension.length);
+		for (const ext of jsExtInfo.tsExtensions) {
+			const candidate = `${baseWithoutExt}${ext}`;
+			if ((0, node_fs.existsSync)(candidate)) {
+				try {
+					const stat = (0, node_fs.statSync)(candidate);
+					if (stat.isFile()) {
+						return normalizePath(candidate);
+					}
+				} catch {}
+			}
+		}
+		if ((0, node_fs.existsSync)(basePath)) {
+			try {
+				const stat = (0, node_fs.statSync)(basePath);
+				if (stat.isFile()) {
+					return normalizePath(basePath);
+				}
+			} catch {}
+		}
+		return null;
+	}
+	if ((0, node_fs.existsSync)(basePath)) {
+		try {
+			const stat = (0, node_fs.statSync)(basePath);
+			if (stat.isFile()) {
+				return normalizePath(basePath);
+			}
+		} catch {}
+	}
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = `${basePath}${ext}`;
+		if ((0, node_fs.existsSync)(candidate)) {
+			try {
+				const stat = (0, node_fs.statSync)(candidate);
+				if (stat.isFile()) {
+					return normalizePath(candidate);
+				}
+			} catch {}
+		}
+	}
+	for (const ext of MODULE_EXTENSION_CANDIDATES) {
+		const candidate = (0, node_path.join)(basePath, `index${ext}`);
+		if ((0, node_fs.existsSync)(candidate)) {
+			try {
+				const stat = (0, node_fs.statSync)(candidate);
+				if (stat.isFile()) {
+					return normalizePath(candidate);
+				}
+			} catch {}
+		}
+	}
+	return null;
+};
+/**
+* Create an alias resolver from tsconfig paths configuration.
+*
+* Resolution behavior:
+* 1. Try each pattern in order (first match wins per TS spec)
+* 2. For each matched pattern, try all target paths in order
+* 3. For each target, apply extension resolution
+* 4. Return first found file, or null if none found
+*/
+const createAliasResolver = (config) => {
+	const { paths } = config;
+	const patterns = Object.keys(paths);
+	return { resolve: (specifier) => {
+		for (const pattern of patterns) {
+			const captured = matchPattern(specifier, pattern);
+			if (captured === null) {
+				continue;
+			}
+			const targets = paths[pattern];
+			if (!targets) {
+				continue;
+			}
+			for (const target of targets) {
+				const resolvedTarget = applyCapture(target, captured);
+				const result = resolveToFile(resolvedTarget);
+				if (result) {
+					return result;
+				}
+			}
+		}
+		return null;
+	} };
+};
+
+//#endregion
+//#region packages/common/src/utils/cached-fn.ts
+const cachedFn = (fn) => {
+	let cached = null;
+	const ensure = () => (cached ??= { value: fn() }).value;
+	ensure.clear = () => {
+		cached = null;
+	};
+	return ensure;
+};
+
+//#endregion
+//#region packages/common/src/utils/tsconfig.ts
+/**
+* Strip JSON comments and trailing commas for parsing.
+* Handles both line comments (//) and block comments.
+*/
+const stripJsonComments = (json) => {
+	return json.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*/g, "").replace(/,(\s*[}\]])/g, "$1");
+};
+/**
+* Read and parse tsconfig.json to extract paths configuration.
+* Currently does not support `extends` - reads only the specified file.
+*
+* @param tsconfigPath - Absolute path to tsconfig.json
+* @returns Parsed paths configuration or null if no paths defined
+*/
+const readTsconfigPaths = (tsconfigPath) => {
+	let content;
+	try {
+		content = (0, node_fs.readFileSync)(tsconfigPath, "utf-8");
+	} catch (error) {
+		return (0, neverthrow.err)({
+			code: "TSCONFIG_READ_FAILED",
+			message: `Failed to read tsconfig.json: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	let parsed;
+	try {
+		const cleaned = stripJsonComments(content);
+		parsed = JSON.parse(cleaned);
+	} catch (error) {
+		return (0, neverthrow.err)({
+			code: "TSCONFIG_PARSE_FAILED",
+			message: `Failed to parse tsconfig.json: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	if (typeof parsed !== "object" || parsed === null) {
+		return (0, neverthrow.err)({
+			code: "TSCONFIG_INVALID",
+			message: "tsconfig.json must be an object"
+		});
+	}
+	const config = parsed;
+	const compilerOptions = config.compilerOptions;
+	if (!compilerOptions?.paths) {
+		return (0, neverthrow.ok)(null);
+	}
+	const tsconfigDir = (0, node_path.dirname)(tsconfigPath);
+	const baseUrl = typeof compilerOptions.baseUrl === "string" ? (0, node_path.resolve)(tsconfigDir, compilerOptions.baseUrl) : tsconfigDir;
+	const rawPaths = compilerOptions.paths;
+	const resolvedPaths = {};
+	for (const [pattern, targets] of Object.entries(rawPaths)) {
+		if (Array.isArray(targets)) {
+			resolvedPaths[pattern] = targets.map((target) => (0, node_path.resolve)(baseUrl, target));
+		}
+	}
+	return (0, neverthrow.ok)({
+		baseUrl,
+		paths: resolvedPaths
+	});
+};
+
+//#endregion
+Object.defineProperty(exports, 'MODULE_EXTENSION_CANDIDATES', {
+  enumerable: true,
+  get: function () {
+    return MODULE_EXTENSION_CANDIDATES;
+  }
+});
+Object.defineProperty(exports, 'cachedFn', {
+  enumerable: true,
+  get: function () {
+    return cachedFn;
+  }
+});
+Object.defineProperty(exports, 'createAliasResolver', {
+  enumerable: true,
+  get: function () {
+    return createAliasResolver;
+  }
+});
+Object.defineProperty(exports, 'isExternalSpecifier', {
+  enumerable: true,
+  get: function () {
+    return isExternalSpecifier;
+  }
+});
+Object.defineProperty(exports, 'isRelativeSpecifier', {
+  enumerable: true,
+  get: function () {
+    return isRelativeSpecifier;
+  }
+});
+Object.defineProperty(exports, 'normalizePath', {
+  enumerable: true,
+  get: function () {
+    return normalizePath;
+  }
+});
+Object.defineProperty(exports, 'parseJsExtension', {
+  enumerable: true,
+  get: function () {
+    return parseJsExtension;
+  }
+});
+Object.defineProperty(exports, 'readTsconfigPaths', {
+  enumerable: true,
+  get: function () {
+    return readTsconfigPaths;
+  }
+});
+Object.defineProperty(exports, 'resolveRelativeImportWithExistenceCheck', {
+  enumerable: true,
+  get: function () {
+    return resolveRelativeImportWithExistenceCheck;
+  }
+});
+Object.defineProperty(exports, 'resolveRelativeImportWithReferences', {
+  enumerable: true,
+  get: function () {
+    return resolveRelativeImportWithReferences;
+  }
+});
+//# sourceMappingURL=utils-Rs7YbafF.cjs.map

package/dist/utils-Rs7YbafF.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils-Rs7YbafF.cjs","names":["JS_TO_TS_EXTENSION_MAP: Readonly<Record<string, readonly string[]>>","cached: { value: T } | null","content: string","parsed: unknown","resolvedPaths: Record<string, readonly string[]>"],"sources":["../src/utils/path.ts","../src/utils/alias-resolver.ts","../src/utils/cached-fn.ts","../src/utils/tsconfig.ts"],"sourcesContent":["import { existsSync, statSync } from \"node:fs\";\nimport { dirname, join, normalize, resolve } from \"node:path\";\n\n/**\n * File extensions to try when resolving module specifiers.\n * Ordered to match TypeScript's module resolution order.\n * @see https://www.typescriptlang.org/docs/handbook/module-resolution.html\n */\nexport const MODULE_EXTENSION_CANDIDATES = [\".ts\", \".tsx\", \".mts\", \".cts\", \".js\", \".mjs\", \".cjs\", \".jsx\"] as const;\n\n/**\n * Mapping from JS extensions to their corresponding TS extensions.\n * Used for ESM-style imports where .js is written but .ts is the actual source.\n */\nconst JS_TO_TS_EXTENSION_MAP: Readonly<Record<string, readonly string[]>> = {\n  \".js\": [\".ts\", \".tsx\"],\n  \".mjs\": [\".mts\"],\n  \".cjs\": [\".cts\"],\n  \".jsx\": [\".tsx\"],\n};\n\n/**\n * Result of parsing a JS extension from a specifier.\n */\nexport type JsExtensionInfo = {\n  /** The specifier without the JS extension */\n  readonly base: string;\n  /** The JS extension found (e.g., \".js\", \".mjs\") */\n  readonly jsExtension: string;\n  /** The corresponding TS extensions to try (e.g., [\".ts\", \".tsx\"] for \".js\") */\n  readonly tsExtensions: readonly string[];\n};\n\n/**\n * Parse a JS extension from a specifier for ESM-style import resolution.\n * Returns the base path (without extension), the JS extension, and corresponding TS extensions.\n *\n * @param specifier - The import specifier to parse\n * @returns Object with base, jsExtension, and tsExtensions, or null if no JS extension found\n *\n * @example\n * parseJsExtension(\"./foo.js\") // { base: \"./foo\", jsExtension: \".js\", tsExtensions: [\".ts\", \".tsx\"] }\n * parseJsExtension(\"./foo.mjs\") // { base: \"./foo\", jsExtension: \".mjs\", tsExtensions: [\".mts\"] }\n * parseJsExtension(\"./foo\") // null\n * parseJsExtension(\"./foo.ts\") // null\n */\nexport const parseJsExtension = (specifier: string): JsExtensionInfo | null => {\n  for (const [ext, tsExts] of Object.entries(JS_TO_TS_EXTENSION_MAP)) {\n    if (specifier.endsWith(ext)) {\n      return {\n        base: specifier.slice(0, -ext.length),\n        jsExtension: ext,\n        tsExtensions: tsExts,\n      };\n    }\n  }\n  return null;\n};\n\n/**\n * Normalize path to use forward slashes (cross-platform).\n * Ensures consistent path handling across platforms.\n */\nexport const normalizePath = (value: string): string => normalize(value).replace(/\\\\/g, \"/\");\n\n/**\n * Resolve a relative import specifier to an absolute file path.\n * Tries the specifier as-is, with extensions, and as a directory with index files.\n *\n * @param from - Absolute path to the importing file\n * @param specifier - Relative module specifier (must start with '.')\n * @returns Absolute POSIX path to the resolved file, or null if not found\n */\nexport const resolveRelativeImportWithExistenceCheck = ({\n  filePath,\n  specifier,\n}: {\n  filePath: string;\n  specifier: string;\n}): string | null => {\n  // Handle ESM-style imports with JS extensions (e.g., \"./foo.js\" -> \"./foo.ts\")\n  const jsExtInfo = parseJsExtension(specifier);\n  if (jsExtInfo) {\n    const baseWithoutExt = resolve(dirname(filePath), jsExtInfo.base);\n\n    // Try corresponding TS extensions first\n    for (const ext of jsExtInfo.tsExtensions) {\n      const candidate = `${baseWithoutExt}${ext}`;\n      if (existsSync(candidate)) {\n        return normalizePath(candidate);\n      }\n    }\n\n    // Fall back to actual JS file if it exists\n    const jsCandidate = `${baseWithoutExt}${jsExtInfo.jsExtension}`;\n    if (existsSync(jsCandidate)) {\n      try {\n        const stat = statSync(jsCandidate);\n        if (stat.isFile()) {\n          return normalizePath(jsCandidate);\n        }\n      } catch {\n        // Ignore stat errors\n      }\n    }\n\n    return null;\n  }\n\n  const base = resolve(dirname(filePath), specifier);\n\n  // Try with extensions first (most common case)\n  // This handles cases like \"./constants\" resolving to \"./constants.ts\"\n  // even when a \"./constants\" directory exists\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = `${base}${ext}`;\n    if (existsSync(candidate)) {\n      return normalizePath(candidate);\n    }\n  }\n\n  // Try as directory with index files\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = join(base, `index${ext}`);\n    if (existsSync(candidate)) {\n      return normalizePath(candidate);\n    }\n  }\n\n  // Try exact path last (only if it's a file, not directory)\n  if (existsSync(base)) {\n    try {\n      const stat = statSync(base);\n      if (stat.isFile()) {\n        return normalizePath(base);\n      }\n    } catch {\n      // Ignore stat errors\n    }\n  }\n\n  return null;\n};\n\n/**\n * Resolve a relative import specifier to an absolute file path.\n * Tries the specifier as-is, with extensions, and as a directory with index files.\n *\n * @param from - Absolute path to the importing file\n * @param specifier - Relative module specifier (must start with '.')\n * @returns Absolute POSIX path to the resolved file, or null if not found\n */\nexport const resolveRelativeImportWithReferences = <_>({\n  filePath,\n  specifier,\n  references,\n}: {\n  filePath: string;\n  specifier: string;\n  references: Map<string, _> | Set<string>;\n}): string | null => {\n  // Handle ESM-style imports with JS extensions (e.g., \"./foo.js\" -> \"./foo.ts\")\n  const jsExtInfo = parseJsExtension(specifier);\n  if (jsExtInfo) {\n    const baseWithoutExt = resolve(dirname(filePath), jsExtInfo.base);\n\n    // Try corresponding TS extensions first\n    for (const ext of jsExtInfo.tsExtensions) {\n      const candidate = `${baseWithoutExt}${ext}`;\n      if (references.has(candidate)) {\n        return normalizePath(candidate);\n      }\n    }\n\n    // Fall back to actual JS file if it exists in references\n    const jsCandidate = `${baseWithoutExt}${jsExtInfo.jsExtension}`;\n    if (references.has(jsCandidate)) {\n      return normalizePath(jsCandidate);\n    }\n\n    return null;\n  }\n\n  const base = resolve(dirname(filePath), specifier);\n\n  // Try exact path first\n  if (references.has(base)) {\n    return normalizePath(base);\n  }\n\n  // Try with extensions\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = `${base}${ext}`;\n    if (references.has(candidate)) {\n      return normalizePath(candidate);\n    }\n  }\n\n  // Try as directory with index files\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = join(base, `index${ext}`);\n    if (references.has(candidate)) {\n      return normalizePath(candidate);\n    }\n  }\n\n  return null;\n};\n\n/**\n * Check if a module specifier is relative (starts with '.' or '..')\n */\nexport const isRelativeSpecifier = (specifier: string): boolean => specifier.startsWith(\"./\") || specifier.startsWith(\"../\");\n\n/**\n * Check if a module specifier is external (package name, not relative)\n */\nexport const isExternalSpecifier = (specifier: string): boolean => !isRelativeSpecifier(specifier);\n","import { existsSync, statSync } from \"node:fs\";\nimport { join } from \"node:path\";\nimport { MODULE_EXTENSION_CANDIDATES, normalizePath, parseJsExtension } from \"./path\";\nimport type { TsconfigPathsConfig } from \"./tsconfig\";\n\n/**\n * Alias resolver interface for resolving path aliases to file paths.\n */\nexport type AliasResolver = {\n  /**\n   * Resolve an alias specifier to an absolute file path.\n   * Returns null if the specifier doesn't match any alias pattern\n   * or if the resolved file doesn't exist.\n   */\n  readonly resolve: (specifier: string) => string | null;\n};\n\n/**\n * Match a specifier against a tsconfig path pattern.\n * Returns the captured wildcard portion or null if no match.\n *\n * Pattern rules:\n * - Exact match: \"@/utils\" matches \"@/utils\" exactly, captures \"\"\n * - Wildcard: \"@/*\" matches \"@/foo\", captures \"foo\"\n * - Wildcard with suffix: \"*.js\" matches \"foo.js\", captures \"foo\"\n */\nconst matchPattern = (specifier: string, pattern: string): string | null => {\n  const starIndex = pattern.indexOf(\"*\");\n\n  if (starIndex === -1) {\n    // Exact match - no wildcard\n    return specifier === pattern ? \"\" : null;\n  }\n\n  const prefix = pattern.slice(0, starIndex);\n  const suffix = pattern.slice(starIndex + 1);\n\n  if (!specifier.startsWith(prefix)) {\n    return null;\n  }\n\n  if (suffix && !specifier.endsWith(suffix)) {\n    return null;\n  }\n\n  // Extract the wildcard capture\n  const captured = specifier.slice(prefix.length, suffix ? specifier.length - suffix.length : undefined);\n\n  return captured;\n};\n\n/**\n * Apply a captured wildcard to a target path.\n */\nconst applyCapture = (target: string, captured: string): string => {\n  const starIndex = target.indexOf(\"*\");\n  if (starIndex === -1) {\n    return target;\n  }\n  return target.slice(0, starIndex) + captured + target.slice(starIndex + 1);\n};\n\n/**\n * Try to resolve a path to an actual file, applying extension resolution.\n * Handles ESM-style imports with JS extensions.\n */\nconst resolveToFile = (basePath: string): string | null => {\n  // Handle ESM-style JS extension imports\n  const jsExtInfo = parseJsExtension(basePath);\n  if (jsExtInfo) {\n    const baseWithoutExt = basePath.slice(0, -jsExtInfo.jsExtension.length);\n\n    // Try corresponding TS extensions first\n    for (const ext of jsExtInfo.tsExtensions) {\n      const candidate = `${baseWithoutExt}${ext}`;\n      if (existsSync(candidate)) {\n        try {\n          const stat = statSync(candidate);\n          if (stat.isFile()) {\n            return normalizePath(candidate);\n          }\n        } catch {\n          // Ignore stat errors\n        }\n      }\n    }\n\n    // Fall back to actual JS file\n    if (existsSync(basePath)) {\n      try {\n        const stat = statSync(basePath);\n        if (stat.isFile()) {\n          return normalizePath(basePath);\n        }\n      } catch {\n        // Ignore stat errors\n      }\n    }\n\n    return null;\n  }\n\n  // Try exact path first (for paths with explicit extension)\n  if (existsSync(basePath)) {\n    try {\n      const stat = statSync(basePath);\n      if (stat.isFile()) {\n        return normalizePath(basePath);\n      }\n    } catch {\n      // Ignore stat errors\n    }\n  }\n\n  // Try with extensions\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = `${basePath}${ext}`;\n    if (existsSync(candidate)) {\n      try {\n        const stat = statSync(candidate);\n        if (stat.isFile()) {\n          return normalizePath(candidate);\n        }\n      } catch {\n        // Ignore stat errors\n      }\n    }\n  }\n\n  // Try as directory with index files\n  for (const ext of MODULE_EXTENSION_CANDIDATES) {\n    const candidate = join(basePath, `index${ext}`);\n    if (existsSync(candidate)) {\n      try {\n        const stat = statSync(candidate);\n        if (stat.isFile()) {\n          return normalizePath(candidate);\n        }\n      } catch {\n        // Ignore stat errors\n      }\n    }\n  }\n\n  return null;\n};\n\n/**\n * Create an alias resolver from tsconfig paths configuration.\n *\n * Resolution behavior:\n * 1. Try each pattern in order (first match wins per TS spec)\n * 2. For each matched pattern, try all target paths in order\n * 3. For each target, apply extension resolution\n * 4. Return first found file, or null if none found\n */\nexport const createAliasResolver = (config: TsconfigPathsConfig): AliasResolver => {\n  const { paths } = config;\n  const patterns = Object.keys(paths);\n\n  return {\n    resolve: (specifier: string): string | null => {\n      // Try each pattern in order (first match wins per TS spec)\n      for (const pattern of patterns) {\n        const captured = matchPattern(specifier, pattern);\n        if (captured === null) {\n          continue;\n        }\n\n        const targets = paths[pattern];\n        if (!targets) {\n          continue;\n        }\n\n        // Try each target path in order\n        for (const target of targets) {\n          const resolvedTarget = applyCapture(target, captured);\n          const result = resolveToFile(resolvedTarget);\n          if (result) {\n            return result;\n          }\n        }\n      }\n\n      return null;\n    },\n  };\n};\n","export const cachedFn = <T>(fn: () => T) => {\n  let cached: { value: T } | null = null;\n\n  const ensure = () => (cached ??= { value: fn() }).value;\n  ensure.clear = () => {\n    cached = null;\n  };\n\n  return ensure;\n};\n","import { readFileSync } from \"node:fs\";\nimport { dirname, resolve } from \"node:path\";\nimport { err, ok, type Result } from \"neverthrow\";\n\n/**\n * Parsed tsconfig.json paths configuration.\n * All paths are resolved to absolute paths.\n */\nexport type TsconfigPathsConfig = {\n  /** Absolute base URL for path resolution */\n  readonly baseUrl: string;\n  /** Path mappings with absolute paths */\n  readonly paths: Readonly<Record<string, readonly string[]>>;\n};\n\n/**\n * Error types for tsconfig reading.\n */\nexport type TsconfigReadError = {\n  readonly code: \"TSCONFIG_READ_FAILED\" | \"TSCONFIG_PARSE_FAILED\" | \"TSCONFIG_INVALID\";\n  readonly message: string;\n};\n\n/**\n * Strip JSON comments and trailing commas for parsing.\n * Handles both line comments (//) and block comments.\n */\nconst stripJsonComments = (json: string): string => {\n  return (\n    json\n      // Remove block comments\n      .replace(/\\/\\*[\\s\\S]*?\\*\\//g, \"\")\n      // Remove line comments\n      .replace(/\\/\\/.*/g, \"\")\n      // Remove trailing commas before } or ]\n      .replace(/,(\\s*[}\\]])/g, \"$1\")\n  );\n};\n\n/**\n * Read and parse tsconfig.json to extract paths configuration.\n * Currently does not support `extends` - reads only the specified file.\n *\n * @param tsconfigPath - Absolute path to tsconfig.json\n * @returns Parsed paths configuration or null if no paths defined\n */\nexport const readTsconfigPaths = (tsconfigPath: string): Result<TsconfigPathsConfig | null, TsconfigReadError> => {\n  // Read file\n  let content: string;\n  try {\n    content = readFileSync(tsconfigPath, \"utf-8\");\n  } catch (error) {\n    return err({\n      code: \"TSCONFIG_READ_FAILED\",\n      message: `Failed to read tsconfig.json: ${error instanceof Error ? error.message : String(error)}`,\n    });\n  }\n\n  // Parse JSON (with comment stripping)\n  let parsed: unknown;\n  try {\n    const cleaned = stripJsonComments(content);\n    parsed = JSON.parse(cleaned);\n  } catch (error) {\n    return err({\n      code: \"TSCONFIG_PARSE_FAILED\",\n      message: `Failed to parse tsconfig.json: ${error instanceof Error ? error.message : String(error)}`,\n    });\n  }\n\n  // Validate structure\n  if (typeof parsed !== \"object\" || parsed === null) {\n    return err({\n      code: \"TSCONFIG_INVALID\",\n      message: \"tsconfig.json must be an object\",\n    });\n  }\n\n  const config = parsed as Record<string, unknown>;\n  const compilerOptions = config.compilerOptions as Record<string, unknown> | undefined;\n\n  // Return null if no paths defined\n  if (!compilerOptions?.paths) {\n    return ok(null);\n  }\n\n  // Resolve baseUrl\n  const tsconfigDir = dirname(tsconfigPath);\n  const baseUrl = typeof compilerOptions.baseUrl === \"string\" ? resolve(tsconfigDir, compilerOptions.baseUrl) : tsconfigDir;\n\n  // Resolve paths to absolute paths\n  const rawPaths = compilerOptions.paths as Record<string, string[]>;\n  const resolvedPaths: Record<string, readonly string[]> = {};\n\n  for (const [pattern, targets] of Object.entries(rawPaths)) {\n    if (Array.isArray(targets)) {\n      resolvedPaths[pattern] = targets.map((target) => resolve(baseUrl, target));\n    }\n  }\n\n  return ok({\n    baseUrl,\n    paths: resolvedPaths,\n  });\n};\n"],"mappings":"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"}