load-oxfmt-config 0.1.1 → 0.2.1

package/README.md

@@ -5,12 +5,13 @@
 [![NPM DOWNLOADS](https://img.shields.io/npm/dy/load-oxfmt-config.svg)](https://www.npmjs.com/package/load-oxfmt-config)
 [![LICENSE](https://img.shields.io/github/license/ntnyq/load-oxfmt-config.svg)](https://github.com/ntnyq/load-oxfmt-config/blob/main/LICENSE)
 
-> Load and resolve `.oxfmtrc.json(c)` configuration files for [oxfmt](https://oxc.rs/docs/guide/usage/formatter.html).
+> Load and resolve oxfmt configuration files and merge supported `.editorconfig` settings for [oxfmt](https://oxc.rs/docs/guide/usage/formatter.html).
 
 ## Features
 
 - 🔍 **Auto-discovery** - Automatically searches for config files in current and parent directories
-- 📦 **Multiple formats** - Supports both `.oxfmtrc.json` and `.oxfmtrc.jsonc` (JSON with comments)
+- 📦 **Multiple formats** - Supports `.oxfmtrc.json`, `.oxfmtrc.jsonc`, and `oxfmt.config.ts`
+- 🧩 **EditorConfig fallback** - Merges supported `.editorconfig` fields into the returned oxfmt config result
 - ⚡ **Built-in caching** - Caches both file resolution and parsed configs for optimal performance
 - 🎯 **TypeScript support** - Fully typed with comprehensive type definitions
 - 🛠️ **Flexible API** - Support explicit config paths or automatic discovery
@@ -38,11 +39,29 @@ Load config from current directory or parent directories:
 ```ts
 import { loadOxfmtConfig } from 'load-oxfmt-config'
 
-// Automatically searches for .oxfmtrc.json(c) in current and parent directories
+// Automatically searches for oxfmt config files and the nearest .editorconfig
 const config = await loadOxfmtConfig()
 console.log(config) // { printWidth: 80, ... }
 ```
 
+### Merge With `.editorconfig`
+
+```ts
+import { loadOxfmtConfig } from 'load-oxfmt-config'
+
+const config = await loadOxfmtConfig({ cwd: '/path/to/project' })
+
+// Returns one merged static config object
+console.log(config)
+// {
+//   tabWidth: 2,
+//   printWidth: 100,
+//   overrides: [
+//     { files: ['src/**/*.ts'], options: { printWidth: 120 } }
+//   ]
+// }
+```
+
 ### Specify Working Directory
 
 ```ts
@@ -70,6 +89,28 @@ const config = await loadOxfmtConfig({
 })
 ```
 
+### Disable `.editorconfig`
+
+```ts
+import { loadOxfmtConfig } from 'load-oxfmt-config'
+
+// Skip .editorconfig reading entirely
+const config = await loadOxfmtConfig({
+  editorconfig: false,
+})
+```
+
+### Limit `.editorconfig` to `cwd`
+
+```ts
+import { loadOxfmtConfig } from 'load-oxfmt-config'
+
+// Only look in the cwd directory itself, no upward traversal
+const config = await loadOxfmtConfig({
+  editorconfig: { onlyCwd: true },
+})
+```
+
 ### Disable Caching
 
 ```ts
@@ -95,13 +136,13 @@ console.log(configPath) // '/path/to/.oxfmtrc.json' or undefined
 
 ### `loadOxfmtConfig(options?)`
 
-Load and parse oxfmt configuration file.
+Load and parse oxfmt configuration files, then merge supported `.editorconfig` fields into the returned result.
 
 **Parameters:**
 
 - `options` - Optional configuration object
 
-**Returns:** `Promise<FormatOptions>` - Parsed oxfmt configuration object. Returns empty object `{}` if no config file is found.
+**Returns:** `Promise<FormatOptions>` - Parsed and merged oxfmt configuration object. Returns empty object `{}` if no supported config file is found.
 
 **Throws:** Error if config file exists but cannot be parsed.
 
@@ -151,6 +192,21 @@ Enable in-memory caching for both path resolution and parsed config contents. Wh
 
 Set to `false` to force reload from disk on every call.
 
+### `editorconfig`
+
+- **Type:** `boolean | EditorconfigOption`
+- **Default:** `true`
+
+Control how `.editorconfig` files are read and merged:
+
+- **`true`** — Read and merge the nearest `.editorconfig`, walking up from the config file's directory (or `cwd` when no config path is given).
+- **`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. |
+
 ## Config File Discovery
 
 When `configPath` is not provided, the loader automatically searches for config files:
@@ -159,10 +215,14 @@ When `configPath` is not provided, the loader automatically searches for config
 2. **Supported filenames:**
    - `.oxfmtrc.json`
    - `.oxfmtrc.jsonc`
+
+- `oxfmt.config.ts`
+
 3. **Stops when:**
    - A valid config file is found
    - Reaches the filesystem root
-4. **Returns:** Empty object `{}` if no config file is found
+4. **EditorConfig:** The nearest `.editorconfig` is also resolved and merged into the returned result
+5. **Returns:** Empty object `{}` if no config file is found
 
 ## Supported Config Formats
 
@@ -191,10 +251,46 @@ JSON with comments support:
   /* Code style preferences */
   "useTabs": false,
   "semi": true,
-  "singleQuote": true
+  "singleQuote": true,
 }
 ```
 
+### TypeScript (`oxfmt.config.ts`)
+
+```ts
+export default {
+  printWidth: 100,
+  tabWidth: 2,
+}
+```
+
+## `.editorconfig` Support
+
+The loader reads the nearest `.editorconfig` file and maps the subset of fields that oxfmt supports:
+
+- `end_of_line` → `endOfLine`
+- `indent_style` → `useTabs`
+- `indent_size` / `tab_width` → `tabWidth`
+- `max_line_length` → `printWidth`
+- `insert_final_newline` → `insertFinalNewline`
+
+Glob sections such as `[*.ts]` are converted into returned `overrides` entries.
+
+## Precedence
+
+The merged result follows this order:
+
+1. Root-level values from the nearest `.editorconfig`
+2. Root-level values from `.oxfmtrc.json`, `.oxfmtrc.jsonc`, or `oxfmt.config.ts`
+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.
+
+## Limitations
+
+`loadOxfmtConfig()` returns a static `OxfmtOptions` object. That means `.editorconfig` support is represented as a merged config shape, 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.
+
 ## Error Handling
 
 ```ts
@@ -218,7 +314,7 @@ The caching system maintains two separate caches:
 **Cache keys are based on:**
 
 - `cwd` + `configPath` for path resolution
-- Resolved file path for config content
+- Resolved oxfmt path and resolved `.editorconfig` path for config content
 
 **Cache invalidation:**
 

package/dist/index.d.mts

@@ -1,10 +1,22 @@
-import { FormatOptions } from "oxfmt";
+import { FormatConfig } from "oxfmt";
 
 //#region src/types.d.ts
+/**
+ * Object-form editorconfig option, enabling fine-grained control.
+ */
+interface EditorconfigOption {
+  /**
+   * When `true`, only look for `.editorconfig` in the `cwd` directory itself
+   * (no upward traversal).
+   *
+   * @default false
+   */
+  onlyCwd?: boolean;
+}
 /**
  * Format option override for a single matching rule
  */
-interface FormatOptionOverride {
+interface OxfmtConfigOverride {
   /**
    * Glob patterns to match files
    */
@@ -16,7 +28,7 @@ interface FormatOptionOverride {
   /**
    * Format options to apply
    */
-  options?: FormatOptions;
+  options?: FormatConfig;
 }
 interface Options {
   /**
@@ -31,18 +43,47 @@ interface Options {
    * Whether to use cache
    */
   useCache?: boolean;
+  /**
+   * Control `.editorconfig` reading.
+   * - `true` (default): read and merge `.editorconfig`, walking up from the config
+   *   file's directory (or `cwd` when no config path is given).
+   * - `false`: disable `.editorconfig` reading entirely.
+   * - `EditorconfigOption`: enable with additional settings (e.g. `onlyCwd`).
+   *
+   * @default true
+   */
+  editorconfig?: boolean | EditorconfigOption;
 }
 /**
  * Final oxfmt options (including overrides)
  */
-interface OxfmtOptions extends FormatOptions {
+interface OxfmtOptions extends FormatConfig {
+  /**
+   * Ignore files matching these glob patterns
+   * Patterns are based on the location of the Oxfmt configuration file
+   */
+  ignorePatterns?: string[];
   /**
    * Array of format option overrides
    */
-  overrides?: FormatOptionOverride[];
+  overrides?: OxfmtConfigOverride[];
 }
+/**
+ * @deprecated Use `OxfmtConfigOverride` instead
+ */
+type FormatOptionOverride = OxfmtConfigOverride;
 //#endregion
 //#region src/core.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 (absolute or relative to cwd).
+ * @returns Absolute path to the config file, or undefined when not found.
+ */
+declare function resolveOxfmtrcPath(cwd: string, configPath?: string): Promise<string | undefined>;
 /**
  * Load oxfmt configuration: resolve the file path, then read and parse it.
  * Caching is enabled by default; pass `useCache: false` to force a re-read.
@@ -57,15 +98,5 @@ interface OxfmtOptions extends FormatOptions {
  * ```
  */
 declare function loadOxfmtConfig(options?: Options): Promise<OxfmtOptions>;
-/**
- * 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 (absolute or relative to cwd).
- * @returns Absolute path to the config file, or undefined when not found.
- */
-declare function resolveOxfmtrcPath(cwd: string, configPath?: string): Promise<string | undefined>;
 //#endregion
-export { FormatOptionOverride, Options, OxfmtOptions, loadOxfmtConfig, resolveOxfmtrcPath };
+export { EditorconfigOption, FormatOptionOverride, Options, OxfmtConfigOverride, OxfmtOptions, loadOxfmtConfig, resolveOxfmtrcPath };

package/dist/index.mjs

@@ -1,71 +1,132 @@
 import { readFile, stat } from "node:fs/promises";
-import { isAbsolute, join } from "node:path";
+import { dirname, isAbsolute, join, relative } from "node:path";
 import process from "node:process";
+import { interopDefault } from "@ntnyq/utils";
 import { parse } from "jsonc-parser";
-
+import { parseBuffer } from "editorconfig";
 //#region src/constants.ts
 /**
 * Supported configuration files for oxfmt.
 * @see https://oxc.rs/docs/guide/usage/formatter/config.html#oxfmtrc-json-c
 */
-const OXFMT_CONFIG_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
-
-//#endregion
-//#region src/core.ts
-const resolveCache = /* @__PURE__ */ new Map();
-const configCache = /* @__PURE__ */ new Map();
+const OXFMT_CONFIG_FILES = [
+	".oxfmtrc.json",
+	".oxfmtrc.jsonc",
+	"oxfmt.config.ts"
+];
 /**
-* Load oxfmt configuration: resolve the file path, then read and parse it.
-* Caching is enabled by default; pass `useCache: false` to force a re-read.
-*
-* @param options - Optional loader settings (cwd, configPath, useCache).
-* @returns Parsed oxfmt OxfmtOptions or an empty object when missing.
-* @throws {Error} when the config file exists but cannot be parsed.
-*
-* @example
-* ```ts
-* const config = await loadOxfmtConfig({ cwd: '/project' })
-* ```
+* Supported EditorConfig filename.
 */
-async function loadOxfmtConfig(options = {}) {
-	const useCache = options.useCache !== false;
-	const cwd = options.cwd || process.cwd();
-	const resolveKey = getResolveCacheKey(cwd, options.configPath);
-	const resolvedPath = useCache ? await cachePromise(resolveCache, resolveKey, () => resolveOxfmtrcPath(cwd, options.configPath)) : await resolveOxfmtrcPath(cwd, options.configPath);
-	if (!resolvedPath) {
-		if (!useCache) return {};
-		return cachePromise(configCache, getConfigCacheKey(resolvedPath, resolveKey), () => Promise.resolve({}));
-	}
-	const loadTask = () => readConfigFromFile(resolvedPath).catch((err) => {
-		throw new Error(`Failed to parse oxfmt configuration file at ${resolvedPath}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
-	});
-	if (!useCache) return loadTask();
-	return cachePromise(configCache, getConfigCacheKey(resolvedPath, resolveKey), loadTask);
-}
+const EDITORCONFIG_FILE = ".editorconfig";
 /**
-* 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 (absolute or relative to cwd).
-* @returns Absolute path to the config file, or undefined when not found.
+* Sections that apply globally and can be merged into root-level oxfmt options.
 */
-async function resolveOxfmtrcPath(cwd, configPath) {
-	if (configPath) return isAbsolute(configPath) ? configPath : join(cwd, configPath);
-	let currentDir = cwd;
+const EDITORCONFIG_GLOBAL_SECTION_NAMES = ["*", "**"];
+//#endregion
+//#region src/editorconfig.ts
+function getEditorconfigResolveCacheKey(resolveKey) {
+	return `editorconfig::${resolveKey}`;
+}
+function getEditorconfigSearchDir(cwd, configPath) {
+	if (!configPath) return cwd;
+	return dirname(isAbsolute(configPath) ? configPath : join(cwd, configPath));
+}
+function mergeRootOptions(oxfmtConfig, editorconfigRootOptions) {
+	return {
+		...editorconfigRootOptions,
+		...oxfmtConfig
+	};
+}
+function mergeOverrides(oxfmtOverrides, editorconfigOverrides) {
+	const mergedOverrides = [...editorconfigOverrides, ...oxfmtOverrides || []];
+	return mergedOverrides.length > 0 ? mergedOverrides : void 0;
+}
+async function resolveEditorconfigPath(startDir, onlyCwd = false) {
+	let currentDir = startDir;
 	while (true) {
-		for (const filename of OXFMT_CONFIG_FILES) {
-			const configFilePath = join(currentDir, filename);
-			try {
-				if ((await stat(configFilePath)).isFile()) return configFilePath;
-			} catch {}
-		}
+		const editorconfigPath = join(currentDir, EDITORCONFIG_FILE);
+		try {
+			if ((await stat(editorconfigPath)).isFile()) return editorconfigPath;
+		} catch {}
+		if (onlyCwd) break;
 		const parentDir = join(currentDir, "..");
 		if (parentDir === currentDir) break;
 		currentDir = parentDir;
 	}
 }
+function toPosixPath(path) {
+	return path.replaceAll("\\", "/");
+}
+function isEditorconfigGlobalSection(sectionName) {
+	return Boolean(sectionName && EDITORCONFIG_GLOBAL_SECTION_NAMES.includes(sectionName));
+}
+function parseEditorconfigBoolean(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+}
+function parseEditorconfigEndOfLine(value) {
+	if (value === "lf" || value === "crlf" || value === "cr") return value;
+}
+function parseEditorconfigTabWidth(section) {
+	const indentSize = section["indent_size"];
+	const tabWidth = section["tab_width"];
+	if (indentSize && indentSize !== "unset" && indentSize !== "tab") {
+		const parsedIndentSize = Number(indentSize);
+		if (Number.isFinite(parsedIndentSize)) return parsedIndentSize;
+	}
+	if (tabWidth && tabWidth !== "unset") {
+		const parsedTabWidth = Number(tabWidth);
+		if (Number.isFinite(parsedTabWidth)) return parsedTabWidth;
+	}
+}
+function mapEditorconfigSectionToOptions(section) {
+	const options = {};
+	const endOfLine = parseEditorconfigEndOfLine(section["end_of_line"]);
+	if (endOfLine) options.endOfLine = endOfLine;
+	if (section["indent_style"] === "tab") options.useTabs = true;
+	else if (section["indent_style"] === "space") options.useTabs = false;
+	const tabWidth = parseEditorconfigTabWidth(section);
+	if (typeof tabWidth === "number") options.tabWidth = tabWidth;
+	if (section["max_line_length"] && section["max_line_length"] !== "unset") {
+		const parsedPrintWidth = Number(section["max_line_length"]);
+		if (Number.isFinite(parsedPrintWidth)) options.printWidth = parsedPrintWidth;
+	}
+	const insertFinalNewline = parseEditorconfigBoolean(section["insert_final_newline"]);
+	if (typeof insertFinalNewline === "boolean") options.insertFinalNewline = insertFinalNewline;
+	return options;
+}
+function rebaseEditorconfigPattern(pattern, editorconfigDir, anchorDir) {
+	const relativePrefix = toPosixPath(relative(anchorDir, editorconfigDir));
+	if (!relativePrefix || relativePrefix === ".") return pattern;
+	return `${relativePrefix}/${pattern.replace(/^\//, "")}`;
+}
+async function readEditorconfigFromFile(editorconfigPath, anchorDir) {
+	const parsedSections = parseBuffer(await readFile(editorconfigPath));
+	const editorconfigDir = dirname(editorconfigPath);
+	const rootOptions = {};
+	const overrides = [];
+	for (const [sectionName, sectionBody] of parsedSections) {
+		if (!sectionName) continue;
+		const mappedOptions = mapEditorconfigSectionToOptions(sectionBody);
+		if (Object.keys(mappedOptions).length === 0) continue;
+		if (isEditorconfigGlobalSection(sectionName)) {
+			Object.assign(rootOptions, mappedOptions);
+			continue;
+		}
+		overrides.push({
+			files: [rebaseEditorconfigPattern(sectionName, editorconfigDir, anchorDir)],
+			options: mappedOptions
+		});
+	}
+	return {
+		overrides,
+		rootOptions
+	};
+}
+//#endregion
+//#region src/core.ts
+const resolveCache = /* @__PURE__ */ new Map();
+const configCache = /* @__PURE__ */ new Map();
 /**
 * Return a cached promise by key, creating and storing it on miss; failures clear the entry.
 *
@@ -77,9 +138,9 @@ async function resolveOxfmtrcPath(cwd, configPath) {
 function cachePromise(cache, key, factory) {
 	const cached = cache.get(key);
 	if (cached) return cached;
-	const task = factory().catch((err) => {
+	const task = factory().catch((error) => {
 		cache.delete(key);
-		throw err;
+		throw error;
 	});
 	cache.set(key, task);
 	return task;
@@ -88,11 +149,36 @@ function cachePromise(cache, key, factory) {
 * Build a cache key for config content; prefixes missing entries with `missing:`.
 *
 * @param resolvedPath - Resolved config path or undefined when missing.
+* @param editorconfigPath - Resolved editorconfig path or undefined when missing.
 * @param resolveKey - Key used for path resolution caching.
 * @returns Cache key for config content.
 */
-function getConfigCacheKey(resolvedPath, resolveKey) {
-	return resolvedPath || `missing:${resolveKey}`;
+function getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey) {
+	return `${resolvedPath || `missing-oxfmt:${resolveKey}`}::${editorconfigPath || `missing-editorconfig:${resolveKey}`}`;
+}
+/**
+* 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 (absolute or relative to cwd).
+* @returns Absolute path to the config file, or undefined when not found.
+*/
+async function resolveOxfmtrcPath(cwd, configPath) {
+	if (configPath) return isAbsolute(configPath) ? configPath : join(cwd, configPath);
+	let currentDir = cwd;
+	while (true) {
+		for (const filename of OXFMT_CONFIG_FILES) {
+			const configFilePath = join(currentDir, filename);
+			try {
+				if ((await stat(configFilePath)).isFile()) return configFilePath;
+			} catch {}
+		}
+		const parentDir = join(currentDir, "..");
+		if (parentDir === currentDir) break;
+		currentDir = parentDir;
+	}
 }
 /**
 * Build a cache key for path resolution (cwd + configPath).
@@ -105,16 +191,65 @@ function getResolveCacheKey(cwd, configPath) {
 	return `${cwd}::${configPath || ""}`;
 }
 /**
-* Read and parse config file, supporting JSON and JSONC.
+* Read and parse config file, supporting JSON, JSONC, and TypeScript/JavaScript.
 *
 * @param resolvedPath - Absolute path to the config file.
 * @returns Parsed OxfmtOptions object.
 */
 async function readConfigFromFile(resolvedPath) {
-	const content = await readFile(resolvedPath, "utf-8");
+	if (resolvedPath.endsWith(".ts")) {
+		const mod = await (await interopDefault(import("jiti")))(import.meta.url).import(resolvedPath);
+		return mod["default"] ?? mod;
+	}
+	const content = await readFile(resolvedPath, "utf8");
 	if (resolvedPath.endsWith(".jsonc")) return parse(content);
 	return JSON.parse(content);
 }
-
+/**
+* Load oxfmt configuration: resolve the file path, then read and parse it.
+* Caching is enabled by default; pass `useCache: false` to force a re-read.
+*
+* @param options - Optional loader settings (cwd, configPath, useCache).
+* @returns Parsed oxfmt OxfmtOptions or an empty object when missing.
+* @throws {Error} when the config file exists but cannot be parsed.
+*
+* @example
+* ```ts
+* const config = await loadOxfmtConfig({ cwd: '/project' })
+* ```
+*/
+async function loadOxfmtConfig(options = {}) {
+	const useCache = options.useCache !== false;
+	const cwd = options.cwd || process.cwd();
+	const editorconfig = options.editorconfig ?? true;
+	const useEditorconfig = editorconfig !== false;
+	const onlyCwd = useEditorconfig && typeof editorconfig === "object" ? editorconfig.onlyCwd ?? false : false;
+	const resolveKey = getResolveCacheKey(cwd, options.configPath);
+	const editorconfigSearchDir = getEditorconfigSearchDir(cwd, options.configPath);
+	const editorconfigResolveKey = getEditorconfigResolveCacheKey(resolveKey);
+	const resolvedPath = useCache ? await cachePromise(resolveCache, resolveKey, () => resolveOxfmtrcPath(cwd, options.configPath)) : await resolveOxfmtrcPath(cwd, 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 loadTask = async () => {
+		const oxfmtConfig = resolvedPath ? await readConfigFromFile(resolvedPath).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;
+		const editorconfigData = await readEditorconfigFromFile(editorconfigPath, anchorDir);
+		const mergedConfig = mergeRootOptions(oxfmtConfig, editorconfigData.rootOptions);
+		const mergedOverrides = mergeOverrides(oxfmtConfig.overrides, editorconfigData.overrides);
+		if (!mergedOverrides) return mergedConfig;
+		return {
+			...mergedConfig,
+			overrides: mergedOverrides
+		};
+	};
+	if (!resolvedPath && !editorconfigPath) {
+		if (!useCache) return {};
+		return cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), () => Promise.resolve({}));
+	}
+	if (!useCache) return loadTask();
+	return cachePromise(configCache, getConfigCacheKey(resolvedPath, editorconfigPath, resolveKey), loadTask);
+}
 //#endregion
-export { loadOxfmtConfig, resolveOxfmtrcPath };
+export { loadOxfmtConfig, resolveOxfmtrcPath };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "load-oxfmt-config",
-  "type": "module",
-  "version": "0.1.1",
-  "description": "Load .oxfmtrc.json(c) for oxfmt.",
+  "version": "0.2.1",
+  "description": "Load oxfmt config files and merge supported .editorconfig options.",
   "keywords": [
+    "editorconfig",
     "jsonc-parser",
     "load-config",
     "load-oxfmt-config",
@@ -11,16 +11,23 @@
     "oxfmt",
     "oxfmtrc"
   ],
+  "homepage": "https://github.com/ntnyq/load-oxfmt-config#readme",
+  "bugs": {
+    "url": "https://github.com/ntnyq/load-oxfmt-config/issues"
+  },
   "license": "MIT",
   "author": {
     "name": "ntnyq",
     "email": "ntnyq13@gmail.com"
   },
-  "homepage": "https://github.com/ntnyq/load-oxfmt-config#readme",
   "repository": "ntnyq/load-oxfmt-config",
-  "bugs": {
-    "url": "https://github.com/ntnyq/load-oxfmt-config/issues"
-  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -28,46 +35,41 @@
       "default": "./dist/index.mjs"
     }
   },
-  "main": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
-  "files": [
-    "dist"
-  ],
   "publishConfig": {
     "access": "public"
   },
-  "sideEffects": false,
-  "peerDependencies": {
-    "oxfmt": "0.x"
-  },
   "dependencies": {
+    "@ntnyq/utils": "^0.11.2",
+    "editorconfig": "^3.0.2",
+    "jiti": "^2.6.1",
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@ntnyq/eslint-config": "^6.0.0-beta.7",
     "@ntnyq/tsconfig": "^3.1.0",
-    "@types/node": "^25.2.2",
-    "@typescript/native-preview": "^7.0.0-dev.20260208.1",
-    "bumpp": "^10.4.1",
-    "eslint": "^10.0.0",
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260326.1",
+    "bumpp": "^11.0.1",
     "husky": "^9.1.7",
     "nano-staged": "^0.9.0",
     "npm-run-all2": "^8.0.4",
-    "oxfmt": "^0.28.0",
-    "tsdown": "^0.20.3",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.18"
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "tsdown": "^0.21.5",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "oxfmt": ">=0.41.0"
   },
   "nano-staged": {
-    "*.{js,ts,mjs,cjs,md,vue,yml,yaml,toml,json}": "eslint --fix",
+    "*.{js,ts,mjs,tsx}": "oxlint --fix",
     "*": "oxfmt --no-error-on-unmatched-pattern"
   },
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",
-    "lint": "eslint",
     "format": "oxfmt",
     "format:check": "oxfmt --check",
+    "lint": "oxlint",
     "release": "run-s release:check release:version",
     "release:check": "run-s format:check lint typecheck test",
     "release:version": "bumpp",