load-oxfmt-config 0.12.1 → 0.14.0

package/README.md

@@ -10,7 +10,7 @@
 ## Features
 
 - 🔍 **Auto-discovery** - Automatically searches for config files in current and parent directories
-- 📦 **Multiple formats** - Auto-discovers `.oxfmtrc.json`, `.oxfmtrc.jsonc`, and `oxfmt.config.ts`, and also supports explicit `.js` / `.mjs` / `.cjs` / `.mts` / `.cts` config paths
+- 📦 **Multiple formats** - Auto-discovers `.oxfmtrc.json`, `.oxfmtrc.jsonc`, and `oxfmt.config.ts`, and also supports explicit `.json` / `.jsonc` / `.js` / `.mjs` / `.cjs` / `.ts` / `.mts` / `.cts` config paths
 - 🧩 **EditorConfig fallback** - Merges supported `.editorconfig` fields into the returned oxfmt config result
 - 🚫 **Ignore resolution** - Resolves ignore status with oxfmt CLI-like global + config-scoped semantics
 - ⚡ **Built-in caching** - Caches both file resolution and parsed configs for optimal performance
@@ -247,10 +247,10 @@ Control how `.editorconfig` files are read and merged:
 - **`false`** — Disable `.editorconfig` reading entirely.
 - **`EditorconfigOption`** — Enable with additional settings:
 
-| Property  | Type      | Default     | Description                                                                                                           |
-| --------- | --------- | ----------- | --------------------------------------------------------------------------------------------------------------------- |
-| `onlyCwd` | `boolean` | `false`     | When `true`, only look for `.editorconfig` in `cwd` itself — no upward traversal.                                     |
-| `cwd`     | `string`  | `undefined` | Override the directory from which `.editorconfig` resolution starts, instead of the config file's directory or `cwd`. |
+| Property  | Type      | Default     | Description                                                                                                   |
+| --------- | --------- | ----------- | ------------------------------------------------------------------------------------------------------------- |
+| `onlyCwd` | `boolean` | `false`     | When `true`, only look for `.editorconfig` in `cwd` itself — no upward traversal.                             |
+| `cwd`     | `string`  | `undefined` | Override the directory from which `.editorconfig` resolution starts, instead of the default lookup directory. |
 
 **Returns:** `Promise<LoadOxfmtConfigResult>`
 
@@ -309,8 +309,9 @@ When provided, nested config lookup is disabled (same as oxfmt CLI `-c`).
 - **Type:** `string | string[]`
 - **Default:** `undefined`
 
-Ignore files to use instead of default `.gitignore` hierarchy + cwd `.prettierignore`.
+Ignore files to use instead of the default cwd `.prettierignore`.
 Can be passed multiple times in CLI style.
+Explicit ignore paths do not replace `.gitignore` or `.git/info/exclude` handling.
 
 #### `withNodeModules`
 
@@ -417,6 +418,7 @@ export default {
 
 > JavaScript and TypeScript config files are executed while loading config. Only load them from repositories you trust.
 
+JavaScript and TypeScript config files must provide a default export whose value is an object.
 When `configPath` is passed explicitly, extensions `.json`, `.jsonc`, `.ts`, `.mts`, `.cts`, `.js`, `.mjs`, and `.cjs` are supported. Extensionless paths are also accepted and parsed as JSON.
 
 ## `.editorconfig` Support
@@ -445,21 +447,20 @@ Set `loadConfigForIgnorePatterns: false` to skip config loading entirely and kee
 
 Global ignore includes:
 
-- Default ignored directories: `.git`, `.svn`, `.jj`, `node_modules`
-- Default lockfiles: `package-lock.json`, `npm-shrinkwrap.json`, `pnpm-lock.yaml`, `yarn.lock`, `bun.lock`, `bun.lockb`
+- Default ignored directories: `.git`, `.jj`, `.sl`, `.svn`, `.hg`, `node_modules`
+- Default lockfiles: `package-lock.json`, `pnpm-lock.yaml`, `yarn.lock`, `MODULE.bazel.lock`, `bun.lock`, `deno.lock`, `composer.lock`, `Package.resolved`, `Pipfile.lock`, `flake.lock`, `Cargo.lock`, `Gopkg.lock`, `pdm.lock`, `poetry.lock`, `uv.lock`, `npm-shrinkwrap.json`, `bun.lockb`
 - Ignore files:
-  - If `ignorePath` is provided: use those files only (multiple supported)
-  - If `ignorePath` is not provided:
-    - Read `.gitignore` from the file's directory upward until the git repo boundary
-    - Read `<repo>/.git/info/exclude` when inside a git repo
-    - Read `.prettierignore` from `cwd`
+  - Always read `.gitignore` from the file's directory upward until the git repo boundary
+  - Always read `<repo>/.git/info/exclude` when inside a git repo
+  - If `ignorePath` is provided: read those files instead of `cwd/.prettierignore`
+  - If `ignorePath` is not provided: read `.prettierignore` from `cwd`
 
 Notes:
 
 - `node_modules` can be included by passing `withNodeModules: true`.
 
 - The default lockfile list mirrors oxfmt documentation intent (`package-lock.json`, `pnpm-lock.yaml`, etc.) and common ecosystem lockfiles. It is not guaranteed to be a complete internal oxfmt list.
-- `ignorePatterns` are always interpreted relative to the resolved oxfmt config directory.
+- `ignorePatterns` use gitignore semantics and are interpreted relative to the resolved oxfmt config directory.
 - `includeConfigIgnorePatterns` defaults to `true` to preserve current behavior.
 - `loadConfigForIgnorePatterns` defaults to `true` to preserve current behavior.
 - Nested config behavior follows oxfmt semantics:
@@ -477,7 +478,7 @@ The merged result follows this order:
 3. Overrides generated from `.editorconfig` sections
 4. Overrides declared directly in the oxfmt config file
 
-This means explicit oxfmt config values always win over `.editorconfig` fallback values.
+This means explicit root-level oxfmt config values win over root-level `.editorconfig` fallback values. Section-specific `.editorconfig` entries are represented as generated `overrides` in the static result, and explicit oxfmt `overrides` are appended after them.
 
 ## Limitations
 
@@ -514,6 +515,7 @@ The caching system maintains two separate caches:
 
 - Failed operations automatically clear their cache entries
 - Use `useCache: false` to bypass cache for specific calls
+- 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
 
 ## Related

package/dist/index.d.mts

@@ -2,7 +2,7 @@ import { FormatConfig } from "oxfmt";
 
 //#region src/types.d.ts
 /**
- * Object-form editorconfig option, enabling fine-grained control.
+ * Object-form `.editorconfig` option for fine-grained lookup control.
  */
 interface EditorconfigOption {
   /**
@@ -14,38 +14,41 @@ interface EditorconfigOption {
   onlyCwd?: boolean;
   /**
    * Override the directory from which `.editorconfig` resolution starts.
-   * When set, editorconfig is searched from this directory instead of from
-   * the config file's directory (or the top-level `cwd`).
    *
-   * This is useful when the oxfmt config path is pre-resolved and you still
-   * want editorconfig to be resolved relative to each file's directory.
+   * When set, `.editorconfig` is searched from this directory instead of from
+   * the config lookup directory. This is useful when the oxfmt config path is
+   * pre-resolved and EditorConfig should still be resolved from another
+   * directory, such as each file's directory.
    */
   cwd?: string;
 }
 /**
- * Format option override for a single matching rule
+ * Format option override for a single matching rule.
  */
 interface OxfmtConfigOverride {
   /**
-   * Glob patterns to match files
+   * Glob patterns to match files.
    */
   files: string[];
   /**
-   * Glob patterns to exclude files
+   * Glob patterns to exclude files.
    */
   excludeFiles?: string[];
   /**
-   * Format options to apply
+   * Format options to apply.
    */
   options?: FormatConfig;
 }
+/**
+ * Options for loading and merging oxfmt configuration.
+ */
 interface LoadOxfmtConfigOptions {
   /**
-   * Path to the configuration file
+   * Path to the configuration file.
    */
   configPath?: string;
   /**
-   * Current working directory
+   * Current working directory.
    */
   cwd?: string;
   /**
@@ -62,7 +65,9 @@ interface LoadOxfmtConfigOptions {
    */
   disableNestedConfig?: boolean;
   /**
-   * Whether to use cache
+   * Whether to use in-memory caches for path resolution and parsed config contents.
+   *
+   * @default true
    */
   useCache?: boolean;
   /**
@@ -77,16 +82,17 @@ interface LoadOxfmtConfigOptions {
   editorconfig?: boolean | EditorconfigOption;
 }
 /**
- * Final oxfmt options (including overrides)
+ * Final oxfmt options, including config `ignorePatterns` and `overrides`.
  */
 interface OxfmtOptions extends FormatConfig {
   /**
-   * Ignore files matching these glob patterns
-   * Patterns are based on the location of the Oxfmt configuration file
+   * Ignore files matching these glob patterns.
+   *
+   * Patterns are based on the location of the oxfmt configuration file.
    */
   ignorePatterns?: string[];
   /**
-   * Array of format option overrides
+   * Array of format option overrides.
    */
   overrides?: OxfmtConfigOverride[];
 }
@@ -95,15 +101,15 @@ interface OxfmtOptions extends FormatConfig {
  */
 interface LoadOxfmtConfigResult {
   /**
-   * Final merged config (oxfmt + optional editorconfig mapping)
+   * Final merged config from oxfmt and optional `.editorconfig` mapping.
    */
   config: OxfmtOptions;
   /**
-   * Absolute path of resolved config file
+   * Absolute path of resolved config file.
    */
   filepath?: string;
   /**
-   * Directory of resolved config file
+   * Directory of resolved config file.
    */
   dirname?: string;
 }
@@ -113,6 +119,7 @@ interface LoadOxfmtConfigResult {
 interface IsOxfmtIgnoredOptions {
   /**
    * Current working directory.
+   *
    * Also the base directory for default `.prettierignore` lookup.
    */
   cwd?: string;
@@ -122,37 +129,46 @@ interface IsOxfmtIgnoredOptions {
   filepath: string;
   /**
    * Explicit oxfmt config path.
+   *
    * When provided, nested config lookup is disabled (same as oxfmt CLI -c).
    */
   configPath?: string;
   /**
-   * Ignore files to use instead of default `.gitignore` hierarchy + cwd `.prettierignore`.
-   * Can be passed multiple times in CLI style.
+   * Ignore files to use instead of the default cwd `.prettierignore`.
+   *
+   * Explicit ignore paths do not replace `.gitignore` or `.git/info/exclude`
+   * handling. They can be passed multiple times in CLI style.
    */
   ignorePath?: string | string[];
   /**
    * Whether node_modules should be included.
+   *
    * @default false
    */
   withNodeModules?: boolean;
   /**
    * Disable nested config lookup.
+   *
    * @default false
    */
   disableNestedConfig?: boolean;
   /**
    * Whether to use in-memory cache.
+   *
    * @default true
    */
   useCache?: boolean;
   /**
    * Whether to include ignore patterns defined in the config file.
+   *
    * @default true
    */
   includeConfigIgnorePatterns?: boolean;
   /**
    * Whether to load resolved oxfmt config when evaluating config ignore patterns.
+   *
    * When false, only global ignore is applied and config loading is skipped.
+   *
    * @default true
    */
   loadConfigForIgnorePatterns?: boolean;
@@ -166,32 +182,11 @@ interface IsOxfmtIgnoredResult {
    */
   ignored: boolean;
   /**
-   * Matched ignore source.
+   * Matched ignore source when `ignored` is true.
    */
   reason?: 'default-dir' | 'lockfile' | 'gitignore' | 'git-info-exclude' | 'prettierignore' | 'ignore-path' | 'config-ignore-patterns';
 }
 //#endregion
-//#region src/config-file.d.ts
-/**
- * Resolve the oxfmt config file path.
- *
- * - If `configPath` is provided, absolute paths are returned as-is;
- *   relative paths are joined to `cwd`.
- * - Otherwise, walk upward from `cwd` to find known filenames.
- *
- * @param cwd - Starting directory for resolution.
- * @param configPath - Optional explicit path.
- * @returns Absolute path to config file, or undefined when not found.
- *
- * @example
- * ```ts
- * import { resolveOxfmtrcPath } from 'load-oxfmt-config'
- *
- * const path = await resolveOxfmtrcPath(process.cwd())
- * ```
- */
-declare function resolveOxfmtrcPath(cwd: string, configPath?: string): Promise<string | undefined>;
-//#endregion
 //#region src/core.d.ts
 /**
  * Resolve config + editorconfig and return merged config with metadata.
@@ -228,4 +223,52 @@ declare function loadOxfmtConfig(options?: LoadOxfmtConfigOptions): Promise<Load
  */
 declare function isOxfmtIgnored(options: IsOxfmtIgnoredOptions): Promise<IsOxfmtIgnoredResult>;
 //#endregion
-export { EditorconfigOption, IsOxfmtIgnoredOptions, IsOxfmtIgnoredResult, LoadOxfmtConfigOptions, LoadOxfmtConfigResult, OxfmtConfigOverride, OxfmtOptions, isOxfmtIgnored, loadOxfmtConfig, resolveOxfmtrcPath };
+//#region src/config.d.ts
+/**
+ * Build a cache key for path resolution (cwd + configPath).
+ *
+ * @param cwd - Current working directory.
+ * @param configPath - Optional config path.
+ * @returns Cache key for resolve cache.
+ */
+declare function getResolveCacheKey(cwd: string, configPath?: string): string;
+/**
+ * Build a cache key for config content; prefixes missing entries.
+ *
+ * @param resolvedPath - Resolved oxfmt config path.
+ * @param editorconfigPath - Resolved editorconfig path.
+ * @param resolveKey - Resolution cache key.
+ * @returns Cache key for config content cache.
+ */
+declare function getConfigCacheKey(resolvedPath: string | undefined, editorconfigPath: string | undefined, resolveKey: string): string;
+/**
+ * Resolve the oxfmt config file path.
+ *
+ * - If `configPath` is provided, absolute paths are returned as-is;
+ *   relative paths are joined to `cwd`.
+ * - Otherwise, walk upward from `cwd` to find known filenames.
+ *
+ * @param cwd - Starting directory for resolution.
+ * @param configPath - Optional explicit path.
+ * @returns Absolute path to config file, or undefined when not found.
+ *
+ * @example
+ * ```ts
+ * import { resolveOxfmtrcPath } from 'load-oxfmt-config'
+ *
+ * const path = await resolveOxfmtrcPath(process.cwd())
+ * ```
+ */
+declare function resolveOxfmtrcPath(cwd: string, configPath?: string): Promise<string | undefined>;
+/**
+ * Read and parse an oxfmt config file.
+ *
+ * @param resolvedPath - Absolute path to config file.
+ * @param options - Config loading options.
+ * @returns Parsed config object.
+ */
+declare function readConfigFromFile(resolvedPath: string, options?: {
+  useCache?: boolean;
+}): Promise<OxfmtOptions>;
+//#endregion
+export { EditorconfigOption, IsOxfmtIgnoredOptions, IsOxfmtIgnoredResult, LoadOxfmtConfigOptions, LoadOxfmtConfigResult, OxfmtConfigOverride, OxfmtOptions, getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, readConfigFromFile, resolveOxfmtrcPath };

package/dist/index.mjs

@@ -1,11 +1,12 @@
+import { createRequire } from "node:module";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve } from "node:path";
 import process from "node:process";
-import { interopDefault, isBoolean, isNumber, isObject } from "@ntnyq/utils";
+import { hasOwn, interopDefault, isBoolean, isNumber, isObject, isRecord, isString, isUndefined } from "@ntnyq/utils";
 import { readFile, stat } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { parseBuffer } from "editorconfig";
 import ignore from "ignore";
-import picomatch from "picomatch";
 //#region src/constants.ts
 /**
 * Supported configuration files for oxfmt.
@@ -34,8 +35,10 @@ const OXFMT_EXPLICIT_CONFIG_EXTENSIONS = [
 */
 const DEFAULT_IGNORED_DIRS = [
 	".git",
-	".svn",
 	".jj",
+	".sl",
+	".svn",
+	".hg",
 	"node_modules"
 ];
 /**
@@ -46,10 +49,21 @@ const DEFAULT_IGNORED_DIRS = [
 */
 const DEFAULT_IGNORED_LOCKFILES = [
 	"package-lock.json",
-	"npm-shrinkwrap.json",
 	"pnpm-lock.yaml",
 	"yarn.lock",
+	"MODULE.bazel.lock",
 	"bun.lock",
+	"deno.lock",
+	"composer.lock",
+	"Package.resolved",
+	"Pipfile.lock",
+	"flake.lock",
+	"Cargo.lock",
+	"Gopkg.lock",
+	"pdm.lock",
+	"poetry.lock",
+	"uv.lock",
+	"npm-shrinkwrap.json",
 	"bun.lockb"
 ];
 /**
@@ -61,7 +75,180 @@ const EDITORCONFIG_FILE = ".editorconfig";
 */
 const EDITORCONFIG_GLOBAL_SECTION_NAMES = ["*"];
 //#endregion
-//#region src/config-file.ts
+//#region src/config.ts
+/**
+* CommonJS require scoped to this ESM module for loading `.cjs` config files.
+*/
+const require = createRequire(import.meta.url);
+/**
+* Node error codes that mean CommonJS require should fall back to ESM loading.
+*/
+const requireFallbackErrorCodes = /* @__PURE__ */ new Set(["ERR_REQUIRE_ASYNC_MODULE", "ERR_REQUIRE_ESM"]);
+/**
+* Syntax errors that indicate module syntax was parsed through CommonJS.
+*/
+const syntaxFallbackMessages = [
+	/Cannot use import statement outside a module/u,
+	/Unexpected token 'export'/u,
+	/Unexpected token 'import'/u
+];
+/**
+* Check whether an unknown config export is an object accepted by oxfmt.
+*
+* @param value - Runtime value to validate.
+* @returns True when the value can be treated as an oxfmt options object.
+*/
+function isConfigObject(value) {
+	return isRecord(value);
+}
+/**
+* Read a parsed JSON-like config value as an oxfmt config object.
+*
+* @param config - Runtime config value.
+* @returns Oxfmt config object.
+* @throws When the config value is not an object.
+*/
+function readParsedConfigObject(config) {
+	if (!isConfigObject(config)) throw new Error("Configuration file must be an object.");
+	return config;
+}
+/**
+* Read the default export from a JavaScript or TypeScript config module.
+*
+* @param mod - Imported config module namespace.
+* @returns Oxfmt config object from the module default export.
+* @throws When the module has no default export or the default export is not an object.
+*/
+function readConfigDefaultExport(mod) {
+	if (!hasOwn(mod, "default")) throw new Error("Configuration file has no default export.");
+	const config = mod["default"];
+	if (!isConfigObject(config)) throw new Error("Configuration file must have a default export that is an object.");
+	return config;
+}
+/**
+* Read a CommonJS module export as an oxfmt config object.
+*
+* @param config - Runtime CommonJS export value.
+* @returns Oxfmt config object from the module export.
+* @throws When the module export is not an object.
+*/
+function readConfigModuleExports(config) {
+	if (!isConfigObject(config)) throw new Error("Configuration file must export an object.");
+	return config;
+}
+/**
+* Import a JavaScript or TypeScript config module through jiti.
+*
+* @param resolvedPath - Absolute config file path to import.
+* @param useCache - Whether jiti should use its filesystem and module caches.
+* @returns Imported module namespace.
+*/
+async function importJitiConfigModule(resolvedPath, useCache) {
+	return (await interopDefault(import("jiti")))(import.meta.url, useCache ? void 0 : {
+		fsCache: false,
+		moduleCache: false
+	}).import(resolvedPath);
+}
+/**
+* Build a cache-busting import key from entry file metadata.
+*
+* @param resolvedPath - Absolute config file path.
+* @returns Stable key that changes when the entry file mtime or size changes.
+*/
+async function getFreshImportCacheKey(resolvedPath) {
+	const stats = await stat(resolvedPath, { bigint: true });
+	return `${stats.mtimeNs}:${stats.size}`;
+}
+/**
+* Read a Node-style `code` field from an unknown thrown value.
+*
+* @param error - Thrown value to inspect.
+* @returns Error code when present.
+*/
+function getErrorCode(error) {
+	return isObject(error) && "code" in error && isString(error.code) ? error.code : void 0;
+}
+/**
+* Check whether a loader error should continue the JS config fallback chain.
+*
+* @param error - Thrown value from require or native import.
+* @returns True when the error is from loader compatibility, not config execution.
+*/
+function isJavaScriptLoaderFallbackError(error) {
+	const code = getErrorCode(error);
+	if (code && requireFallbackErrorCodes.has(code)) return true;
+	return error instanceof SyntaxError && syntaxFallbackMessages.some((pattern) => pattern.test(error.message));
+}
+/**
+* Import an ESM config module with entry-file cache busting.
+*
+* @param resolvedPath - Absolute config file path to import.
+* @returns Imported module namespace.
+*/
+async function importNativeFreshModule(resolvedPath) {
+	const url = pathToFileURL(resolvedPath);
+	url.searchParams.set("oxfmtConfigCacheBust", await getFreshImportCacheKey(resolvedPath));
+	return import(url.href);
+}
+/**
+* Delete a CommonJS module and all cached children reachable from it.
+*
+* @param requirePath - Resolved CommonJS module id.
+* @param seen - Visited module ids used to avoid cycles.
+*/
+function deleteRequireCacheTree(requirePath, seen = /* @__PURE__ */ new Set()) {
+	if (seen.has(requirePath)) return;
+	seen.add(requirePath);
+	const cachedModule = require.cache[requirePath];
+	if (cachedModule) for (const child of cachedModule.children) deleteRequireCacheTree(child.id, seen);
+	Reflect.deleteProperty(require.cache, requirePath);
+}
+/**
+* Require a CommonJS module after removing it from Node's require cache.
+*
+* @param resolvedPath - Absolute config file path to require.
+* @returns Runtime module export value.
+*/
+function requireFreshModule(resolvedPath) {
+	const requirePath = require.resolve(resolvedPath);
+	deleteRequireCacheTree(requirePath);
+	return require(requirePath);
+}
+/**
+* Load a CommonJS config file without reusing Node's require cache.
+*
+* @param resolvedPath - Absolute `.cjs` config file path.
+* @returns Oxfmt config object from default or module exports.
+*/
+function requireFreshCommonJSConfig(resolvedPath) {
+	const configModule = requireFreshModule(resolvedPath);
+	if (Object.prototype.toString.call(configModule) === "[object Module]") return readConfigDefaultExport(configModule);
+	return readConfigModuleExports(configModule);
+}
+/**
+* Load a JavaScript config file without reusing stale module contents.
+*
+* This supports CommonJS, native ESM, and jiti fallback loading so package type
+* and syntax differences can be handled consistently.
+*
+* @param resolvedPath - Absolute `.js` config file path.
+* @returns Imported module namespace with a default config export.
+*/
+async function importFreshJavaScriptConfigModule(resolvedPath) {
+	try {
+		const configModule = requireFreshModule(resolvedPath);
+		if (Object.prototype.toString.call(configModule) === "[object Module]") return importNativeFreshModule(resolvedPath);
+		return { default: readConfigModuleExports(configModule) };
+	} catch (error) {
+		if (!isJavaScriptLoaderFallbackError(error)) throw error;
+		try {
+			return await importNativeFreshModule(resolvedPath);
+		} catch (importError) {
+			if (!isJavaScriptLoaderFallbackError(importError)) throw importError;
+			return importJitiConfigModule(resolvedPath, false);
+		}
+	}
+}
 /**
 * Build a cache key for path resolution (cwd + configPath).
 *
@@ -124,13 +311,17 @@ async function resolveOxfmtrcPath(cwd, configPath) {
 * Read and parse an oxfmt config file.
 *
 * @param resolvedPath - Absolute path to config file.
+* @param options - Config loading options.
 * @returns Parsed config object.
 */
-async function readConfigFromFile(resolvedPath) {
+async function readConfigFromFile(resolvedPath, options = {}) {
 	const extension = extname(resolvedPath);
+	const useCache = options.useCache !== false;
 	if (extension === ".ts" || extension === ".mts" || extension === ".cts" || extension === ".js" || extension === ".mjs" || extension === ".cjs") {
-		const mod = await (await interopDefault(import("jiti")))(import.meta.url).import(resolvedPath);
-		return mod["default"] ?? mod;
+		if (!useCache && extension === ".cjs") return requireFreshCommonJSConfig(resolvedPath);
+		if (!useCache && extension === ".mjs") return readConfigDefaultExport(await importNativeFreshModule(resolvedPath));
+		if (!useCache && extension === ".js") return readConfigDefaultExport(await importFreshJavaScriptConfigModule(resolvedPath));
+		return readConfigDefaultExport(await importJitiConfigModule(resolvedPath, useCache));
 	}
 	const content = await readFile(resolvedPath, "utf8");
 	if (extension === ".jsonc") {
@@ -141,15 +332,15 @@ async function readConfigFromFile(resolvedPath) {
 		});
 		if (parseErrors.length > 0) {
 			const firstError = parseErrors[0];
-			const errorCode = firstError === void 0 ? "Unknown" : printParseErrorCode(firstError.error);
+			const errorCode = isUndefined(firstError) ? "Unknown" : printParseErrorCode(firstError.error);
 			throw new Error(`Invalid JSONC syntax: ${errorCode}`);
 		}
-		return parsed ?? {};
+		return readParsedConfigObject(isUndefined(parsed) && content.trim() === "" ? {} : parsed);
 	}
-	if (extension === ".json") return JSON.parse(content);
-	if (!extension) return JSON.parse(content);
+	if (extension === ".json") return readParsedConfigObject(JSON.parse(content));
+	if (!extension) return readParsedConfigObject(JSON.parse(content));
 	if (!OXFMT_EXPLICIT_CONFIG_EXTENSIONS.includes(extension)) throw new Error(`Unsupported oxfmt config extension "${extension}" at ${resolvedPath}`);
-	return JSON.parse(content);
+	return readParsedConfigObject(JSON.parse(content));
 }
 //#endregion
 //#region src/utils.ts
@@ -386,7 +577,13 @@ async function readEditorconfigFromFile(editorconfigPath, anchorDir) {
 }
 //#endregion
 //#region src/core.ts
+/**
+* Cache resolved config paths keyed by the effective lookup directory and optional config path.
+*/
 const resolveCache = /* @__PURE__ */ new Map();
+/**
+* Cache parsed and merged config objects keyed by resolved config and EditorConfig paths.
+*/
 const configCache = /* @__PURE__ */ new Map();
 /**
 * Resolve config + editorconfig and return merged config with metadata.
@@ -419,7 +616,7 @@ async function loadOxfmtConfig(options = {}) {
 	const editorconfigPath = useEditorconfig ? await (useCache ? cachePromise(resolveCache, editorconfigResolveKey, () => resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : void 0;
 	const anchorDir = dirname(resolvedPath || editorconfigPath || cwd);
 	const loadTask = async () => {
-		const oxfmtConfig = resolvedPath ? await readConfigFromFile(resolvedPath).catch((error) => {
+		const oxfmtConfig = resolvedPath ? await readConfigFromFile(resolvedPath, { useCache }).catch((error) => {
 			throw new Error(`Failed to parse oxfmt configuration file at ${resolvedPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
 		}) : {};
 		if (!editorconfigPath) return oxfmtConfig;
@@ -446,8 +643,15 @@ async function loadOxfmtConfig(options = {}) {
 }
 //#endregion
 //#region src/ignore.ts
+/**
+* Cache parsed ignore file matchers by ignore file path.
+*/
 const ignoreMatcherCache = /* @__PURE__ */ new Map();
 /**
+* Cache compiled matchers for config-level `ignorePatterns`.
+*/
+const configIgnoreMatcherCache = /* @__PURE__ */ new Map();
+/**
 * Check whether a file is under oxfmt's default ignored directories.
 *
 * @param filepath - Absolute file path to test.
@@ -515,6 +719,27 @@ async function matchIgnoreFile(filepath, ignoreFilePath, useCache, baseDir) {
 	return matcher.ignores(relativeToIgnore);
 }
 /**
+* 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.
+* @returns True when the ordered ignore files mark the file as ignored.
+*/
+async function matchIgnoreFileChain(filepath, ignoreFileEntries, useCache) {
+	let ignored = 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);
+		if (result.ignored) ignored = true;
+		else if (result.unignored) ignored = false;
+	}
+	return ignored;
+}
+/**
 * Resolve an ignore file path against cwd when needed.
 *
 * @param path - Absolute or relative path.
@@ -543,6 +768,29 @@ async function hasGitEntry(dir) {
 	}
 }
 /**
+* Resolve the git info exclude file from a repo root.
+*
+* Worktrees and submodules store `.git` as a file containing a `gitdir:` pointer.
+*
+* @param repoRoot - Git repository working tree root.
+* @returns Absolute path to the git info exclude file, or undefined when unavailable.
+*/
+async function resolveGitInfoExcludePath(repoRoot) {
+	const gitEntryPath = join(repoRoot, ".git");
+	try {
+		const stats = await stat(gitEntryPath);
+		if (stats.isDirectory()) return join(gitEntryPath, "info", "exclude");
+		if (!stats.isFile()) return;
+		const gitdir = (await readFile(gitEntryPath, "utf8")).split(/\r?\n/u).find((line) => line.startsWith("gitdir:"))?.slice(7).trim();
+		if (!gitdir) return;
+		return join(isAbsolute(gitdir) ? gitdir : resolve(repoRoot, gitdir), "info", "exclude");
+	} catch (error) {
+		const code = error.code;
+		if (code === "ENOENT" || code === "ENOTDIR") return;
+		throw error;
+	}
+}
+/**
 * Find the nearest git repo root by walking up from a start directory.
 *
 * @param fromDir - Directory to start from.
@@ -586,19 +834,19 @@ async function collectGitignorePaths(filepath) {
 * @param filepath - Absolute file path.
 * @param configDir - Resolved config directory.
 * @param patterns - Config ignore patterns.
+* @param useCache - Whether to reuse compiled pattern matchers.
 * @returns True when patterns mark the file as ignored.
 */
-function matchConfigIgnorePatterns(filepath, configDir, patterns) {
+function matchConfigIgnorePatterns(filepath, configDir, patterns, useCache) {
 	const relativeFile = relativeSafe(configDir, filepath);
-	let ignored = false;
-	for (const rawPattern of patterns) {
-		if (!rawPattern) continue;
-		const isNegative = rawPattern.startsWith("!");
-		const pattern = isNegative ? rawPattern.slice(1) : rawPattern;
-		if (!pattern) continue;
-		if (picomatch(pattern, { dot: true })(relativeFile)) ignored = !isNegative;
-	}
-	return ignored;
+	if (relativeFile === ".." || relativeFile.startsWith("../")) return false;
+	if (!useCache) return ignore().add(patterns).ignores(relativeFile);
+	const cacheKey = `${configDir}::${JSON.stringify(patterns)}`;
+	const cachedMatcher = configIgnoreMatcherCache.get(cacheKey);
+	if (cachedMatcher) return cachedMatcher.ignores(relativeFile);
+	const matcher = ignore().add(patterns);
+	configIgnoreMatcherCache.set(cacheKey, matcher);
+	return matcher.ignores(relativeFile);
 }
 /**
 * Resolve whether a file should be ignored using oxfmt-like CLI semantics.
@@ -631,28 +879,27 @@ async function isOxfmtIgnored(options) {
 		reason: "lockfile"
 	};
 	const explicitIgnorePaths = (typeof options.ignorePath === "string" ? [options.ignorePath] : options.ignorePath)?.map((path) => resolveIgnoreFilePath(path, cwd));
-	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
-		for (const ignoreFilePath of explicitIgnorePaths) if (await matchIgnoreFile(filepath, ignoreFilePath, useCache)) return {
-			ignored: true,
-			reason: "ignore-path"
-		};
-	} else {
-		const { paths: gitignorePaths, repoRoot } = await collectGitignorePaths(filepath);
-		for (const ignorePath of gitignorePaths) if (await matchIgnoreFile(filepath, ignorePath, useCache)) return {
+	const { paths: gitignorePaths, repoRoot } = await collectGitignorePaths(filepath);
+	if (await matchIgnoreFileChain(filepath, [...gitignorePaths].reverse().map((path) => ({ path })), useCache)) return {
+		ignored: true,
+		reason: "gitignore"
+	};
+	if (repoRoot) {
+		const infoExcludePath = await resolveGitInfoExcludePath(repoRoot);
+		if (infoExcludePath && await matchIgnoreFile(filepath, infoExcludePath, useCache, repoRoot)) return {
 			ignored: true,
-			reason: "gitignore"
+			reason: "git-info-exclude"
 		};
-		if (repoRoot) {
-			if (await matchIgnoreFile(filepath, join(repoRoot, ".git", "info", "exclude"), useCache, repoRoot)) return {
-				ignored: true,
-				reason: "git-info-exclude"
-			};
-		}
-		if (await matchIgnoreFile(filepath, resolve(cwd, ".prettierignore"), useCache)) return {
+	}
+	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
+		if (await matchIgnoreFileChain(filepath, explicitIgnorePaths.map((path) => ({ path })), useCache)) return {
 			ignored: true,
-			reason: "prettierignore"
+			reason: "ignore-path"
 		};
-	}
+	} else if (await matchIgnoreFile(filepath, resolve(cwd, ".prettierignore"), useCache)) return {
+		ignored: true,
+		reason: "prettierignore"
+	};
 	if (!loadConfigForIgnorePatterns) return { ignored: false };
 	const configResult = await loadOxfmtConfig({
 		cwd,
@@ -662,11 +909,11 @@ async function isOxfmtIgnored(options) {
 		editorconfig: false,
 		useCache
 	});
-	if (includeConfigIgnorePatterns && configResult.dirname && configResult.config.ignorePatterns && configResult.config.ignorePatterns.length > 0 && matchConfigIgnorePatterns(filepath, configResult.dirname, configResult.config.ignorePatterns)) return {
+	if (includeConfigIgnorePatterns && configResult.dirname && configResult.config.ignorePatterns && configResult.config.ignorePatterns.length > 0 && matchConfigIgnorePatterns(filepath, configResult.dirname, configResult.config.ignorePatterns, useCache)) return {
 		ignored: true,
 		reason: "config-ignore-patterns"
 	};
 	return { ignored: false };
 }
 //#endregion
-export { isOxfmtIgnored, loadOxfmtConfig, resolveOxfmtrcPath };
+export { getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, readConfigFromFile, resolveOxfmtrcPath };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "load-oxfmt-config",
-  "version": "0.12.1",
+  "version": "0.14.0",
   "description": "Load and resolve oxfmt configuration files, including explicit JS/TS config paths, and merge supported `.editorconfig` settings for Oxfmt.",
   "keywords": [
     "editorconfig",
@@ -42,29 +42,27 @@
     "access": "public"
   },
   "dependencies": {
-    "@ntnyq/utils": "^0.15.0",
+    "@ntnyq/utils": "^0.16.0",
     "editorconfig": "^3.0.2",
     "ignore": "^7.0.5",
     "jiti": "^2.7.0",
-    "jsonc-parser": "^3.3.1",
-    "picomatch": "^4.0.4"
+    "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
     "@ntnyq/tsconfig": "^3.1.0",
-    "@types/node": "^26.0.0",
-    "@types/picomatch": "^4.0.3",
-    "@typescript/native-preview": "^7.0.0-dev.20260622.1",
+    "@types/node": "^26.1.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260706.1",
     "bumpp": "^11.1.0",
     "husky": "^9.1.7",
     "nano-staged": "^1.0.2",
     "npm-run-all2": "^9.0.2",
-    "oxfmt": "^0.56.0",
-    "oxlint": "^1.71.0",
+    "oxfmt": "^0.58.0",
+    "oxlint": "^1.73.0",
     "tsdown": "^0.22.3",
-    "vitest": "^4.1.9"
+    "vitest": "^4.1.10"
   },
   "peerDependencies": {
-    "oxfmt": ">=0.56.0"
+    "oxfmt": ">=0.58.0"
   },
   "nano-staged": {
     "*.{js,ts,mjs,tsx}": "oxlint --fix",