@mkrz/oxlint-config 0.1.0

package/dist/index.js

@@ -0,0 +1,624 @@
+import { defineConfig as defineConfig$1 } from "oxlint";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/configs/ignore-patterns.ts
+/**
+* Build output, caches, and lockfiles that should never be linted.
+*
+* Oxlint only honors `ignorePatterns` on the root config; patterns inside an
+* extended config are dropped. Spread this list into the root config.
+*/
+const ignorePatterns = [
+	"**/__snapshots__/**",
+	"**/.next/**",
+	"**/.turbo/**",
+	"**/*.d.ts",
+	"**/*.min.*",
+	"**/CHANGELOG.md",
+	"**/coverage/**",
+	"**/dist/**",
+	"**/node_modules/**",
+	"**/out/**",
+	"**/output/**",
+	"**/package-lock.json",
+	"**/pnpm-lock.yaml",
+	"**/yarn.lock"
+];
+//#endregion
+//#region src/configs/base.ts
+/**
+* Fast defaults for TypeScript projects.
+*
+* Rule policy: the `correctness` and `suspicious` categories are enabled at
+* error severity for every enabled plugin, so rules in those categories are
+* not repeated here. The explicit list below only holds rules outside those
+* categories, rules that need options, and rules turned off for TypeScript
+* because the compiler already reports them.
+*/
+const base = {
+	plugins: [
+		"import",
+		"oxc",
+		"promise",
+		"typescript",
+		"unicorn"
+	],
+	categories: {
+		correctness: "error",
+		suspicious: "error"
+	},
+	env: {
+		builtin: true,
+		node: true
+	},
+	options: { reportUnusedDisableDirectives: "error" },
+	rules: {
+		"mkrz/no-chained-type-assertions": "error",
+		"mkrz/no-known-value-widening": "error",
+		"mkrz/no-let": "error",
+		"mkrz/no-module-mocking": "error",
+		"mkrz/no-reflect-apply": "error",
+		"mkrz/no-reflect-get": "error",
+		"mkrz/no-type-assertion": "error",
+		"mkrz/no-unknown-parameters": "error",
+		"mkrz/no-unknown-returns": "error",
+		"mkrz/no-unknown-type-aliases": "error",
+		"mkrz/no-unsafe-dictionary-type": "error",
+		"mkrz/no-widen-then-assert": "error",
+		"mkrz/padding-line-between-statements": [
+			"error",
+			{
+				blankLine: "always",
+				prev: {
+					selector: "*",
+					lineMode: "multiline"
+				},
+				next: "*"
+			},
+			{
+				blankLine: "always",
+				prev: "block-like",
+				next: "*"
+			},
+			{
+				blankLine: "always",
+				prev: "*",
+				next: "return"
+			},
+			{
+				blankLine: "any",
+				prev: "import",
+				next: "import"
+			}
+		],
+		"array-callback-return": "error",
+		complexity: ["error", { max: 10 }],
+		curly: ["error", "all"],
+		"default-case-last": "error",
+		eqeqeq: [
+			"error",
+			"always",
+			{ null: "ignore" }
+		],
+		"import/consistent-type-specifier-style": ["error", "prefer-inline"],
+		"import/no-duplicates": "error",
+		"import/no-relative-parent-imports": "error",
+		"no-alert": "error",
+		"no-array-constructor": "error",
+		"no-case-declarations": "error",
+		"no-empty": "error",
+		"no-empty-function": "error",
+		"no-fallthrough": "error",
+		"no-new-wrappers": "error",
+		"no-promise-executor-return": "error",
+		"no-prototype-builtins": "error",
+		"no-self-compare": "error",
+		"no-template-curly-in-string": "error",
+		"no-unreachable-loop": "error",
+		"no-unused-vars": ["error", {
+			argsIgnorePattern: "^_",
+			caughtErrorsIgnorePattern: "^_",
+			varsIgnorePattern: "^_"
+		}],
+		"no-var": "error",
+		"no-warning-comments": ["error", { terms: ["@nocommit"] }],
+		"oxc/bad-bitwise-operator": "error",
+		"oxc/no-accumulating-spread": "error",
+		"prefer-const": "error",
+		"prefer-object-has-own": "error",
+		"promise/no-return-wrap": "error",
+		"typescript/adjacent-overload-signatures": "error",
+		"typescript/array-type": "error",
+		"typescript/ban-ts-comment": "error",
+		"typescript/ban-tslint-comment": "error",
+		"typescript/class-literal-property-style": "error",
+		"typescript/consistent-generic-constructors": "error",
+		"typescript/consistent-indexed-object-style": "error",
+		"typescript/consistent-type-definitions": ["error", "type"],
+		"typescript/consistent-type-imports": ["error", {
+			fixStyle: "inline-type-imports",
+			prefer: "type-imports"
+		}],
+		"typescript/no-empty-object-type": "error",
+		"typescript/no-explicit-any": "error",
+		"typescript/no-inferrable-types": "error",
+		"typescript/no-namespace": "error",
+		"typescript/no-non-null-asserted-nullish-coalescing": "error",
+		"typescript/no-non-null-assertion": "error",
+		"typescript/no-require-imports": "error",
+		"typescript/no-unnecessary-type-assertion": "off",
+		"typescript/no-unsafe-function-type": "error",
+		"typescript/no-unsafe-type-assertion": "off",
+		"typescript/prefer-for-of": "error",
+		"typescript/prefer-function-type": "error",
+		"unicorn/no-abusive-eslint-disable": "error",
+		"unicorn/no-magic-array-flat-depth": "error",
+		"unicorn/no-unnecessary-slice-end": "error",
+		"unicorn/no-useless-promise-resolve-reject": "error",
+		"unicorn/prefer-array-flat-map": "error",
+		"unicorn/prefer-array-some": "error",
+		"unicorn/prefer-date-now": "error",
+		"unicorn/prefer-node-protocol": "error",
+		"unicorn/prefer-number-properties": "error",
+		"unicorn/throw-new-error": "error"
+	},
+	overrides: [{
+		files: [
+			"**/*.cts",
+			"**/*.mts",
+			"**/*.ts",
+			"**/*.tsx"
+		],
+		rules: {
+			"constructor-super": "off",
+			"getter-return": "off",
+			"no-class-assign": "off",
+			"no-const-assign": "off",
+			"no-dupe-class-members": "off",
+			"no-dupe-keys": "off",
+			"no-func-assign": "off",
+			"no-import-assign": "off",
+			"no-new-native-nonconstructor": "off",
+			"no-obj-calls": "off",
+			"no-setter-return": "off",
+			"no-this-before-super": "off",
+			"no-unreachable": "off",
+			"no-unsafe-negation": "off",
+			"no-with": "off",
+			"prefer-rest-params": "error",
+			"prefer-spread": "error"
+		}
+	}, {
+		files: ["**/*.cjs"],
+		rules: { "typescript/no-require-imports": "off" }
+	}]
+};
+//#endregion
+//#region src/configs/monorepo.ts
+const message = "Move shared code into a package and import it from there instead.";
+/**
+* Overrides for the apps/packages layout.
+*
+* Relative imports that climb out of a package are already rejected by
+* `import/no-relative-parent-imports` in `base`, so only workspace package
+* names need a rule here.
+*/
+function monorepo({ appsPath = ["apps/**"], packagesPath = ["packages/**"], appPackages = [] } = {}) {
+	const packageRules = { "mkrz/package-disable-policy": "error" };
+	if (appPackages.length > 0) {
+		const patterns = appPackages.flatMap((name) => [name, `${name}/**`]);
+		packageRules["mkrz/no-app-requires"] = ["error", patterns];
+		packageRules["no-restricted-imports"] = ["error", { patterns: [{
+			group: patterns,
+			message
+		}] }];
+	}
+	return { overrides: [{
+		files: appsPath,
+		rules: { "mkrz/no-oxlint-disable": "error" }
+	}, {
+		files: packagesPath,
+		rules: packageRules
+	}] };
+}
+//#endregion
+//#region src/configs/plugin-specifiers.ts
+const modulePath = fileURLToPath(import.meta.url);
+const moduleExtension = path.extname(modulePath);
+const pluginCandidates = [`../plugin/index${moduleExtension}`, `./plugin/index${moduleExtension}`].map((candidate) => fileURLToPath(new URL(candidate, import.meta.url)));
+const mkrzPluginSpecifier = pluginCandidates.find((candidate) => fs.existsSync(candidate));
+if (mkrzPluginSpecifier === void 0) throw new Error(`@mkrz/oxlint-config cannot locate its plugin module; looked at ${pluginCandidates.join(" and ")}.`);
+/** Absolute specifier so `extends` of this config still loads the plugin. */
+const mkrzPlugin = {
+	name: "mkrz",
+	specifier: mkrzPluginSpecifier
+};
+//#endregion
+//#region src/configs/react.ts
+/**
+* React, accessibility, compiler, query, and store rules.
+*
+* React and jsx-a11y rules in the `correctness` and `suspicious` categories
+* are already on through `base`; only rules outside those categories, rules
+* with options, and rules turned off are listed.
+*/
+const react = {
+	plugins: ["jsx-a11y", "react"],
+	env: { browser: true },
+	rules: {
+		"import/no-unassigned-import": ["error", { allow: [
+			"**/*.css",
+			"**/*.less",
+			"**/*.sass",
+			"**/*.scss"
+		] }],
+		"jsx-a11y/interactive-supports-focus": ["error", { tabbable: [
+			"button",
+			"checkbox",
+			"link",
+			"searchbox",
+			"spinbutton",
+			"switch",
+			"textbox"
+		] }],
+		"jsx-a11y/label-has-associated-control": ["error", {
+			controlComponents: [
+				"Checkbox",
+				"Input",
+				"Select",
+				"Switch"
+			],
+			depth: 3
+		}],
+		"jsx-a11y/no-interactive-element-to-noninteractive-role": ["error", {
+			canvas: ["img"],
+			tr: ["none", "presentation"]
+		}],
+		"jsx-a11y/no-noninteractive-element-interactions": ["error", {
+			alert: [
+				"onKeyDown",
+				"onKeyPress",
+				"onKeyUp"
+			],
+			body: ["onError", "onLoad"],
+			dialog: [
+				"onKeyDown",
+				"onKeyPress",
+				"onKeyUp"
+			],
+			handlers: [
+				"onClick",
+				"onError",
+				"onKeyDown",
+				"onKeyPress",
+				"onKeyUp",
+				"onLoad",
+				"onMouseDown",
+				"onMouseUp"
+			],
+			iframe: ["onError", "onLoad"],
+			img: ["onError", "onLoad"]
+		}],
+		"jsx-a11y/no-noninteractive-element-to-interactive-role": ["error", {
+			fieldset: ["presentation", "radiogroup"],
+			li: [
+				"menuitem",
+				"menuitemcheckbox",
+				"menuitemradio",
+				"option",
+				"row",
+				"tab",
+				"treeitem"
+			],
+			ol: [
+				"listbox",
+				"menu",
+				"menubar",
+				"radiogroup",
+				"tablist",
+				"tree",
+				"treegrid"
+			],
+			table: ["grid"],
+			td: ["gridcell"],
+			ul: [
+				"listbox",
+				"menu",
+				"menubar",
+				"radiogroup",
+				"tablist",
+				"tree",
+				"treegrid"
+			]
+		}],
+		"jsx-a11y/no-noninteractive-tabindex": ["error", {
+			allowExpressionValues: true,
+			roles: ["tabpanel"],
+			tags: []
+		}],
+		"jsx-a11y/no-static-element-interactions": ["error", {
+			allowExpressionValues: true,
+			handlers: [
+				"onClick",
+				"onKeyDown",
+				"onKeyPress",
+				"onKeyUp",
+				"onMouseDown",
+				"onMouseUp"
+			]
+		}],
+		"mkrz/no-query-result-destructuring": "error",
+		"mkrz/no-restricted-react-hooks": "error",
+		"mkrz/require-store-selector": "error",
+		"react/button-has-type": "error",
+		"react/checked-requires-onchange-or-readonly": "error",
+		"react/display-name": "error",
+		"react/exhaustive-effect-dependencies": "off",
+		"react/jsx-no-constructed-context-values": "error",
+		"react/jsx-no-target-blank": "error",
+		"react/jsx-no-useless-fragment": "error",
+		"react/no-array-index-key": "error",
+		"react/no-unescaped-entities": "error",
+		"react/no-unknown-property": "error",
+		"react/react-in-jsx-scope": "off",
+		"react/require-render-return": "error",
+		"react/rules-of-hooks": "error",
+		"react/unsupported-syntax": "error"
+	}
+};
+//#endregion
+//#region src/configs/repository.ts
+const monorepoDirectories = ["apps", "packages"];
+/**
+* A `pnpm-workspace.yaml` only marks a monorepo when it declares `packages`.
+* Single-package repositories use the file for the catalog alone.
+*/
+function declaresWorkspacePackages(root) {
+	const file = path.join(root, "pnpm-workspace.yaml");
+	return fs.existsSync(file) && /^packages:/mu.test(fs.readFileSync(file, "utf8"));
+}
+function readManifest(root) {
+	const file = path.join(root, "package.json");
+	if (!fs.existsSync(file)) return null;
+	const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+	if (typeof parsed !== "object" || parsed === null) return null;
+	return {
+		private: "private" in parsed && parsed.private === true,
+		workspaces: "workspaces" in parsed && parsed.workspaces != null
+	};
+}
+/**
+* Detect the repository type from the directory Oxlint runs in.
+*
+* A `pnpm-workspace.yaml` with `packages`, a `workspaces` field, or an `apps/`
+* or `packages/` directory means `monorepo`. Otherwise `package.json` decides:
+* `"private": true` means `app`, anything else `library`. Without a
+* `package.json` the result is `app`, with a warning.
+*
+* A workspace without the default `apps/` and `packages/` directories also
+* warns, because the monorepo overrides would then match no file at all.
+*/
+function detectRepositoryType(root, warn) {
+	const manifest = readManifest(root);
+	if (monorepoDirectories.some((directory) => fs.existsSync(path.join(root, directory)))) return "monorepo";
+	if (declaresWorkspacePackages(root) || manifest?.workspaces === true) {
+		warn(`@mkrz/oxlint-config: ${root} is a workspace but has no apps/ or packages/ directory, so the disable-directive policy applies to no file. Pass repositoryType: 'monorepo' with appsPath and packagesPath to mkrz().`);
+		return "monorepo";
+	}
+	if (manifest === null) {
+		warn(`@mkrz/oxlint-config: no package.json in ${root}; treating the repository as an application. Pass repositoryType to mkrz() to silence this.`);
+		return "app";
+	}
+	return manifest.private ? "app" : "library";
+}
+const app = { overrides: [{
+	files: ["**/*"],
+	rules: { "mkrz/no-oxlint-disable": "error" }
+}] };
+const library = { overrides: [{
+	files: ["**/*"],
+	rules: { "mkrz/package-disable-policy": "error" }
+}] };
+/** The overrides that carry the disable-directive and import policy. */
+function repository(type, layout = {}) {
+	switch (type) {
+		case "app": return app;
+		case "library": return library;
+		default: return monorepo(layout);
+	}
+}
+/**
+* Test-file rules: vitest checks, plus permission to use type assertions and
+* non-null assertions.
+*/
+const tests = { overrides: [{
+	files: [
+		"**/*.{test,spec}.*",
+		"**/*.test-d.*",
+		"**/__tests__/**"
+	],
+	plugins: ["vitest"],
+	rules: {
+		"mkrz/no-chained-type-assertions": "off",
+		"mkrz/no-known-value-widening": "off",
+		"mkrz/no-type-assertion": "off",
+		"mkrz/no-widen-then-assert": "off",
+		"typescript/no-non-null-assertion": "off",
+		"vitest/expect-expect": "error",
+		"vitest/no-disabled-tests": "error",
+		"vitest/no-focused-tests": "error"
+	}
+}] };
+//#endregion
+//#region src/configs/type-aware.ts
+function* ancestors(directory) {
+	const parent = path.dirname(directory);
+	yield directory;
+	if (parent !== directory) yield* ancestors(parent);
+}
+/**
+* Whether Oxlint will find the `tsgolint` binary when run from `root`.
+*
+* Oxlint reads `OXLINT_TSGOLINT_PATH` first and otherwise looks for the
+* `.bin/tsgolint` shim in the `node_modules` directories above the working
+* directory. Resolving the package beside this config is insufficient: a
+* linked config may live outside the executable search path.
+*/
+function hasTsgolint(root) {
+	if (process.env.OXLINT_TSGOLINT_PATH !== void 0) return true;
+	return [...ancestors(root)].some((directory) => fs.existsSync(path.join(directory, "node_modules", ".bin", "tsgolint")));
+}
+/**
+* Type-checked rules for consumers that can pay the extra lint time.
+*
+* Type-aware rules in the `correctness` and `suspicious` categories are
+* already on through `base`; only rules outside those categories are listed.
+*/
+const typeAware = {
+	options: { typeAware: true },
+	plugins: ["typescript"],
+	rules: {
+		"typescript/dot-notation": "error",
+		"typescript/no-misused-promises": "error",
+		"typescript/no-mixed-enums": "error",
+		"typescript/no-unsafe-argument": "error",
+		"typescript/no-unsafe-assignment": "error",
+		"typescript/no-unsafe-call": "error",
+		"typescript/no-unsafe-member-access": "error",
+		"typescript/no-unsafe-return": "error",
+		"typescript/only-throw-error": "error",
+		"typescript/prefer-find": "error",
+		"typescript/prefer-includes": "error",
+		"typescript/prefer-nullish-coalescing": "error",
+		"typescript/prefer-optional-chain": "error",
+		"typescript/prefer-promise-reject-errors": "error",
+		"typescript/prefer-regexp-exec": "error",
+		"typescript/prefer-string-starts-ends-with": "error",
+		"typescript/related-getter-setter-pairs": "error",
+		"typescript/require-await": "error",
+		"typescript/restrict-plus-operands": "error",
+		"typescript/return-await": "error",
+		"typescript/switch-exhaustiveness-check": ["error", { considerDefaultExhaustiveForUnions: true }]
+	}
+};
+//#endregion
+//#region src/mkrz.ts
+/** Shallow-merge two optional record fields, the second winning. */
+function merged(first, second) {
+	return first === void 0 && second === void 0 ? void 0 : Object.assign({}, first, second);
+}
+/** Concatenate two optional array fields. */
+function joined(first, second) {
+	return first === void 0 && second === void 0 ? void 0 : [...first ?? [], ...second ?? []];
+}
+/**
+* Lay `top` over `bottom` the way `extends` should: object fields merge with
+* `top` winning, list fields concatenate, and nothing is dropped.
+*/
+function layer(bottom, top) {
+	const plugins = joined(bottom.plugins, top.plugins);
+	return {
+		...bottom,
+		...top,
+		categories: merged(bottom.categories, top.categories),
+		env: merged(bottom.env, top.env),
+		globals: merged(bottom.globals, top.globals),
+		ignorePatterns: joined(bottom.ignorePatterns, top.ignorePatterns),
+		jsPlugins: joined(bottom.jsPlugins ?? void 0, top.jsPlugins ?? void 0),
+		options: merged(bottom.options, top.options),
+		overrides: joined(bottom.overrides, top.overrides),
+		plugins: plugins === void 0 ? void 0 : [...new Set(plugins)],
+		rules: merged(bottom.rules, top.rules),
+		settings: merged(bottom.settings, top.settings)
+	};
+}
+/**
+* `defineConfig` from Oxlint for consumers who compose with `extends`.
+*
+* Oxlint only honors `ignorePatterns`, `env`, `globals`, and `settings` on
+* the root config and drops them from extended configs. This wrapper folds
+* those fields from every entry of `extends` into the root, and adds this
+* package's ignore list. Prefer the second argument of `mkrz` when you only
+* need to layer settings on this ruleset.
+*/
+function defineConfig(config) {
+	const inherited = inheritedRootFields(config);
+	return defineConfig$1({
+		...config,
+		...inherited,
+		ignorePatterns: [...ignorePatterns, ...inherited.ignorePatterns ?? []]
+	});
+}
+/** Fold root-only fields without changing Oxlint's rule/override precedence. */
+function inheritedRootFields(config) {
+	const inherited = (config.extends ?? []).reduce((accumulated, entry) => layer(accumulated, inheritedRootFields(entry)), {});
+	return {
+		env: merged(inherited.env, config.env),
+		globals: merged(inherited.globals, config.globals),
+		settings: merged(inherited.settings, config.settings),
+		ignorePatterns: joined(inherited.ignorePatterns, config.ignorePatterns)
+	};
+}
+const empty = {};
+function typeAwareEnabled(requested, root, warn) {
+	if (requested === false || hasTsgolint(root)) return requested ?? true;
+	if (requested === true) throw new Error("@mkrz/oxlint-config: typeAware is on but oxlint-tsgolint is not installed. Add it with `pnpm add -D oxlint-tsgolint` or pass typeAware: false.");
+	warn("@mkrz/oxlint-config: oxlint-tsgolint is not installed; type-aware rules are off until it is. Add it with `pnpm add -D oxlint-tsgolint` or pass typeAware: false to silence this.");
+	return false;
+}
+function resolveRepositoryType(options, root, warn) {
+	return options.repositoryType === void 0 || options.repositoryType === "auto" ? detectRepositoryType(root, warn) : options.repositoryType;
+}
+function build(options, config, warn) {
+	const root = process.cwd();
+	const { react: withReact = true, typeAware: typeAwareOption } = options;
+	const typeAwarePiece = typeAwareEnabled(typeAwareOption, root, warn) ? typeAware : empty;
+	const reactPiece = withReact ? react : empty;
+	const repositoryPiece = options.repositoryType === "monorepo" ? repository("monorepo", options) : repository(resolveRepositoryType(options, root, warn));
+	const ruleset = {
+		jsPlugins: [mkrzPlugin],
+		plugins: [...new Set([
+			base,
+			typeAwarePiece,
+			reactPiece
+		].flatMap((piece) => piece.plugins ?? []))],
+		categories: base.categories,
+		env: {
+			...base.env,
+			...reactPiece.env
+		},
+		options: {
+			...base.options,
+			...typeAwarePiece.options
+		},
+		rules: {
+			...base.rules,
+			...typeAwarePiece.rules,
+			...reactPiece.rules
+		},
+		overrides: [
+			base,
+			tests,
+			repositoryPiece
+		].flatMap((piece) => piece.overrides ?? []),
+		ignorePatterns
+	};
+	return defineConfig$1(layer(ruleset, config));
+}
+/**
+* The complete ruleset as one flat root config.
+*
+* Everything is built as a single object rather than a chain of `extends`
+* pieces: the plugin is declared once, the rule categories are declared once,
+* and no subset can be handed to Oxlint that fails to load or runs at the
+* wrong severity. `config` is the consumer's own root config and is layered
+* on top: its root `rules` win over our root rules, its `overrides` run last,
+* and its `ignorePatterns` are added to this package's list. Matching file
+* overrides still take precedence over root rules.
+*/
+function mkrz(options = {}, config = {}) {
+	return build(options, config, console.warn);
+}
+//#endregion
+export { defineConfig, ignorePatterns, mkrz };

package/dist/plugin/index.d.ts

@@ -0,0 +1,4 @@
+//#region src/plugin/index.d.ts
+declare const plugin: import("@oxlint/plugins").Plugin;
+//#endregion
+export { plugin as default };