load-oxfmt-config 0.18.0 → 0.19.0

package/README.md

@@ -516,8 +516,9 @@ The caching system maintains two separate caches:
 
 - Failed operations automatically clear their cache entries
 - Use `useCache: false` to bypass cache for specific calls
+- Each process-level cache retains at most 1,000 least-recently used entries
 - For native ESM config files (`.mjs` or `.js` under `"type": "module"`), `useCache: false` cache-busts the entry config file. Imported ESM helper modules still follow Node.js module cache behavior for the current process.
-- Cache persists for the lifetime of the Node.js process
+- Cache entries persist until least-recently used eviction or process exit
 
 ## Related
 

package/dist/index.mjs

@@ -1,8 +1,9 @@
 import { createRequire } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import process from "node:process";
-import { hasOwn, interopDefault, isBoolean, isNumber, isObject, isRecord, isString, isUndefined } from "@ntnyq/utils";
-import { readFile, stat } from "node:fs/promises";
+import { hasOwn, interopDefault, isBoolean, isNumber, isObject, isString, isUndefined } from "@ntnyq/utils";
+import { createHash } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { parseBuffer } from "editorconfig";
@@ -78,6 +79,34 @@ const EDITORCONFIG_GLOBAL_SECTION_NAMES = ["*"];
 //#endregion
 //#region src/utils.ts
 /**
+* Read a cache value and move it to the most-recent position.
+*
+* @param cache - Cache map to read.
+* @param key - Cache key.
+* @returns Cached value, or undefined when missing.
+*/
+function getCacheValue(cache, key) {
+	const value = cache.get(key);
+	if (value === void 0) return;
+	cache.delete(key);
+	cache.set(key, value);
+	return value;
+}
+/**
+* Store a cache value and evict the least-recent entry when over capacity.
+*
+* @param cache - Cache map to update.
+* @param key - Cache key.
+* @param value - Value to cache.
+*/
+function setCacheValue(cache, key, value) {
+	cache.delete(key);
+	cache.set(key, value);
+	if (cache.size <= 1e3) return;
+	const oldestKey = cache.keys().next();
+	if (!oldestKey.done) cache.delete(oldestKey.value);
+}
+/**
 * Return a cached promise by key, creating and storing it on miss.
 *
 * If the promise rejects, the cache entry is removed so future calls can retry.
@@ -88,13 +117,13 @@ const EDITORCONFIG_GLOBAL_SECTION_NAMES = ["*"];
 * @returns Cached or newly created promise.
 */
 function cachePromise(cache, key, factory) {
-	const cached = cache.get(key);
+	const cached = getCacheValue(cache, key);
 	if (cached) return cached;
 	const task = factory().catch((error) => {
-		cache.delete(key);
+		if (cache.get(key) === task) cache.delete(key);
 		throw error;
 	});
-	cache.set(key, task);
+	setCacheValue(cache, key, task);
 	return task;
 }
 /**
@@ -115,6 +144,19 @@ function toPosixPath(path) {
 function splitPathSegments(path) {
 	return path.split(/[\\/]+/u).filter(Boolean);
 }
+/**
+* Check whether a relative path points outside its intended base directory.
+*
+* This also recognizes Windows drive-qualified paths when running on another
+* platform so the behavior can be tested consistently.
+*
+* @param path - Relative path candidate.
+* @returns True when the path escapes or is absolute.
+*/
+function isPathOutsideBase(path) {
+	const normalizedPath = toPosixPath(path);
+	return normalizedPath === ".." || normalizedPath.startsWith("../") || normalizedPath.startsWith("/") || /^[A-Za-z]:\//u.test(normalizedPath);
+}
 //#endregion
 //#region src/config.ts
 /**
@@ -149,7 +191,9 @@ const freshJavaScriptModuleCache = /* @__PURE__ */ new Map();
 * @returns True when the value can be treated as an oxfmt options object.
 */
 function isConfigObject(value) {
-	return isRecord(value);
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
 }
 /**
 * Read a parsed JSON-like config value as an oxfmt config object.
@@ -200,14 +244,14 @@ async function importJitiConfigModule(resolvedPath, useCache) {
 	}).import(resolvedPath);
 }
 /**
-* Build a cache-busting import key from entry file metadata.
+* Build a cache-busting import key from entry file contents.
 *
 * @param resolvedPath - Absolute config file path.
-* @returns Stable key that changes when the entry file mtime or size changes.
+* @returns Stable key that changes when the entry file contents change.
 */
 async function getFreshImportCacheKey(resolvedPath) {
-	const stats = await stat(resolvedPath, { bigint: true });
-	return `${stats.mtimeNs}:${stats.size}`;
+	const content = await readFile(resolvedPath);
+	return createHash("sha256").update(content).digest("hex");
 }
 /**
 * Read a Node-style `code` field from an unknown thrown value.
@@ -222,12 +266,13 @@ function getErrorCode(error) {
 * Check whether a loader error should continue the JS config fallback chain.
 *
 * @param error - Thrown value from require or native import.
+* @param resolvedPaths - Entry module paths that may appear in parser errors.
 * @returns True when the error is from loader compatibility, not config execution.
 */
-function isJavaScriptLoaderFallbackError(error) {
+function isJavaScriptLoaderFallbackError(error, resolvedPaths) {
 	const code = getErrorCode(error);
 	if (code && requireFallbackErrorCodes.has(code)) return true;
-	return error instanceof SyntaxError && syntaxFallbackMessages.some((pattern) => pattern.test(error.message));
+	return error instanceof SyntaxError && resolvedPaths.some((resolvedPath) => error.stack?.startsWith(`${resolvedPath}:`) === true) && syntaxFallbackMessages.some((pattern) => pattern.test(error.message));
 }
 /**
 * Import an ESM config module with entry-file cache busting.
@@ -287,12 +332,14 @@ function requireFreshCommonJSConfig(resolvedPath) {
 * @returns Imported module namespace with a default config export.
 */
 async function importFreshJavaScriptConfigModule(resolvedPath) {
+	const canonicalPath = await realpath(resolvedPath);
+	const loaderPaths = canonicalPath === resolvedPath ? [resolvedPath] : [resolvedPath, canonicalPath];
 	const cacheKey = await getFreshImportCacheKey(resolvedPath);
-	const cachedModule = freshJavaScriptModuleCache.get(resolvedPath);
+	const cachedModule = getCacheValue(freshJavaScriptModuleCache, resolvedPath);
 	if (cachedModule?.cacheKey === cacheKey) return cachedModule.namespace;
 	if (cachedModule) {
 		const namespace = await importNativeFreshModule(resolvedPath);
-		freshJavaScriptModuleCache.set(resolvedPath, {
+		setCacheValue(freshJavaScriptModuleCache, resolvedPath, {
 			cacheKey,
 			namespace
 		});
@@ -302,7 +349,7 @@ async function importFreshJavaScriptConfigModule(resolvedPath) {
 		const configModule = requireFreshModule(resolvedPath);
 		if (Object.prototype.toString.call(configModule) === "[object Module]") {
 			const namespace = configModule;
-			freshJavaScriptModuleCache.set(resolvedPath, {
+			setCacheValue(freshJavaScriptModuleCache, resolvedPath, {
 				cacheKey,
 				namespace
 			});
@@ -310,16 +357,16 @@ async function importFreshJavaScriptConfigModule(resolvedPath) {
 		}
 		return { default: readConfigModuleExports(configModule) };
 	} catch (error) {
-		if (!isJavaScriptLoaderFallbackError(error)) throw error;
+		if (!isJavaScriptLoaderFallbackError(error, loaderPaths)) throw error;
 		try {
 			const namespace = await importNativeFreshModule(resolvedPath);
-			freshJavaScriptModuleCache.set(resolvedPath, {
+			setCacheValue(freshJavaScriptModuleCache, resolvedPath, {
 				cacheKey,
 				namespace
 			});
 			return namespace;
 		} catch (importError) {
-			if (!isJavaScriptLoaderFallbackError(importError)) throw importError;
+			if (!isJavaScriptLoaderFallbackError(importError, loaderPaths)) throw importError;
 			return importJitiConfigModule(resolvedPath, false);
 		}
 	}
@@ -762,26 +809,25 @@ async function matchIgnoreFile(filepath, ignoreFilePath, useCache, baseDir) {
 	const matcher = await loadIgnoreMatcher(ignoreFilePath, useCache);
 	if (!matcher) return false;
 	const relativeToIgnore = relativeSafe(baseDir ?? dirname(ignoreFilePath), filepath);
-	if (relativeToIgnore === ".." || relativeToIgnore.startsWith("../")) return false;
+	if (isPathOutsideBase(relativeToIgnore)) return false;
 	return matcher.ignores(relativeToIgnore);
 }
 /**
-* Match a file path against ordered ignore files while preserving negation state.
+* Match a path against loaded ignore matchers in precedence order.
 *
-* @param filepath - Absolute file path.
-* @param ignoreFileEntries - Ignore files in increasing precedence order.
-* @param useCache - Whether to use matcher cache.
-* @returns True when the ordered ignore files mark the file as ignored.
+* @param filepath - Absolute file or directory path to test.
+* @param matcherEntries - Loaded matchers in increasing precedence order.
+* @param isDirectory - Whether the target path is a directory.
+* @returns Final ignore state after all matching rules.
 */
-async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache) {
+function matchLoadedIgnoreMatchers(filepath, matcherEntries, isDirectory = false) {
 	let ignored = false;
 	let matched = false;
-	for (const entry of ignoreFileEntries) {
-		const matcher = await loadIgnoreMatcher(entry.path, useCache);
-		if (!matcher) continue;
-		const relativeToIgnore = relativeSafe(entry.baseDir ?? dirname(entry.path), filepath);
-		if (relativeToIgnore === ".." || relativeToIgnore.startsWith("../")) continue;
-		const result = matcher.test(relativeToIgnore);
+	for (const entry of matcherEntries) {
+		let relativeToIgnore = relativeSafe(entry.baseDir, filepath);
+		if (isPathOutsideBase(relativeToIgnore)) continue;
+		if (isDirectory && relativeToIgnore && !relativeToIgnore.endsWith("/")) relativeToIgnore += "/";
+		const result = entry.matcher.test(relativeToIgnore);
 		if (result.ignored) {
 			ignored = true;
 			matched = true;
@@ -796,6 +842,28 @@ async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache) {
 	};
 }
 /**
+* Match a file path against ordered ignore files while preserving negation state.
+*
+* @param filepath - Absolute file path.
+* @param ignoreFileEntries - Ignore files in increasing precedence order.
+* @param useCache - Whether to use matcher cache.
+* @param stopAtIgnoredDirectory - Whether ignored directories prevent reading nested ignore files.
+* @returns True when the ordered ignore files mark the file as ignored.
+*/
+async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache, stopAtIgnoredDirectory = false) {
+	const matcherEntries = [];
+	for (const entry of ignoreFileEntries) {
+		const baseDir = entry.baseDir ?? dirname(entry.path);
+		if (stopAtIgnoredDirectory && matchLoadedIgnoreMatchers(baseDir, matcherEntries, true).ignored) break;
+		const matcher = await loadIgnoreMatcher(entry.path, useCache);
+		if (matcher) matcherEntries.push({
+			baseDir,
+			matcher
+		});
+	}
+	return matchLoadedIgnoreMatchers(filepath, matcherEntries);
+}
+/**
 * Resolve an ignore file path against cwd when needed.
 *
 * @param path - Absolute or relative path.
@@ -920,13 +988,13 @@ function validateConfigIgnorePatterns(patterns) {
 function matchConfigIgnorePatterns(filepath, configDir, patterns, useCache) {
 	validateConfigIgnorePatterns(patterns);
 	const relativeFile = relativeSafe(configDir, filepath);
-	if (relativeFile === ".." || relativeFile.startsWith("../")) return false;
+	if (isPathOutsideBase(relativeFile)) return false;
 	if (!useCache) return ignore().add(patterns).ignores(relativeFile);
 	const cacheKey = `${configDir}::${JSON.stringify(patterns)}`;
-	const cachedMatcher = configIgnoreMatcherCache.get(cacheKey);
+	const cachedMatcher = getCacheValue(configIgnoreMatcherCache, cacheKey);
 	if (cachedMatcher) return cachedMatcher.ignores(relativeFile);
 	const matcher = ignore().add(patterns);
-	configIgnoreMatcherCache.set(cacheKey, matcher);
+	setCacheValue(configIgnoreMatcherCache, cacheKey, matcher);
 	return matcher.ignores(relativeFile);
 }
 /**
@@ -961,7 +1029,7 @@ async function isOxfmtIgnored(options) {
 	};
 	const explicitIgnorePaths = (typeof options.ignorePath === "string" ? [options.ignorePath] : options.ignorePath)?.map((path) => resolveIgnoreFilePath(path, cwd));
 	const { paths: gitignorePaths, repoRoot } = await collectGitignorePaths(filepath);
-	const gitignoreResult = await matchIgnoreFileChain(filepath, [...gitignorePaths].reverse().map((path) => ({ path })), useCache);
+	const gitignoreResult = await matchIgnoreFileChain(filepath, [...gitignorePaths].reverse().map((path) => ({ path })), useCache, true);
 	if (gitignoreResult.ignored) return {
 		ignored: true,
 		reason: "gitignore"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "load-oxfmt-config",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "Load and resolve oxfmt configuration files, including explicit JS/TS config paths, and merge supported `.editorconfig` settings for Oxfmt.",
   "keywords": [
     "editorconfig",
@@ -42,7 +42,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ntnyq/utils": "^0.21.0",
+    "@ntnyq/utils": "^0.21.1",
     "editorconfig": "^3.0.2",
     "ignore": "^7.0.6",
     "jiti": "^2.7.0",
@@ -50,21 +50,21 @@
   },
   "devDependencies": {
     "@ntnyq/tsconfig": "^3.1.0",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@typescript/native-preview": "^7.0.0-dev.20260707.2",
-    "bumpp": "^12.1.1",
+    "bumpp": "^12.2.0",
     "changelogithub": "14.0.0",
     "husky": "^9.1.7",
     "nano-staged": "^1.0.2",
     "npm": "11.18.0",
     "npm-run-all2": "^9.0.3",
-    "oxfmt": "^0.62.0",
-    "oxlint": "^1.77.0",
+    "oxfmt": "^0.63.0",
+    "oxlint": "^1.78.0",
     "tsdown": "^0.22.14",
     "vitest": "^4.1.10"
   },
   "peerDependencies": {
-    "oxfmt": ">=0.62.0"
+    "oxfmt": ">=0.63.0"
   },
   "nano-staged": {
     "*.{js,ts,mjs,tsx}": "oxlint --fix",