@isentinel/eslint-config 6.1.0 → 6.2.0

package/dist/oxlint.d.mts

@@ -25140,6 +25140,20 @@ interface OptionsConfig extends OptionsComponentExtensions, OptionsProjectType {
    * @requires eslint-plugin-eslint-plugin
    */
   eslintPlugin?: boolean | OptionsOverrides;
+  /**
+   * Where formatting runs.
+   *
+   * - `"eslint"`: oxfmt runs inside the linter as the `oxfmt/oxfmt` rule.
+   * - `"standalone"`: oxfmt runs as its own tool (`oxfmt`, with an
+   *   `oxfmt.config.ts` built by `isentinelOxfmt` from
+   *   `@isentinel/eslint-config/oxfmt`). The linter keeps the
+   *   formatter-conflict disables and still reads the oxfmt config so
+   *   width-aware rules agree with it, but enables `oxfmt/oxfmt` nowhere.
+   *   Lua formatting (Stylua) stays in ESLint, as oxfmt does not format Lua.
+   *
+   * @default "eslint"
+   */
+  formatter?: "eslint" | "standalone";
   /**
    * Use external formatters to format files.
    *

package/dist/oxlint.mjs

@@ -7,6 +7,7 @@ import path from "node:path";
 import process from "node:process";
 import { getStaticYAMLValue, parseYAML } from "yaml-eslint-parser";
 import { findUpSync } from "find-up-simple";
+import { isMainThread } from "node:worker_threads";
 import { minVersion } from "semver";
 import { pathToFileURL } from "node:url";
 import globals from "globals";
@@ -5236,10 +5237,19 @@ const GLOB_SRC_EXTENSIONS = [
 	"cjs"
 ];
 [...GLOB_SRC_EXTENSIONS];
+const GLOB_JS = "**/*.{,c,m}js";
 const GLOB_JSX = "**/*.{,c,m}jsx";
+const GLOB_TS = "**/*.{,c,m}ts";
 const GLOB_TSX = "**/*.{,c,m}tsx";
 const GLOB_DTS = "**/*.d.{,c,m}ts";
 const GLOB_BIN = ["**/bin/**/*", `**/bin.${GLOB_SRC_EXT}`];
+const GLOB_CSS = "**/*.css";
+const GLOB_POSTCSS = "**/*.{p,post}css";
+const GLOB_LESS = "**/*.less";
+const GLOB_SCSS = "**/*.scss";
+const GLOB_ALL_JSON = "**/*.json{,5,c}";
+const GLOB_MARKDOWN = "**/*.md";
+const GLOB_YAML = "**/*.y{,a}ml";
 /**
 * Type tests (`expectTypeOf` / `assertType`), run by Vitest's `typecheck`
 * mode. They are test files, but assert nothing at runtime.
@@ -5414,6 +5424,79 @@ function resolvePrettierSettings(prettierOptions = {}, cwd = process.cwd()) {
 		...prettierOptions
 	};
 }
+/**
+* Replace `printWidth` and `tabWidth` in the formatting settings with the
+* values oxfmt really uses.
+*
+* `flawless/arrow-return-style` hands `printWidth` to oxfmt to predict its
+* output (`useOxfmt.printWidth`), so it must match the width oxfmt formats
+* with, or `--fix` ping-pongs. An oxfmt config can set a width that differs
+* from the Prettier-shaped settings, so the oxfmt value wins.
+*
+* @template T - The settings shape.
+* @param settings - The resolved formatting settings.
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns The settings with oxfmt's widths.
+*/
+function withOxfmtWidths(settings, { printWidth, tabWidth }) {
+	return {
+		...settings,
+		...typeof printWidth === "number" ? { printWidth } : {},
+		...typeof tabWidth === "number" ? { tabWidth } : {}
+	};
+}
+/**
+* The indent oxfmt writes.
+*
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns `"tab"`, or the number of spaces.
+*/
+function oxfmtIndent({ tabWidth, useTabs }) {
+	if (useTabs !== false) return "tab";
+	return typeof tabWidth === "number" ? tabWidth : 2;
+}
+/**
+* Default the stylistic `indent` and `quotes` to what oxfmt writes, so the
+* stylistic rules and oxfmt agree. Explicit `stylistic` values win.
+*
+* @param stylistic - The user's stylistic options.
+* @param oxfmtOptions - The effective oxfmt options.
+* @returns The stylistic options with oxfmt's indent and quotes.
+*/
+function withOxfmtStyle(stylistic, oxfmtOptions) {
+	return {
+		indent: oxfmtIndent(oxfmtOptions),
+		quotes: oxfmtOptions["singleQuote"] === true ? "single" : "double",
+		...stylistic
+	};
+}
+/**
+* Turn the nearest `.editorconfig`'s sections into oxfmt overrides, the way
+* the `oxfmt/oxfmt` rule's config loader does: `[*]` is skipped (it feeds the
+* root options), and each other section becomes an override whose globs are
+* relative to `cwd`. A key set in the oxfmt config root wins over the
+* sections.
+*
+* @param cwd - The config directory.
+* @param root - The oxfmt config root options.
+* @returns The overrides, in file order.
+*/
+function editorConfigOverrides(cwd = process.cwd(), root = {}) {
+	for (const directory of ancestorDirectories(cwd)) {
+		const contents = readFileOrUndefined(path.join(directory, ".editorconfig"));
+		if (contents === void 0) continue;
+		const prefix = path.relative(cwd, directory).split(path.sep).join("/");
+		return parseEditorConfig(contents).sections.flatMap(({ pattern, properties }) => {
+			const options = Object.fromEntries(Object.entries(editorConfigToOxfmt(properties)).filter(([key]) => !Object.hasOwn(root, key)));
+			if (pattern === "*" || Object.keys(options).length === 0) return [];
+			return [{
+				files: [prefix === "" ? pattern : `${prefix}/${pattern.replace(LEADING_SLASH, "")}`],
+				options
+			}];
+		});
+	}
+	return [];
+}
 function readFileOrUndefined(filePath) {
 	try {
 		return fs.readFileSync(filePath, "utf-8");
@@ -5593,6 +5676,31 @@ function resolveEditorConfigOptions(cwd) {
 	}
 	return editorConfigToPrettier(properties);
 }
+/**
+* Map one `.editorconfig` section to oxfmt options, as the rule's config
+* loader does.
+*
+* @param properties - The section's properties.
+* @returns The oxfmt options it sets.
+*/
+function editorConfigToOxfmt(properties) {
+	const options = {};
+	const endOfLine = properties["end_of_line"];
+	if (endOfLine === "cr" || endOfLine === "crlf" || endOfLine === "lf") options["endOfLine"] = endOfLine;
+	const indentStyle = properties["indent_style"];
+	if (indentStyle === "tab" || indentStyle === "space") options["useTabs"] = indentStyle === "tab";
+	const quoteType = properties["quote_type"];
+	if (quoteType === "single" || quoteType === "double") options["singleQuote"] = quoteType === "single";
+	const indentSize = Number(properties["indent_size"]);
+	const tabWidth = Number(properties["tab_width"]);
+	if (options["useTabs"] === false && properties["indent_size"] && Number.isFinite(indentSize)) options["tabWidth"] = indentSize;
+	else if (properties["tab_width"] && Number.isFinite(tabWidth)) options["tabWidth"] = tabWidth;
+	const printWidth = Number(properties["max_line_length"]);
+	if (properties["max_line_length"] && Number.isFinite(printWidth)) options["printWidth"] = printWidth;
+	const finalNewline = properties["insert_final_newline"];
+	if (finalNewline === "true" || finalNewline === "false") options["insertFinalNewline"] = finalNewline === "true";
+	return options;
+}
 //#endregion
 //#region src/rules/oxfmt.ts
 const UNSUPPORTED_PRETTIER_KEYS = /* @__PURE__ */ new Set([
@@ -5646,11 +5754,30 @@ function migratePrettierOptions(prettierOptions) {
 	for (const [key, value] of Object.entries(prettierOptions)) {
 		if (UNSUPPORTED_PRETTIER_KEYS.has(key)) continue;
 		if (key === "endOfLine" && value === "auto") continue;
-		oxfmtOptions[key] = value;
+		oxfmtOptions[key] = key === "overrides" ? migratePrettierOverrides(value) : value;
 	}
 	return oxfmtOptions;
 }
 /**
+* Migrate Prettier `overrides`: oxfmt wants `files` as an array, and the
+* nested options migrated like the root ones.
+*
+* @param overrides - The `overrides` value, of unknown shape.
+* @returns The overrides in oxfmt's shape; empty when not an array.
+*/
+function migratePrettierOverrides(overrides) {
+	if (!Array.isArray(overrides)) return [];
+	return overrides.flatMap((override) => {
+		if (typeof override !== "object" || override === null) return [];
+		const { excludeFiles, files, options } = override;
+		return [{
+			...excludeFiles === void 0 ? {} : { excludeFiles: stringsOf(excludeFiles) },
+			files: stringsOf(files),
+			options: typeof options === "object" && options !== null ? migratePrettierOptions(options) : {}
+		}];
+	});
+}
+/**
 * Build the effective oxfmt options shared between the ESLint and oxlint
 * factories.
 *
@@ -5666,6 +5793,9 @@ function buildOxfmtOptions({ oxfmtConfigOptions = {}, oxfmtOptions, prettierOpti
 		...oxfmtOptions
 	};
 }
+function stringsOf(value) {
+	return [value].flat().filter((item) => typeof item === "string");
+}
 //#endregion
 //#region src/rules/react.ts
 const DOM_IMPORT_MESSAGE = "Import from react-testing-library-lua instead; it re-exports the DOM utilities, and eslint-plugin-testing-library only detects one module per file.";
@@ -5878,7 +6008,9 @@ function isDomImportRestriction(value, domPackage) {
 function isObjectStyleRestriction(value) {
 	return isRecord$1(value) && !("name" in value);
 }
-createRequire(import.meta.url);
+//#endregion
+//#region src/utils.ts
+const require$2 = createRequire(import.meta.url);
 /**
 * Synchronous {@link findWorkspaceRoot}, for the oxlint factory.
 *
@@ -6108,27 +6240,168 @@ function environmentMatcher(name, pattern, { noTty = false } = {}) {
 		return value !== void 0 && pattern.test(value);
 	};
 }
-const OXFMT_CONFIG_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
+/** JSON oxfmt config files oxfmt discovers. */
+const OXFMT_RC_FILES = [".oxfmtrc.json", ".oxfmtrc.jsonc"];
 /**
-* Resolve oxfmt configuration from `.oxfmtrc.json` or `.oxfmtrc.jsonc`,
-* synchronously. Used by the (synchronous) oxlint factory.
+* Oxfmt config modules oxfmt discovers. It loads other module extensions only
+* through `--config`, never by search.
+*/
+const OXFMT_CONFIG_MODULES = ["oxfmt.config.ts", "oxfmt.config.mts"];
+OXFMT_CONFIG_MODULES[0];
+/** Every file name oxfmt discovers. One directory may hold only one of them. */
+const OXFMT_CONFIG_NAMES = [...OXFMT_RC_FILES, ...OXFMT_CONFIG_MODULES];
+/** The extensions of the JS/TS files ESLint and oxlint format. */
+const SCRIPT_EXTENSIONS = [
+	"cjs",
+	"cts",
+	"js",
+	"jsx",
+	"mjs",
+	"mts",
+	"ts",
+	"tsx"
+];
+/** The extensions of the Markdown files ESLint lints code blocks in. */
+const MARKDOWN_EXTENSIONS = ["md"];
+const LEADING_DOT_SLASH = /^\.\//;
+/** Set once a process has warned about a JS/TS width override. */
+const WARNED_SCRIPT_OVERRIDE = Symbol.for("@isentinel/eslint-config/oxfmt-override-warned");
+/** Set once a process has warned about options standalone oxfmt ignores. */
+const WARNED_STANDALONE = Symbol.for("@isentinel/eslint-config/standalone-options-warned");
+const GLOB_MAGIC = /[*?[\]{}]/;
+/**
+* List the oxfmt config files in one directory, without walking up.
+*
+* @param directory - Directory to check.
+* @returns The file names found, sorted.
+*/
+function oxfmtConfigNamesIn(directory) {
+	return OXFMT_CONFIG_NAMES.filter((name) => fs.existsSync(path.join(directory, name))).sort();
+}
+/**
+* Find the oxfmt config the way oxfmt does: walk up from `cwd` to the
+* filesystem root and take the first directory that holds one. Like oxfmt,
+* refuse a directory that holds more than one.
+*
+* @param cwd - Directory to start from.
+* @returns The config file, if any.
+* @throws When one directory holds more than one oxfmt config file.
+*/
+function findOxfmtConfig(cwd = process.cwd()) {
+	let directory = path.resolve(cwd);
+	for (;;) {
+		const [first, second] = oxfmtConfigNamesIn(directory);
+		if (second !== void 0) throw new Error(`[@isentinel/eslint-config] Both '${first}' and '${second}' found in ${directory}. Keep one oxfmt config file.`);
+		if (first !== void 0) return {
+			isModule: OXFMT_CONFIG_MODULES.some((name) => name === first),
+			path: path.join(directory, first)
+		};
+		const parent = path.dirname(directory);
+		if (parent === directory) return;
+		directory = parent;
+	}
+}
+/**
+* The overrides that set `printWidth` or `tabWidth` for Markdown files.
 *
-* @returns The oxfmt configuration options, or an empty object if none found.
+* @param overrides - The config's `overrides`.
+* @returns Each such override's scope and widths, in order.
+*/
+function markdownOverridesOf(overrides) {
+	if (!Array.isArray(overrides)) return [];
+	return overrides.flatMap((override) => {
+		if (!isRecord$1(override) || !overrideMatches(override, MARKDOWN_EXTENSIONS)) return [];
+		const widths = widthsOf(override["options"]);
+		return Object.keys(widths).length > 0 ? [{
+			...scopeOf(override),
+			widths
+		}] : [];
+	});
+}
+/**
+* Where an override applies: its `files`, minus its `excludeFiles` and any
+* negated glob in `files`.
+*
+* @param override - One override.
+* @returns Its scope.
+*/
+function scopeOf(override) {
+	const strings = (value) => {
+		return [value].flat().filter((glob) => typeof glob === "string");
+	};
+	const globs = strings(override["files"]);
+	return {
+		excludeFiles: [...strings(override["excludeFiles"]), ...globs.filter((glob) => glob.startsWith("!")).map((glob) => glob.slice(1))],
+		files: globs.filter((glob) => !glob.startsWith("!"))
+	};
+}
+/**
+* Warn, at most once per process, about factory options that do not reach
+* standalone oxfmt: it formats with `oxfmt.config.ts` alone.
+*
+* @param options - The factory options.
+* @param options.componentExts - Oxfmt formats only the extensions
+*   `isentinelOxfmt` is given.
+* @param options.formatters - Any value but `true` is ignored by oxfmt.
+* @param options.gitignore - Custom ignore files, or `false`, do not reach
+*   oxfmt.
+* @param options.ignores - User ignores do not reach oxfmt.
+*/
+function warnStandaloneOptions({ componentExts, formatters, gitignore, ignores }) {
+	const state = globalThis;
+	if (!isMainThread || state[WARNED_STANDALONE] === true || process.env["ISENTINEL_QUIET_CONFIG_WARNINGS"] === "1") return;
+	const names = [
+		formatters !== void 0 && formatters !== true ? "formatters" : void 0,
+		Array.isArray(componentExts) && componentExts.length > 0 ? "componentExts" : void 0,
+		ignores === void 0 || Array.isArray(ignores) && ignores.length === 0 ? void 0 : "ignores",
+		gitignore === false || isRecord$1(gitignore) ? "gitignore" : void 0
+	].filter((name) => name !== void 0);
+	if (names.length > 0) {
+		state[WARNED_STANDALONE] = true;
+		console.warn(`[@isentinel/eslint-config] With formatter: "standalone", oxfmt formats with oxfmt.config.ts alone, so these options do not change formatting: ${names.join(", ")}. Set the equivalent in isentinelOxfmt() (formatters, componentExts, ignorePatterns, format options).`);
+	}
+}
+/**
+* Warn, at most once per process, when an oxfmt override changes `printWidth`
+* or `tabWidth` for JS/TS files: ESLint and oxlint use the root values.
+*
+* @param overrides - The config's `overrides`.
+* @param source - The config file name.
+*/
+function warnScriptWidthOverrides(overrides, source) {
+	const state = globalThis;
+	if (state[WARNED_SCRIPT_OVERRIDE] === true || !Array.isArray(overrides)) return;
+	if (overrides.some((override) => {
+		if (!isRecord$1(override) || !isRecord$1(override["options"])) return false;
+		const { printWidth, tabWidth } = override["options"];
+		if (printWidth === void 0 && tabWidth === void 0) return false;
+		return overrideMatches(override, SCRIPT_EXTENSIONS);
+	})) {
+		state[WARNED_SCRIPT_OVERRIDE] = true;
+		console.warn(`[@isentinel/eslint-config] ${source} has an override that changes printWidth or tabWidth for JS/TS files. ESLint and oxlint use the root values for those files.`);
+	}
+}
+/**
+* Synchronous {@link resolveOxfmtConfig}, for the (synchronous) oxlint factory.
+* Loads a config module through jiti's synchronous API. Oxlint does not lint
+* Markdown code blocks, so it returns the format options alone.
+*
+* @returns The oxfmt format options, or an empty object if none found.
+* @throws When the config is ambiguous or cannot be loaded.
 */
 function resolveOxfmtConfigOptionsSync() {
-	for (const filename of OXFMT_CONFIG_FILES) {
-		const configPath = path.resolve(process.cwd(), filename);
-		try {
-			const content = fs.readFileSync(configPath, "utf-8");
-			const parsed = JSON.parse(content);
-			if (!isRecord$1(parsed)) continue;
-			const { $schema: _, ...config } = parsed;
-			return config;
-		} catch {
-			continue;
-		}
+	const config = findOxfmtConfig();
+	if (config === void 0) return {};
+	if (!config.isModule) return rcConfig(config.path, fs.readFileSync(config.path, "utf-8")).options;
+	let loaded;
+	try {
+		const { createJiti } = require$2("jiti");
+		const module = createJiti(import.meta.url, { moduleCache: false })(config.path);
+		loaded = isRecord$1(module) && "default" in module ? module["default"] : module;
+	} catch (err) {
+		throw loadError(config.path, err);
 	}
-	return {};
+	return moduleConfig(config.path, loaded).options;
 }
 /**
 * Override the severity of all rules in a rules object, preserving rule
@@ -6152,6 +6425,105 @@ function overrideRuleSeverity(rules, severity, excludeRules = /* @__PURE__ */ ne
 	}));
 }
 /**
+* Whether a glob can match a file with one of `extensions`, judged by the
+* extension of its last segment (`*.ts`, `*.{ts,tsx}`, `*.?ts`, `*`, ...).
+*
+* @param glob - An override `files` glob.
+* @param extensions - The extensions to look for.
+* @returns Whether it can match such a file.
+*/
+function globMatchesExtension(glob, extensions) {
+	const base = glob.split("/").at(-1) ?? glob;
+	const dot = base.lastIndexOf(".");
+	if (dot === -1) return base.includes("*");
+	const extension = base.slice(dot + 1);
+	if (!GLOB_MAGIC.test(extension)) return extensions.includes(extension);
+	return extensions.some((candidate) => path.matchesGlob(candidate, extension));
+}
+/**
+* Whether an oxfmt override can apply to a file with one of `extensions`.
+*
+* @param override - One entry of the config's `overrides`.
+* @param extensions - The extensions to look for.
+* @returns Whether its `files` can match such a file.
+*/
+function overrideMatches(override, extensions) {
+	return (Array.isArray(override["files"]) ? override["files"] : [override["files"]]).some((glob) => typeof glob === "string" && globMatchesExtension(glob, extensions));
+}
+function loadError(configPath, error) {
+	return new Error(`[@isentinel/eslint-config] Failed to load ${path.basename(configPath)}: ${String(error)}`, { cause: error });
+}
+/**
+* Whether a config override is an `.editorconfig` section that
+* `isentinelOxfmt` copied in: the same globs (anchored or not) and a subset
+* of its options.
+*
+* @param override - One config override.
+* @param sections - The `.editorconfig` sections, as overrides.
+* @returns Whether it mirrors one of them.
+*/
+function mirrorsSection(override, sections) {
+	if (!isRecord$1(override) || !isRecord$1(override["options"])) return false;
+	const { options } = override;
+	const files = [override["files"]].flat().map((glob) => typeof glob === "string" ? glob.replace(LEADING_DOT_SLASH, "") : glob);
+	return sections.some((section) => {
+		return section.files.length === files.length && section.files.every((glob, index) => glob === files[index]) && Object.entries(options).every(([key, value]) => section.options[key] === value);
+	});
+}
+/**
+* Turn a loaded oxfmt config into `oxfmt/oxfmt` rule options and the Markdown
+* widths. The rule takes format options only, so `$schema`, `ignorePatterns`
+* and `overrides` are dropped from the options.
+*
+* @param config - The loaded config.
+* @param config.$schema - Dropped.
+* @param config.ignorePatterns - Dropped; oxfmt applies them itself.
+* @param config.overrides - Dropped, after the width check; read for the
+*   Markdown widths.
+* @param configPath - The config file, for the warning.
+* @returns The format options and Markdown widths.
+*/
+function toResolvedConfig({ $schema: _schema, ignorePatterns: _ignorePatterns, overrides, ...options }, configPath) {
+	const sections = editorConfigOverrides(path.dirname(configPath));
+	const list = Array.isArray(overrides) ? overrides : [];
+	const copied = list.filter((override) => mirrorsSection(override, sections));
+	warnScriptWidthOverrides(copied, ".editorconfig");
+	warnScriptWidthOverrides(list.filter((override) => !copied.includes(override)), path.basename(configPath));
+	return {
+		markdownOverrides: markdownOverridesOf(overrides),
+		options,
+		overrides: Array.isArray(overrides) ? overrides : []
+	};
+}
+function moduleConfig(configPath, loaded) {
+	if (!isRecord$1(loaded)) throw loadError(configPath, /* @__PURE__ */ new TypeError("the default export is not an object"));
+	return toResolvedConfig(loaded, configPath);
+}
+function rcConfig(configPath, content) {
+	let parsed;
+	try {
+		parsed = getStaticJSONValue(parseJSON(content, { jsonSyntax: "jsonc" }));
+	} catch (err) {
+		throw loadError(configPath, err);
+	}
+	if (!isRecord$1(parsed)) throw loadError(configPath, /* @__PURE__ */ new TypeError("the config is not an object"));
+	return toResolvedConfig(parsed, configPath);
+}
+/**
+* Pick `printWidth` and `tabWidth` out of a set of format options.
+*
+* @param options - Format options, of unknown shape.
+* @returns The widths it sets.
+*/
+function widthsOf(options) {
+	if (!isRecord$1(options)) return {};
+	const { printWidth, tabWidth } = options;
+	return {
+		...typeof printWidth === "number" ? { printWidth } : {},
+		...typeof tabWidth === "number" ? { tabWidth } : {}
+	};
+}
+/**
 * Resolves the lowest Node major version a semver range can match.
 *
 * @param range - A semver range such as `>=24.12.0` or `^24 || ^26`.
@@ -7707,6 +8079,28 @@ const defaultPluginRenaming = {
 	"yml": "yaml"
 };
 //#endregion
+//#region src/formatted-files.ts
+/**
+* The files the preset formats with oxfmt. ESLint mode enables `oxfmt/oxfmt`
+* on these globs; the standalone oxfmt config ignores every other file. One
+* list keeps both modes formatting the same files.
+*
+* Imported by the standalone oxfmt config, so keep it light.
+*/
+/** Formatted globs, by `oxfmt/oxfmt` config block. */
+const FORMATTED_FILES = {
+	css: [GLOB_CSS, GLOB_POSTCSS],
+	graphql: ["**/*.graphql"],
+	html: ["**/*.html"],
+	javascript: [GLOB_JS, GLOB_JSX],
+	json: [GLOB_ALL_JSON],
+	less: [GLOB_LESS],
+	markdown: [GLOB_MARKDOWN],
+	scss: [GLOB_SCSS],
+	typescript: [GLOB_TS, GLOB_TSX],
+	yaml: [GLOB_YAML]
+};
+//#endregion
 //#region src/generated/stylistic.ts
 const stylisticRuleNames = /* @__PURE__ */ new Set([
 	"array-bracket-newline",
@@ -7811,7 +8205,7 @@ const stylisticRuleNames = /* @__PURE__ */ new Set([
 //#region src/oxlint/configs/oxfmt.ts
 const require$1 = createRequire(import.meta.url);
 function oxlintOxfmt(options) {
-	const { componentExts: componentExtensions = [], files: oxfmtFiles, oxfmtOptions = {} } = options ?? {};
+	const { componentExts: componentExtensions = [], files: oxfmtFiles, oxfmtOptions = {}, standalone = false } = options ?? {};
 	const configPrettier = require$1("eslint-config-prettier/flat");
 	const configPrettierRules = isRecord$1(configPrettier) && isRecord$1(configPrettier["rules"]) ? configPrettier["rules"] : {};
 	const rulesToIgnore = /* @__PURE__ */ new Set(["curly", "style/quotes"]);
@@ -7831,12 +8225,8 @@ function oxlintOxfmt(options) {
 		name: "oxfmt",
 		specifier: resolveJsPluginSpecifier("eslint-plugin-oxfmt")
 	};
-	const jsFiles = oxfmtFiles?.flat() ?? ["**/*.{,c,m}js", "**/*.{,c,m}jsx"];
-	const tsFiles = oxfmtFiles?.flat() ?? [
-		"**/*.{,c,m}ts",
-		"**/*.{,c,m}tsx",
-		...componentExtensions.map((extension) => `**/*.${extension}`)
-	];
+	const jsFiles = oxfmtFiles?.flat() ?? [...FORMATTED_FILES.javascript];
+	const tsFiles = oxfmtFiles?.flat() ?? [...FORMATTED_FILES.typescript, ...componentExtensions.map((extension) => `**/*.${extension}`)];
 	function createFragments(name, files) {
 		return [{
 			name,
@@ -7849,10 +8239,13 @@ function oxlintOxfmt(options) {
 		}, {
 			name: `${name}/js-plugin`,
 			files,
-			jsPlugins: [...jsPlugins, oxfmtPlugin],
+			jsPlugins: standalone ? jsPlugins : [...jsPlugins, oxfmtPlugin],
 			rules: {
 				...jsPluginRules,
-				"oxfmt/oxfmt": ["error", oxfmtOptions]
+				...standalone ? {} : { "oxfmt/oxfmt": ["error", {
+					...oxfmtOptions,
+					disableNestedConfig: true
+				}] }
 			}
 		}];
 	}
@@ -9420,7 +9813,7 @@ const NATIVE_ONLY_JS_PLUGINS = /* @__PURE__ */ new Set(["oxlint-comments"]);
 */
 function isentinel(factoryOptions, ...userConfigs) {
 	const options = factoryOptions ?? { name: "isentinel" };
-	const { antiSlop = false, categories, componentExts: componentExtensions = [], e18e: enableE18e = true, env, eslintPlugin: enableEslintPlugin = false, formatters, gitignore: enableGitignore = true, globals, ignores, jsdoc: enableJsdoc = true, jsPlugins: userJsPlugins, jsx: enableJsx = true, options: linterOptions, oxc: enableOxc = true, projectStructure: enableProjectStructure = false, react: enableReact = false, root: customRootGlobs, rules = {}, spellCheck: enableSpellCheck, test: enableTest = false, warnDroppedOverrides: enableDroppedOverrideWarning = true } = options;
+	const { antiSlop = false, categories, componentExts: componentExtensions = [], e18e: enableE18e = true, env, eslintPlugin: enableEslintPlugin = false, formatter = "eslint", formatters, gitignore: enableGitignore = true, globals, ignores, jsdoc: enableJsdoc = true, jsPlugins: userJsPlugins, jsx: enableJsx = true, options: linterOptions, oxc: enableOxc = true, projectStructure: enableProjectStructure = false, react: enableReact = false, root: customRootGlobs, rules = {}, spellCheck: enableSpellCheck, test: enableTest = false, warnDroppedOverrides: enableDroppedOverrideWarning = true } = options;
 	const rootGlobs = mergeGlobs(GLOB_ROOT, customRootGlobs);
 	const enableRoblox = options.roblox !== false;
 	const reactOptions = resolveSubOptions(options, "react");
@@ -9441,14 +9834,22 @@ function isentinel(factoryOptions, ...userConfigs) {
 		if (options.type !== void 0) return options.type;
 		return enableRoblox ? "game" : "package";
 	})();
+	if (formatter === "standalone") warnStandaloneOptions(options);
+	const formatterOptions = formatter !== "standalone" && typeof formatters === "object" ? formatters : {};
+	const oxfmtFormats = formatter === "standalone" || formatters !== false && options.stylistic !== false;
+	const prettierSettings = resolvePrettierSettings(formatterOptions.prettierOptions);
+	const oxfmtOptions = buildOxfmtOptions({
+		oxfmtConfigOptions: oxfmtFormats ? resolveOxfmtConfigOptionsSync() : {},
+		oxfmtOptions: formatterOptions.oxfmtOptions,
+		prettierOptions: prettierSettings
+	});
 	const stylisticOptions = (() => {
 		if (options.stylistic === false) return false;
 		if (typeof options.stylistic === "object") return options.stylistic;
 		return {};
 	})();
 	if (stylisticOptions !== false && !("jsx" in stylisticOptions)) stylisticOptions.jsx = enableJsx;
-	const formatterOptions = typeof formatters === "object" ? formatters : {};
-	const prettierSettings = resolvePrettierSettings(formatterOptions.prettierOptions);
+	const widthSettings = withOxfmtWidths(prettierSettings, oxfmtOptions);
 	const configs = [
 		oxlintJavascript({
 			...getOverrides(options, "javascript"),
@@ -9540,7 +9941,7 @@ function isentinel(factoryOptions, ...userConfigs) {
 	if (stylisticOptions !== false) configs.push(oxlintPerfectionist({
 		...resolveSubOptions(options, "perfectionist"),
 		type: projectType
-	}), oxlintStylistic(stylisticOptions));
+	}), oxlintStylistic(oxfmtFormats ? withOxfmtStyle(stylisticOptions, oxfmtOptions) : stylisticOptions));
 	if (enableReact !== false) configs.push(oxlintReact({
 		roblox: enableRoblox,
 		settings: options.settings,
@@ -9569,30 +9970,24 @@ function isentinel(factoryOptions, ...userConfigs) {
 		antiSlop,
 		roblox: enableRoblox,
 		stylistic: stylisticOptions
-	}, prettierSettings), ...needsComplementOverlay ? [oxlintFlawless({
+	}, widthSettings), ...needsComplementOverlay ? [oxlintFlawless({
 		antiSlop,
 		excludeFiles: robloxScopedFiles,
 		roblox: false,
 		stylistic: stylisticOptions
-	}, prettierSettings)] : [], oxlintComments({
-		prettierOptions: prettierSettings,
+	}, widthSettings)] : [], oxlintComments({
+		prettierOptions: widthSettings,
 		stylistic: stylisticOptions
 	}), oxlintDisables({
 		configDirectory: options.configDirectory,
 		root: rootGlobs,
 		workspaceRoot: findWorkspaceRootSync()
 	}));
-	if (stylisticOptions !== false && formatters !== false) {
-		const oxfmtConfigOptions = resolveOxfmtConfigOptionsSync();
-		configs.push(oxlintOxfmt({
-			componentExts: componentExtensions,
-			oxfmtOptions: buildOxfmtOptions({
-				oxfmtConfigOptions,
-				oxfmtOptions: formatterOptions.oxfmtOptions,
-				prettierOptions: prettierSettings
-			})
-		}));
-	}
+	if (stylisticOptions !== false && formatters !== false) configs.push(oxlintOxfmt({
+		componentExts: componentExtensions,
+		oxfmtOptions,
+		standalone: formatter === "standalone"
+	}));
 	const jsPlugins = /* @__PURE__ */ new Map();
 	const nativePlugins = /* @__PURE__ */ new Set();
 	const globalPlugins = /* @__PURE__ */ new Set();