load-oxfmt-config 0.24.0 → 0.25.0

package/README.md

@@ -33,7 +33,7 @@ yarn add oxfmt load-oxfmt-config
 pnpm add oxfmt load-oxfmt-config
 ```
 
-> `oxfmt >=0.68.0` is a peer dependency and is installed alongside this package.
+> `oxfmt >=0.70.0` is a peer dependency and is installed alongside this package.
 > Node.js `^22.13.0 || >=24` is supported.
 
 ## Usage
@@ -78,6 +78,27 @@ const result = await loadOxfmtConfig({
 })
 ```
 
+### Resolve EditorConfig for One File
+
+Use `loadOxfmtConfigForFile()` when formatting a specific file, especially when
+its oxfmt config and `.editorconfig` live in different directories:
+
+```ts
+import { loadOxfmtConfigForFile } from 'load-oxfmt-config'
+
+const result = await loadOxfmtConfigForFile({
+  cwd: '/path/to/project',
+  filepath: 'packages/app/src/index.ts',
+})
+```
+
+This accepts the same options as `loadOxfmtConfig()`, with `filepath` required.
+EditorConfig sections are matched relative to their own directory and applied
+in source order, including later `[*]` sections. The resulting EditorConfig
+defaults are merged below explicit oxfmt root options. Explicit oxfmt `overrides`
+remain in the returned config and must still be applied by the caller, relative
+to `result.dirname`. Config metadata retains the same meaning as in the static API.
+
 ### Get Config Metadata
 
 ```ts
@@ -344,6 +365,16 @@ Whether to use in-memory cache.
 
 Whether to include ignore patterns defined in the resolved config file.
 
+#### `includeDefaultIgnores`
+
+- **Type:** `boolean`
+- **Default:** `true`
+
+Whether to apply default directories, lockfiles, and ignore files (`.gitignore`,
+Git info exclude, `.prettierignore`, and explicit `ignorePath` files).
+Set to `false` to evaluate only config `ignorePatterns`. This does not disable
+config loading or matching; use the separate config options for that.
+
 #### `loadConfigForIgnorePatterns`
 
 - **Type:** `boolean`
@@ -437,7 +468,12 @@ The loader reads the nearest `.editorconfig` file and maps the subset of fields
 - `insert_final_newline` → `insertFinalNewline`
 - `quote_type` → `singleQuote`
 
-Only `[*]` is treated as a global section to match oxfmt. Other sections such as `[**]` and `[*.ts]` are converted into returned `overrides` entries.
+In the static API, `[*]` provides root defaults. A `[*]` section after scoped
+sections also generates an override to preserve source order. Other sections
+such as `[**]` and `[*.ts]` are converted into returned `overrides` entries;
+basename patterns such as `*.ts` are normalized to `**/*.ts` to match descendants.
+The per-file API evaluates matching sections directly, without rebasing them to
+the oxfmt config directory.
 
 ## Ignore Strategy
 
@@ -485,7 +521,12 @@ Section-specific `.editorconfig` entries are represented as generated `overrides
 
 ## Limitations
 
-`loadOxfmtConfig()` returns a static merged `OxfmtOptions` shape. That means `.editorconfig` support is represented as merged root + overrides config data, not as per-file runtime evaluation. In practice this works well for common root settings and section-based overrides, but it is not a full replacement for oxfmt's own file-by-file config resolution.
+`loadOxfmtConfig()` returns a static merged `OxfmtOptions` shape. Its generated
+EditorConfig globs cannot represent every relationship between config directories,
+particularly an ancestor EditorConfig with a nested oxfmt config. Use
+`loadOxfmtConfigForFile()` to resolve EditorConfig against its original directory
+for a specific target file. Both APIs retain the nearest-file discovery strategy;
+they do not merge multiple EditorConfig files.
 
 ## Error Handling
 
@@ -503,16 +544,19 @@ try {
 
 ## Caching Behavior
 
-The caching system maintains two separate caches:
+The caching system maintains bounded caches for:
 
 1. **Path Resolution Cache:** Stores resolved config file paths
-2. **Config Content Cache:** Stores parsed configuration objects
+2. **Config Sources:** Shares parsed oxfmt files and EditorConfig sections between target files
+3. **Config Results:** Stores merged static or per-file configuration objects
+4. **EditorConfig Matchers:** Reuses compiled section patterns
 
 **Cache keys are based on:**
 
 - `cwd` + `configPath` for path resolution
 - or `dirname(filepath)` + `configPath` when `filepath` is provided and nested lookup is enabled
 - Resolved oxfmt path and resolved `.editorconfig` path for config content
+- The target file path for per-file results, isolated from static results
 
 **Cache invalidation:**
 

package/dist/index.d.mts

@@ -60,6 +60,12 @@ export interface IsOxfmtIgnoredOptions {
    * @default true
    */
   includeConfigIgnorePatterns?: boolean;
+  /**
+   * Apply default directories, lockfiles, and ignore files independently of config patterns.
+   *
+   * @default true
+   */
+  includeDefaultIgnores?: boolean;
   /**
    * Whether to load resolved oxfmt config when evaluating config ignore patterns.
    *
@@ -203,6 +209,16 @@ export interface OxfmtOptions extends FormatConfig {
  * ```
  */
 export declare function loadOxfmtConfig(options?: LoadOxfmtConfigOptions): Promise<LoadOxfmtConfigResult>;
+/**
+ * Load config with EditorConfig fallbacks resolved for one file.
+ * Explicit oxfmt overrides remain unevaluated and retain their config-relative globs.
+ *
+ * @param options - Loader settings with the target file path.
+ * @returns Config with per-file EditorConfig defaults and config metadata.
+ */
+export declare function loadOxfmtConfigForFile(options: LoadOxfmtConfigOptions & {
+  filepath: string;
+}): Promise<LoadOxfmtConfigResult>;
 //#endregion
 //#region src/config.d.ts
 /**

package/dist/index.mjs

@@ -7,6 +7,7 @@ import { readFile, realpath, stat } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { parse, printParseErrorCode } from "jsonc-parser";
 import { parseBuffer } from "editorconfig";
+import { Minimatch } from "minimatch";
 import ignore from "ignore";
 //#region src/constants.ts
 /**
@@ -479,6 +480,11 @@ function requireFreshModule(resolvedPath) {
 //#endregion
 //#region src/editorconfig.ts
 /**
+* Shared input caches for static and per-file EditorConfig resolution.
+*/
+const sectionCache = /* @__PURE__ */ new Map();
+const matcherCache = /* @__PURE__ */ new Map();
+/**
 * Builds the cache key used for resolved EditorConfig lookups.
 *
 * @param resolveKey - The base resolution key for the current lookup.
@@ -534,21 +540,34 @@ function mergeRootOptions(oxfmtConfig, editorconfigRootOptions) {
 *
 * @param editorconfigPath - The absolute path to the .editorconfig file.
 * @param anchorDir - The directory used to rebase section patterns.
+* @param options - Optional per-file resolution and cache controls.
+* @param options.filepath - Resolve matching sections for this absolute file path.
+* @param options.useCache - Reuse parsed sections and compiled matchers.
 * @returns Parsed EditorConfig data ready to merge into oxfmt config.
 */
-async function readEditorconfigFromFile(editorconfigPath, anchorDir) {
-	const content = await readFile(editorconfigPath);
-	const parsedSections = parseBuffer(content);
+async function readEditorconfigFromFile(editorconfigPath, anchorDir, options = {}) {
+	const useCache = options.useCache !== false;
+	const readSections = async () => parseBuffer(await readFile(editorconfigPath));
+	const parsedSections = useCache ? await cachePromise(sectionCache, editorconfigPath, readSections) : await readSections();
 	const editorconfigDir = dirname(editorconfigPath);
 	const rootOptions = {};
 	const overrides = [];
+	const relativeFile = options.filepath ? toPosixPath(relative(editorconfigDir, options.filepath)) : void 0;
+	if (relativeFile !== void 0 && isPathOutsideBase(relativeFile)) return {
+		overrides,
+		rootOptions
+	};
 	for (const [sectionName, sectionBody] of parsedSections) {
 		if (!sectionName) continue;
 		const mappedOptions = mapEditorconfigSectionToOptions(sectionBody);
 		if (Object.keys(mappedOptions).length === 0) continue;
+		if (relativeFile !== void 0) {
+			if (matchesEditorconfigSection(sectionName, relativeFile, useCache)) Object.assign(rootOptions, mappedOptions);
+			continue;
+		}
 		if (isEditorconfigGlobalSection(sectionName)) {
 			Object.assign(rootOptions, mappedOptions);
-			continue;
+			if (overrides.length === 0) continue;
 		}
 		overrides.push({
 			options: mappedOptions,
@@ -617,6 +636,37 @@ function mapEditorconfigSectionToOptions(section) {
 	return options;
 }
 /**
+* Match a section against its source-relative file path without oxfmt rebasing.
+*
+* @param pattern - Original section name.
+* @param filepath - File path relative to the EditorConfig directory.
+* @param useCache - Whether compiled matchers can be reused.
+* @returns Whether the section applies to the file.
+*/
+function matchesEditorconfigSection(pattern, filepath, useCache) {
+	let matcher = useCache ? getCacheValue(matcherCache, pattern) : void 0;
+	if (!matcher) {
+		matcher = new Minimatch(normalizeEditorconfigPattern(pattern), {
+			dot: true,
+			nocomment: true,
+			noext: true,
+			nonegate: true
+		});
+		if (useCache) setCacheValue(matcherCache, pattern, matcher);
+	}
+	return matcher.match(filepath);
+}
+/**
+* Keep basename patterns recursive without changing path-scoped patterns.
+*
+* @param pattern - Original EditorConfig section name.
+* @returns Pattern suitable for matching a path relative to EditorConfig.
+*/
+function normalizeEditorconfigPattern(pattern) {
+	if (pattern === "*" || pattern === "**") return "**";
+	return pattern.includes("/") ? pattern : `**/${pattern}`;
+}
+/**
 * Parses an EditorConfig boolean string.
 *
 * @param value - The raw EditorConfig value.
@@ -677,9 +727,10 @@ function parseEditorconfigTabWidth(section, useTabs) {
 * @returns The rebased glob pattern.
 */
 function rebaseEditorconfigPattern(pattern, editorconfigDir, anchorDir) {
+	const normalizedPattern = normalizeEditorconfigPattern(pattern);
 	const relativePrefix = toPosixPath(relative(anchorDir, editorconfigDir));
-	if (!relativePrefix || relativePrefix === ".") return pattern;
-	return `${relativePrefix}/${pattern.replace(/^\//u, "")}`;
+	if (!relativePrefix || relativePrefix === ".") return normalizedPattern;
+	return `${relativePrefix}/${normalizedPattern.replace(/^\//u, "")}`;
 }
 //#endregion
 //#region src/core.ts
@@ -692,6 +743,10 @@ const resolveCache = /* @__PURE__ */ new Map();
 */
 const configCache = /* @__PURE__ */ new Map();
 /**
+* Share raw config reads across files without caching file-specific fallbacks.
+*/
+const sourceCache = /* @__PURE__ */ new Map();
+/**
 * Resolve config + editorconfig and return merged config with metadata.
 *
 * @param options - Loader settings.
@@ -706,6 +761,26 @@ const configCache = /* @__PURE__ */ new Map();
 * ```
 */
 async function loadOxfmtConfig(options = {}) {
+	return loadConfig(options);
+}
+/**
+* Load config with EditorConfig fallbacks resolved for one file.
+* Explicit oxfmt overrides remain unevaluated and retain their config-relative globs.
+*
+* @param options - Loader settings with the target file path.
+* @returns Config with per-file EditorConfig defaults and config metadata.
+*/
+async function loadOxfmtConfigForFile(options) {
+	return loadConfig(options, true);
+}
+/**
+* Share discovery and caches between static and per-file loading.
+*
+* @param options - Loader settings.
+* @param resolveEditorconfig - Resolve EditorConfig sections against the target file.
+* @returns Loaded config and metadata.
+*/
+async function loadConfig(options, resolveEditorconfig = false) {
 	const useCache = options.useCache !== false;
 	const cwd = resolve(options.cwd || process.cwd());
 	const filepath = options.filepath ? resolve(cwd, options.filepath) : void 0;
@@ -721,12 +796,17 @@ async function loadOxfmtConfig(options = {}) {
 	const resolvedPath = useCache ? await cachePromise(resolveCache, resolveKey, () => resolveOxfmtrcPath(configLookupCwd, options.configPath)) : await resolveOxfmtrcPath(configLookupCwd, options.configPath);
 	const editorconfigPath = useEditorconfig ? await (useCache ? cachePromise(resolveCache, editorconfigResolveKey, () => resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : resolveEditorconfigPath(editorconfigSearchDir, onlyCwd)) : void 0;
 	const anchorDir = dirname(resolvedPath || editorconfigPath || cwd);
+	const configKey = getConfigCacheKey(resolvedPath, editorconfigPath, JSON.stringify([resolveKey, resolveEditorconfig ? filepath : null]));
 	const loadTask = async () => {
-		const oxfmtConfig = resolvedPath ? await readConfigFromFile(resolvedPath, { useCache }).catch((error) => {
+		const readConfig = async () => 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 });
 		}) : {};
+		const oxfmtConfig = useCache && resolvedPath ? await cachePromise(sourceCache, resolvedPath, readConfig) : await readConfig();
 		if (!editorconfigPath) return oxfmtConfig;
-		const editorconfigData = await readEditorconfigFromFile(editorconfigPath, anchorDir);
+		const editorconfigData = await readEditorconfigFromFile(editorconfigPath, anchorDir, {
+			filepath: resolveEditorconfig ? filepath : void 0,
+			useCache
+		});
 		const mergedConfig = mergeRootOptions(oxfmtConfig, editorconfigData.rootOptions);
 		const mergedOverrides = mergeOverrides(oxfmtConfig, editorconfigData.overrides);
 		if (!mergedOverrides) return mergedConfig;
@@ -735,12 +815,8 @@ async function loadOxfmtConfig(options = {}) {
 			overrides: mergedOverrides
 		};
 	};
-	const hasNoConfigSources = !resolvedPath && !editorconfigPath;
 	return {
-		config: await (async () => {
-			if (hasNoConfigSources) return useCache ? await cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), () => Promise.resolve({})) : {};
-			return useCache ? await cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), loadTask) : await loadTask();
-		})(),
+		config: useCache ? await cachePromise(configCache, configKey, loadTask) : await loadTask(),
 		...resolvedPath ? {
 			dirname: dirname(resolvedPath),
 			filepath: resolvedPath
@@ -779,37 +855,10 @@ async function isOxfmtIgnored(options) {
 	const loadConfigForIgnorePatterns = options.loadConfigForIgnorePatterns !== false;
 	const cwd = resolve(options.cwd ?? process.cwd());
 	const filepath = isAbsolute(options.filepath) ? resolve(options.filepath) : resolve(cwd, options.filepath);
-	if (isDefaultIgnoredDir(filepath, options.withNodeModules ? { withNodeModules: true } : {})) return {
-		ignored: true,
-		reason: "default-dir"
-	};
-	if (isLockfile(filepath)) return {
-		ignored: true,
-		reason: "lockfile"
-	};
-	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, true);
-	if (gitignoreResult.ignored) return {
-		ignored: true,
-		reason: "gitignore"
-	};
-	if (repoRoot && !gitignoreResult.matched) {
-		const infoExcludePath = await resolveGitInfoExcludePath(repoRoot);
-		if (infoExcludePath && await matchIgnoreFile(filepath, infoExcludePath, useCache, repoRoot)) return {
-			ignored: true,
-			reason: "git-info-exclude"
-		};
+	if (options.includeDefaultIgnores !== false) {
+		const defaultResult = await resolveDefaultIgnores(filepath, cwd, options, useCache);
+		if (defaultResult.ignored) return defaultResult;
 	}
-	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
-		if ((await matchIgnoreFileChain(filepath, explicitIgnorePaths.map((path) => ({ path })), useCache)).ignored) return {
-			ignored: true,
-			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,
@@ -1022,6 +1071,49 @@ function relativeSafe(from, to) {
 	return toPosixPath(relative(from, to));
 }
 /**
+* Evaluate global ignore rules separately from explicit config patterns.
+*
+* @param filepath - Absolute target file path.
+* @param cwd - Base directory for ignore file resolution.
+* @param options - Ignore file and node_modules settings.
+* @param useCache - Whether ignore matchers can be reused.
+* @returns Global ignore status.
+*/
+async function resolveDefaultIgnores(filepath, cwd, options, useCache) {
+	if (isDefaultIgnoredDir(filepath, options.withNodeModules ? { withNodeModules: true } : {})) return {
+		ignored: true,
+		reason: "default-dir"
+	};
+	if (isLockfile(filepath)) return {
+		ignored: true,
+		reason: "lockfile"
+	};
+	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, true);
+	if (gitignoreResult.ignored) return {
+		ignored: true,
+		reason: "gitignore"
+	};
+	if (repoRoot && !gitignoreResult.matched) {
+		const infoExcludePath = await resolveGitInfoExcludePath(repoRoot);
+		if (infoExcludePath && await matchIgnoreFile(filepath, infoExcludePath, useCache, repoRoot)) return {
+			ignored: true,
+			reason: "git-info-exclude"
+		};
+	}
+	if (explicitIgnorePaths && explicitIgnorePaths.length > 0) {
+		if ((await matchIgnoreFileChain(filepath, explicitIgnorePaths.map((path) => ({ path })), useCache)).ignored) return {
+			ignored: true,
+			reason: "ignore-path"
+		};
+	} else if (await matchIgnoreFile(filepath, resolve(cwd, ".prettierignore"), useCache)) return {
+		ignored: true,
+		reason: "prettierignore"
+	};
+	return { ignored: false };
+}
+/**
 * Resolve the git info exclude file from a repo root.
 *
 * Worktrees and submodules store `.git` as a file containing a `gitdir:` pointer.
@@ -1079,4 +1171,4 @@ function validateConfigIgnorePatterns(patterns) {
 	}
 }
 //#endregion
-export { getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, readConfigFromFile, resolveOxfmtrcPath };
+export { getConfigCacheKey, getResolveCacheKey, isOxfmtIgnored, loadOxfmtConfig, loadOxfmtConfigForFile, readConfigFromFile, resolveOxfmtrcPath };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "load-oxfmt-config",
   "type": "module",
-  "version": "0.24.0",
+  "version": "0.25.0",
   "description": "Load and resolve oxfmt configuration files, including explicit JS/TS config paths, and merge supported `.editorconfig` settings for Oxfmt.",
   "keywords": [
     "editorconfig",
@@ -43,14 +43,15 @@
   },
   "sideEffects": false,
   "peerDependencies": {
-    "oxfmt": ">=0.68.0"
+    "oxfmt": ">=0.70.0"
   },
   "dependencies": {
-    "@ntnyq/utils": "^0.22.0",
+    "@ntnyq/utils": "^0.23.0",
     "editorconfig": "^3.0.2",
     "ignore": "^7.0.9",
     "jiti": "^2.7.0",
-    "jsonc-parser": "^3.3.1"
+    "jsonc-parser": "^3.3.1",
+    "minimatch": "~10.2.6"
   },
   "engines": {
     "node": "^22.13.0 || >=24"