@rdjperron/lint 0.1.0 → 0.2.0

package/README.md

@@ -1,18 +1,20 @@
 # @rdjperron/lint
 
-Oxlint JS plugins in four packs. Each pack is one plugin, registered on its own, so a project
-enables only what it wants.
+One Oxlint JS plugin, `rdj`, with twenty rules against low-evidence code, the config data a
+project spreads into its own `vite.config.ts`, and the check that proves every rule still fires.
 
-| Pack        | Plugin name    | Rules                                                                                                                                                       |
-| ----------- | -------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `anti-slop` | `anti-slop`    | 17 rules that reject low-evidence patterns: `unknown` contracts, unjustified type assertions, `Reflect` calls, runtime `typeof`, module mocking, and so on. |
-| `react`     | `react-policy` | `no-use-effect`: reports every `useEffect` and `useLayoutEffect` call or import.                                                                            |
-| `i18n`      | `i18n`         | `no-hardcoded-jsx-text`: reports words written straight into JSX children.                                                                                  |
-| `expo`      | `expo`         | `static-public-env`: allows only `process.env.NAME` reads, the one form Expo inlines at bundle time.                                                        |
+| Entry                        | What it gives you                                                                    |
+| ---------------------------- | ------------------------------------------------------------------------------------ |
+| `@rdjperron/lint`            | The plugin. One `jsPlugins` entry, one prefix, twenty rules.                         |
+| `@rdjperron/lint/config`     | `recommended`, the override builders, and the `fmt`, `ignore` and `staged` blocks.   |
+| `@rdjperron/lint/verify`     | `verifySuites`, `packageSuite`, `verifyPluginApiPin`, and the `rdj-lint-verify` bin. |
+| `@rdjperron/lint/fixtures/*` | One deliberately violating file per rule, the input the verify command lints.        |
 
-`anti-slop` is a copy of [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop), owned and
-edited here (see `src/anti-slop/VENDORED.md` in the source repo). The plugin name is `react-policy`
-and not `react` because oxlint has a built-in plugin called `react`.
+Seventeen of the rules are a copy of [dmmulroy/anti-slop](https://github.com/dmmulroy/anti-slop),
+owned and edited here (`src/anti-slop/VENDORED.md` in the source repo records the commit). The
+other three are written here.
+
+Tested on vite-plus 0.3.1, oxlint 1.81.0 and `@oxlint/plugins` 1.79.0 (2026-09-17).
 
 ## Install
 
@@ -30,59 +32,146 @@ vp why @oxlint/plugins
 # or: node -p "require('vite-plus/package.json').dependencies['@oxlint/plugins']"
 ```
 
-Pin `@oxlint/plugins` exactly to that number. The peer range in this package is a caret so an
-exact pin anywhere in the same major satisfies it. Move the pin every time `vp` moves.
-
-## Register a pack
+Pin `@oxlint/plugins` exactly to that number. The peer range here is a caret, so an exact pin
+anywhere in the same major satisfies it. Move the pin every time `vp` moves; `rdj-lint-verify`
+fails when the two drift apart.
 
-Each pack is a `jsPlugins` entry with its name and its specifier, then rules by `<name>/<rule>`:
+## Use it
 
 ```ts
-// vite.config.ts (or .oxlintrc.json, same shape)
+// vite.config.ts
+import { fixtures, fmt, ignore, react, recommended, staged, tests } from "@rdjperron/lint/config";
+import { defineConfig } from "vite-plus";
+
 export default defineConfig({
+  staged,
+  fmt: { ...fmt, ignorePatterns: ignore },
   lint: {
-    jsPlugins: [
-      { name: "anti-slop", specifier: "@rdjperron/lint/anti-slop" },
-      { name: "react-policy", specifier: "@rdjperron/lint/react" },
-      { name: "i18n", specifier: "@rdjperron/lint/i18n" },
-      { name: "expo", specifier: "@rdjperron/lint/expo" },
+    extends: [recommended],
+    plugins: ["typescript", "unicorn", "oxc", "import", "promise", "node"],
+    categories: { correctness: "error", suspicious: "warn", perf: "warn" },
+    env: { builtin: true, node: true },
+    overrides: [
+      ...react(["app/**"], { useEffectAllowedIn: "hooks/use-mount-effect.ts" }),
+      ...tests(["**/*.test.ts", "**/*.test.tsx"]),
+      ...fixtures(),
     ],
-    rules: {
-      "anti-slop/no-reflect-get": "error",
-      "react-policy/no-use-effect": [
-        "error",
-        { hint: "The one sanctioned wrapper is useMountEffect." },
-      ],
-      "i18n/no-hardcoded-jsx-text": "error",
-      "expo/static-public-env": "error",
-    },
+    options: { typeAware: true, typeCheck: true },
+    ignorePatterns: ignore,
   },
 });
 ```
 
-Measure before promoting: land a new rule at `warn`, fix or scope what fires, then move it to
-`error`. The anti-slop severities this package's own repo settled on are in its root
-`vite.config.ts`.
-
-### Rule options
-
-- `react-policy/no-use-effect` takes `{ hint?: string }`. The hint is appended to every finding,
-  so a project can name its one sanctioned wrapper. Exempt that wrapper's file with an override.
-- `i18n/no-hardcoded-jsx-text` takes `{ pattern?: string }`, a regex source compiled with the
-  `u` flag. The default `\p{L}{3,}` says three letters in a row is a word; digits, separators and
-  bullets are not. It looks at JSX text and at string literals placed as children, never at
-  attribute values.
-- `expo/static-public-env` has no options. It reports destructuring of `process.env`, computed
-  access, and `process.env` used as a value (assigned, passed, spread, returned).
-
-## The fixtures ship with the package
-
-`fixtures/<pack>/<rule>.fixture.ts(x)` is one deliberately violating file per rule. A rule can
-go silently dead (a linter upgrade, a plugin API skew, an ignore pattern that swallows the wrong
-path), and "reports nothing" looks exactly like "no violations". The consumer's verify script
-lints each fixture directory through its own pipeline and asserts that every rule fired on the
-file named after it. The source repo's `scripts/verify-lint-fixtures.mjs` is the reference
-implementation; copy it and point its suites at
-`node_modules/@rdjperron/lint/fixtures/<pack>`. oxlint skips `node_modules`, so the script lints
-through a symlinked view outside it, and that view must never be gitignored (oxlint honours
-`.gitignore`, and a gitignored view silently disables the whole check).
+`jsPlugins` needs no entry: `recommended` carries it. Registering by hand works too, in either
+form, because the plugin declares its own `meta.name`:
+
+```ts
+jsPlugins: ["@rdjperron/lint"];
+jsPlugins: [{ name: "rdj", specifier: "@rdjperron/lint" }];
+```
+
+### What `extends` carries, and what it does not
+
+Measured on vite-plus 0.3.1 and oxlint 1.81.0 (2026-09-17), with a base config object passed to
+`lint.extends`:
+
+| Field                                                                 | Inherited                               |
+| --------------------------------------------------------------------- | --------------------------------------- |
+| `jsPlugins`, `rules`, `overrides`, `plugins`, `categories`, `options` | yes, and the consumer's own entries win |
+| `env`, `settings`, `ignorePatterns`                                   | no, the consumer writes its own         |
+
+So `recommended` carries a plugin entry and rules, nothing else. Write `plugins`, `categories`,
+`env`, `options` and `ignorePatterns` in your own config; `ignore` is an array you spread into
+`ignorePatterns`, not a field you inherit.
+
+Two more things oxlint does quietly. An override that changes a built-in plugin's rule must
+repeat that plugin in its own `plugins`, even when an earlier override already listed it, or the
+entry is dropped with no error. And a relative plugin specifier inside an `extends` object is
+refused; a package name is what works.
+
+### The config exports
+
+| Export                   | What it is                                                                                                                                                                                                |
+| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `plugin`                 | `{ name: "rdj", specifier: "@rdjperron/lint" }`.                                                                                                                                                          |
+| `RULE_IDS`, `RuleId`     | The twenty prefixed ids, as a readonly tuple and as a type.                                                                                                                                               |
+| `recommended`            | The config object for `lint.extends`: the plugin entry, the rules below, and the built-in choices.                                                                                                        |
+| `react(files, options?)` | Browser globals, the hooks rules and the compiler's rules. `options.useEffectAllowedIn` names the one file allowed to call `useEffect`, puts its name in every finding, and switches the rule off for it. |
+| `i18n(files, options?)`  | `rdj/no-hardcoded-jsx-text` at error. `options.pattern` sets the word pattern.                                                                                                                            |
+| `expo(files)`            | `rdj/static-public-env` at error.                                                                                                                                                                         |
+| `tests(files)`           | `any`, `!`, `no-runtime-typeof` and the safety-comment rule off, with the reason on each.                                                                                                                 |
+| `fixtures(view?)`        | Every rule at error on the verify view, `scripts/.lint-fixtures/**` by default.                                                                                                                           |
+| `fmt`                    | `printWidth` 100, double quotes, semicolons, two spaces.                                                                                                                                                  |
+| `ignore`                 | Dependencies, build output, the AI agent directories and the Vitest JSON report.                                                                                                                          |
+| `staged`                 | `vp check --fix` on JS and TS sources.                                                                                                                                                                    |
+
+`recommended` puts every rule at `error` except `no-hardcoded-jsx-text` and `static-public-env`,
+which belong to a translated app and to an Expo app and are left to `i18n()` and `expo()`. The
+measurements behind those severities are in the comments beside them.
+
+## Prove the rules still fire
+
+```bash
+npx rdj-lint-verify
+```
+
+The fixtures ship in the package: `fixtures/<rule>.fixture.ts(x)` is one deliberately violating
+file per rule. The command lints them through your own `vp lint` and asserts a positive, that
+every rule fired on the file named after it, then checks the `@oxlint/plugins` pin. A rule can
+go silently dead after a linter upgrade or a plugin API skew, and "reports nothing" looks exactly
+like "no violations". Nothing else notices.
+
+Your config has to carry `fixtures()` in its overrides, on the view path the command uses
+(`scripts/.lint-fixtures/rdj` sits under the default `scripts/.lint-fixtures/**`). This is not a
+convenience: `-A`, `-W` and `-D` reach built-in rules only and cannot switch a JS plugin rule on,
+so the override is the only way the rules you leave off on your own code get proven.
+
+Two things not to do. Do not gitignore the view: oxlint honours `.gitignore`, so an ignored view
+reports zero files instead of a dead rule. And do not delete the fixtures.
+
+A repo with a second plugin to check imports `verifySuites` and describes both suites itself; the
+source repo's `scripts/verify-lint-fixtures.mjs` is the example.
+
+## The rules
+
+Each page explains what the rule rejects, what to write instead, and what it deliberately allows.
+
+| Rule                                                                                                       | What it rejects                                                           |
+| ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------- |
+| [`rdj/no-array-filter-map`](docs/rules/no-array-filter-map.md)                                             | `filter().map()`, two passes and an intermediate array.                   |
+| [`rdj/no-chained-type-assertions`](docs/rules/no-chained-type-assertions.md)                               | `x as unknown as T`, an assertion laundered through a second one.         |
+| [`rdj/no-conditional-empty-object-spread`](docs/rules/no-conditional-empty-object-spread.md)               | `...(cond ? { a } : {})`, omission hidden behind an empty object.         |
+| [`rdj/no-hardcoded-jsx-text`](docs/rules/no-hardcoded-jsx-text.md)                                         | Words written straight into JSX children.                                 |
+| [`rdj/no-known-value-widening`](docs/rules/no-known-value-widening.md)                                     | An annotation that throws away what inference already knew.               |
+| [`rdj/no-module-mocking`](docs/rules/no-module-mocking.md)                                                 | `vi.mock` and friends, a test of the mock rather than the module.         |
+| [`rdj/no-object-parameters`](docs/rules/no-object-parameters.md)                                           | The bare `object` type on a function input.                               |
+| [`rdj/no-reduce-accumulator-copy`](docs/rules/no-reduce-accumulator-copy.md)                               | Spreading the accumulator inside `reduce`, quadratic by construction.     |
+| [`rdj/no-reflect-apply`](docs/rules/no-reflect-apply.md)                                                   | `Reflect.apply`, a call the types cannot follow.                          |
+| [`rdj/no-reflect-get`](docs/rules/no-reflect-get.md)                                                       | `Reflect.get`, a property read the types cannot follow.                   |
+| [`rdj/no-runtime-typeof`](docs/rules/no-runtime-typeof.md)                                                 | `typeof` as a substitute for parsing input at its boundary.               |
+| [`rdj/no-shape-in-symbol-names`](docs/rules/no-shape-in-symbol-names.md)                                   | "shape" in a symbol name, structure in place of a domain role.            |
+| [`rdj/no-unknown-parameters`](docs/rules/no-unknown-parameters.md)                                         | `unknown` on a function input.                                            |
+| [`rdj/no-unknown-returns`](docs/rules/no-unknown-returns.md)                                               | `unknown` on a function output.                                           |
+| [`rdj/no-unknown-type-aliases`](docs/rules/no-unknown-type-aliases.md)                                     | A type alias that resolves to `unknown`.                                  |
+| [`rdj/no-unsafe-dictionary-type`](docs/rules/no-unsafe-dictionary-type.md)                                 | A dictionary whose values are `unknown`, `any` or `object`.               |
+| [`rdj/no-use-effect`](docs/rules/no-use-effect.md)                                                         | Every `useEffect` and `useLayoutEffect` call or import.                   |
+| [`rdj/no-widen-then-assert`](docs/rules/no-widen-then-assert.md)                                           | Widening a value and asserting it back.                                   |
+| [`rdj/require-safety-comment-for-type-assertion`](docs/rules/require-safety-comment-for-type-assertion.md) | An assertion with no `SAFETY:` line naming the invariant.                 |
+| [`rdj/static-public-env`](docs/rules/static-public-env.md)                                                 | Any `process.env` read but `process.env.NAME`, the one form Expo inlines. |
+
+### Options
+
+- `rdj/no-use-effect` takes `{ hint?: string }`, appended to every finding, so a project can name
+  its one sanctioned wrapper. `react(files, { useEffectAllowedIn })` sets it and exempts that file.
+- `rdj/no-hardcoded-jsx-text` takes `{ pattern?: string }`, a regex source compiled with `u`. The
+  default `\p{L}{3,}` says three letters in a row is a word; digits, separators and bullets are
+  not. It looks at JSX text and at string literals placed as children, never at attribute values.
+- `rdj/no-runtime-typeof` takes `{ allowInTypeGuards?: boolean }`. `recommended` turns it on: a
+  `typeof` inside a type predicate is the decode the rule asks for, named and reusable.
+- `rdj/static-public-env` has no options.
+
+## Severities are measurements
+
+Land a new rule at `warn`, fix or scope what fires, then promote it. When a rule fires, fix the
+code or add a narrowly scoped override with the measurement that justifies it. Never weaken the
+rule, add a cast, or rename a symbol to dodge the check.

package/dist/config.d.mts

@@ -0,0 +1,113 @@
+//#region src/config.d.ts
+/**
+ * Config data for a consumer's `vite.config.ts` (or `.oxlintrc.ts`).
+ *
+ * The types below are declared locally rather than imported from `oxlint`:
+ * `oxlint` is never a dependency of this package (`vp migrate` strips one, and a
+ * direct dependency installs a second linter beside the Vite+ IDE stub), and a
+ * consumer that installs only `vite-plus` and `@oxlint/plugins` has no
+ * guaranteed path to oxlint's own `.d.ts`. They are structurally compatible with
+ * `OxlintConfig` and `OxlintOverride`, checked by a consumer-shaped config in
+ * `tests/config.test.ts`: arrays are mutable (oxlint's are), and `plugins` is
+ * oxlint's own literal union, because a bare `string[]` is not assignable to it.
+ */
+/** A severity as oxlint spells it in a config; the numeric forms are not used here. */
+type Severity = "off" | "warn" | "error";
+/** A rule entry: a severity, or a severity followed by the rule's own options. */
+type RuleEntry = Severity | [Severity, ...unknown[]];
+interface Rules {
+  [ruleId: string]: RuleEntry;
+}
+/** oxlint's built-in plugins, the values its `plugins` field accepts. */
+type BuiltinPlugin = "eslint" | "import" | "jest" | "jsdoc" | "jsx-a11y" | "nextjs" | "node" | "oxc" | "promise" | "react" | "react-perf" | "typescript" | "unicorn" | "vitest" | "vue";
+interface JsPlugin {
+  name: string;
+  specifier: string;
+}
+export interface Override {
+  files: string[];
+  excludeFiles?: string[];
+  plugins?: BuiltinPlugin[];
+  env?: {
+    [name: string]: boolean;
+  };
+  jsPlugins?: JsPlugin[];
+  rules?: Rules;
+}
+export interface Config {
+  jsPlugins?: JsPlugin[];
+  rules?: Rules;
+  overrides?: Override[];
+}
+/**
+ * The plugin entry. The alias is `rdj`, which is also the prefix in every
+ * diagnostic and every disable comment, so a consumer that renames it renames
+ * its own rule keys too.
+ */
+export declare const plugin: JsPlugin;
+/** Every rule the plugin registers, prefixed. `fixtures()` and the verify bin read this list. */
+export declare const RULE_IDS: readonly ["rdj/no-array-filter-map", "rdj/no-chained-type-assertions", "rdj/no-conditional-empty-object-spread", "rdj/no-hardcoded-jsx-text", "rdj/no-known-value-widening", "rdj/no-module-mocking", "rdj/no-object-parameters", "rdj/no-reduce-accumulator-copy", "rdj/no-reflect-apply", "rdj/no-reflect-get", "rdj/no-runtime-typeof", "rdj/no-shape-in-symbol-names", "rdj/no-unknown-parameters", "rdj/no-unknown-returns", "rdj/no-unknown-type-aliases", "rdj/no-unsafe-dictionary-type", "rdj/no-use-effect", "rdj/no-widen-then-assert", "rdj/require-safety-comment-for-type-assertion", "rdj/static-public-env"];
+export type RuleId = (typeof RULE_IDS)[number];
+/**
+ * The base config, for `lint: { extends: [recommended] }`.
+ *
+ * Measured through `extends` on vite-plus 0.3.1 / oxlint 1.81.0 (2026-09-17):
+ * `jsPlugins`, `rules`, `overrides`, `plugins`, `categories` and `options` are
+ * inherited by the consumer's config, and the consumer's own entries win.
+ * `env`, `settings` and `ignorePatterns` are not inherited, which is why this
+ * object carries none of them and the consumer keeps writing its own.
+ */
+export declare const recommended: Config;
+export interface ReactOptions {
+  /**
+   * The one file allowed to call `useEffect`, as a path. Its name goes into the
+   * `no-use-effect` hint for every React file, and the rule is off for it.
+   */
+  useEffectAllowedIn?: string;
+}
+/**
+ * The React file set: browser globals, the hooks rules, and the compiler's own
+ * judgement. A consumer appends its own entries after these, because an override
+ * that changes a `react/*` rule must repeat `plugins: ["react"]` or oxlint
+ * silently drops the entry.
+ */
+export declare function react(files: string[], options?: ReactOptions): Override[];
+export interface I18nOptions {
+  /**
+   * The word pattern, a regex source compiled with `u`. The rule's default,
+   * `\p{L}{3,}`, reads three letters in a row as a word.
+   */
+  pattern?: string;
+}
+/** Files whose JSX text belongs in a catalogue rather than in the source. */
+export declare function i18n(files: string[], options?: I18nOptions): Override[];
+/** Files Expo's bundler inlines `process.env` into, where only `process.env.NAME` survives. */
+export declare function expo(files: string[]): Override[];
+/** Test files: four rules whose premise a test does not hold. */
+export declare function tests(files: string[]): Override[];
+/**
+ * The view the verify command lints the shipped fixtures through. Without this
+ * override every rule the consumer leaves off reports nothing there, and "no
+ * findings" is exactly what a dead rule looks like.
+ */
+export declare function fixtures(view?: string): Override[];
+/** The formatting both consumers settled on. Spread it and add what is yours. */
+export declare const fmt: {
+  printWidth: number;
+  singleQuote: boolean;
+  semi: boolean;
+  tabWidth: number;
+  useTabs: boolean;
+};
+/**
+ * Paths no linter and no formatter should walk: build output, dependencies, the
+ * directories AI coding agents scribble in, and the Vitest JSON report. Spread
+ * it into `ignorePatterns` and append the repo's own.
+ */
+export declare const ignore: string[];
+/** The pre-commit entry: `vp check --fix` is defined for JS and TS sources, nothing else. */
+export declare const staged: {
+  "*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}": string;
+};
+//#endregion
+//# sourceMappingURL=config.d.mts.map

package/dist/config.mjs

@@ -0,0 +1,218 @@
+//#region src/config.ts
+/**
+* The plugin entry. The alias is `rdj`, which is also the prefix in every
+* diagnostic and every disable comment, so a consumer that renames it renames
+* its own rule keys too.
+*/
+const plugin = {
+	name: "rdj",
+	specifier: "@rdjperron/lint"
+};
+/** Every rule the plugin registers, prefixed. `fixtures()` and the verify bin read this list. */
+const RULE_IDS = [
+	"rdj/no-array-filter-map",
+	"rdj/no-chained-type-assertions",
+	"rdj/no-conditional-empty-object-spread",
+	"rdj/no-hardcoded-jsx-text",
+	"rdj/no-known-value-widening",
+	"rdj/no-module-mocking",
+	"rdj/no-object-parameters",
+	"rdj/no-reduce-accumulator-copy",
+	"rdj/no-reflect-apply",
+	"rdj/no-reflect-get",
+	"rdj/no-runtime-typeof",
+	"rdj/no-shape-in-symbol-names",
+	"rdj/no-unknown-parameters",
+	"rdj/no-unknown-returns",
+	"rdj/no-unknown-type-aliases",
+	"rdj/no-unsafe-dictionary-type",
+	"rdj/no-use-effect",
+	"rdj/no-widen-then-assert",
+	"rdj/require-safety-comment-for-type-assertion",
+	"rdj/static-public-env"
+];
+/**
+* The base config, for `lint: { extends: [recommended] }`.
+*
+* Measured through `extends` on vite-plus 0.3.1 / oxlint 1.81.0 (2026-09-17):
+* `jsPlugins`, `rules`, `overrides`, `plugins`, `categories` and `options` are
+* inherited by the consumer's config, and the consumer's own entries win.
+* `env`, `settings` and `ignorePatterns` are not inherited, which is why this
+* object carries none of them and the consumer keeps writing its own.
+*/
+const recommended = {
+	jsPlugins: [plugin],
+	rules: {
+		"rdj/no-array-filter-map": "error",
+		"rdj/no-chained-type-assertions": "error",
+		"rdj/no-conditional-empty-object-spread": "error",
+		"rdj/no-known-value-widening": "error",
+		"rdj/no-module-mocking": "error",
+		"rdj/no-object-parameters": "error",
+		"rdj/no-reduce-accumulator-copy": "error",
+		"rdj/no-reflect-apply": "error",
+		"rdj/no-reflect-get": "error",
+		"rdj/no-runtime-typeof": ["error", { allowInTypeGuards: true }],
+		"rdj/no-shape-in-symbol-names": "error",
+		"rdj/no-unknown-parameters": "error",
+		"rdj/no-unknown-returns": "error",
+		"rdj/no-unknown-type-aliases": "error",
+		"rdj/no-unsafe-dictionary-type": "error",
+		"rdj/no-widen-then-assert": "error",
+		"rdj/require-safety-comment-for-type-assertion": "error",
+		"rdj/no-use-effect": "error",
+		"typescript/no-floating-promises": "error",
+		"typescript/no-misused-promises": "error",
+		"typescript/await-thenable": "error",
+		"typescript/no-unnecessary-type-assertion": "error",
+		"typescript/no-misused-spread": "error",
+		"typescript/require-array-sort-compare": "error",
+		"typescript/no-explicit-any": "warn",
+		"prefer-const": ["error", { destructuring: "all" }],
+		"no-unused-vars": ["error", {
+			argsIgnorePattern: "^_",
+			varsIgnorePattern: "^_"
+		}],
+		"no-underscore-dangle": "off",
+		eqeqeq: [
+			"error",
+			"always",
+			{ null: "ignore" }
+		],
+		"typescript/no-unsafe-type-assertion": "off",
+		"no-await-in-loop": "off",
+		"unicorn/consistent-function-scoping": "off",
+		"promise/always-return": "off"
+	}
+};
+/**
+* The React file set: browser globals, the hooks rules, and the compiler's own
+* judgement. A consumer appends its own entries after these, because an override
+* that changes a `react/*` rule must repeat `plugins: ["react"]` or oxlint
+* silently drops the entry.
+*/
+function react(files, options = {}) {
+	const { useEffectAllowedIn } = options;
+	const rules = {
+		"react/rules-of-hooks": "error",
+		"react/exhaustive-deps": "warn",
+		"react/react-in-jsx-scope": "off",
+		"react/immutability": "error",
+		"react/refs": "error",
+		"react/purity": "error",
+		"react/only-export-components": "error"
+	};
+	const overrides = [{
+		files,
+		plugins: ["react"],
+		env: { browser: true },
+		rules
+	}];
+	if (useEffectAllowedIn !== void 0) {
+		rules["rdj/no-use-effect"] = ["error", { hint: `The one sanctioned wrapper is ${useEffectAllowedIn}.` }];
+		overrides.push({
+			files: [useEffectAllowedIn],
+			rules: { "rdj/no-use-effect": "off" }
+		});
+	}
+	return overrides;
+}
+/** Files whose JSX text belongs in a catalogue rather than in the source. */
+function i18n(files, options = {}) {
+	const { pattern } = options;
+	return [{
+		files,
+		rules: { "rdj/no-hardcoded-jsx-text": pattern === void 0 ? "error" : ["error", { pattern }] }
+	}];
+}
+/** Files Expo's bundler inlines `process.env` into, where only `process.env.NAME` survives. */
+function expo(files) {
+	return [{
+		files,
+		rules: { "rdj/static-public-env": "error" }
+	}];
+}
+/** Test files: four rules whose premise a test does not hold. */
+function tests(files) {
+	return [{
+		files,
+		rules: {
+			"typescript/no-explicit-any": "off",
+			"typescript/no-non-null-assertion": "off",
+			"rdj/no-runtime-typeof": "off",
+			"rdj/require-safety-comment-for-type-assertion": "off"
+		}
+	}];
+}
+/** Every rule of the plugin at `error`, so none of them can be missing from the list. */
+const FIXTURE_RULES = {
+	"rdj/no-array-filter-map": "error",
+	"rdj/no-chained-type-assertions": "error",
+	"rdj/no-conditional-empty-object-spread": "error",
+	"rdj/no-hardcoded-jsx-text": "error",
+	"rdj/no-known-value-widening": "error",
+	"rdj/no-module-mocking": "error",
+	"rdj/no-object-parameters": "error",
+	"rdj/no-reduce-accumulator-copy": "error",
+	"rdj/no-reflect-apply": "error",
+	"rdj/no-reflect-get": "error",
+	"rdj/no-runtime-typeof": "error",
+	"rdj/no-shape-in-symbol-names": "error",
+	"rdj/no-unknown-parameters": "error",
+	"rdj/no-unknown-returns": "error",
+	"rdj/no-unknown-type-aliases": "error",
+	"rdj/no-unsafe-dictionary-type": "error",
+	"rdj/no-use-effect": "error",
+	"rdj/no-widen-then-assert": "error",
+	"rdj/require-safety-comment-for-type-assertion": "error",
+	"rdj/static-public-env": "error"
+};
+/**
+* The view the verify command lints the shipped fixtures through. Without this
+* override every rule the consumer leaves off reports nothing there, and "no
+* findings" is exactly what a dead rule looks like.
+*/
+function fixtures(view = "scripts/.lint-fixtures/**") {
+	return [{
+		files: [view],
+		rules: { ...FIXTURE_RULES }
+	}];
+}
+/** The formatting both consumers settled on. Spread it and add what is yours. */
+const fmt = {
+	printWidth: 100,
+	singleQuote: false,
+	semi: true,
+	tabWidth: 2,
+	useTabs: false
+};
+/**
+* Paths no linter and no formatter should walk: build output, dependencies, the
+* directories AI coding agents scribble in, and the Vitest JSON report. Spread
+* it into `ignorePatterns` and append the repo's own.
+*/
+const ignore = [
+	"node_modules/**",
+	"**/node_modules/**",
+	"dist/**",
+	"**/dist/**",
+	...[
+		".agents",
+		".claude",
+		".codex",
+		".continue",
+		".cursor",
+		".gemini",
+		".opencode",
+		".pi",
+		".roo",
+		".windsurf"
+	].flatMap((dir) => [`${dir}/**`, `**/${dir}/**`]),
+	"**/test-results.json"
+];
+/** The pre-commit entry: `vp check --fix` is defined for JS and TS sources, nothing else. */
+const staged = { "*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}": "vp check --fix" };
+//#endregion
+export { RULE_IDS, expo, fixtures, fmt, i18n, ignore, plugin, react, recommended, staged, tests };
+
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../src/config.ts"],"sourcesContent":["/**\n * Config data for a consumer's `vite.config.ts` (or `.oxlintrc.ts`).\n *\n * The types below are declared locally rather than imported from `oxlint`:\n * `oxlint` is never a dependency of this package (`vp migrate` strips one, and a\n * direct dependency installs a second linter beside the Vite+ IDE stub), and a\n * consumer that installs only `vite-plus` and `@oxlint/plugins` has no\n * guaranteed path to oxlint's own `.d.ts`. They are structurally compatible with\n * `OxlintConfig` and `OxlintOverride`, checked by a consumer-shaped config in\n * `tests/config.test.ts`: arrays are mutable (oxlint's are), and `plugins` is\n * oxlint's own literal union, because a bare `string[]` is not assignable to it.\n */\n\n/** A severity as oxlint spells it in a config; the numeric forms are not used here. */\ntype Severity = \"off\" | \"warn\" | \"error\";\n\n/** A rule entry: a severity, or a severity followed by the rule's own options. */\ntype RuleEntry = Severity | [Severity, ...unknown[]];\n\ninterface Rules {\n  [ruleId: string]: RuleEntry;\n}\n\n/** oxlint's built-in plugins, the values its `plugins` field accepts. */\ntype BuiltinPlugin =\n  | \"eslint\"\n  | \"import\"\n  | \"jest\"\n  | \"jsdoc\"\n  | \"jsx-a11y\"\n  | \"nextjs\"\n  | \"node\"\n  | \"oxc\"\n  | \"promise\"\n  | \"react\"\n  | \"react-perf\"\n  | \"typescript\"\n  | \"unicorn\"\n  | \"vitest\"\n  | \"vue\";\n\ninterface JsPlugin {\n  name: string;\n  specifier: string;\n}\n\nexport interface Override {\n  files: string[];\n  excludeFiles?: string[];\n  plugins?: BuiltinPlugin[];\n  env?: { [name: string]: boolean };\n  jsPlugins?: JsPlugin[];\n  rules?: Rules;\n}\n\nexport interface Config {\n  jsPlugins?: JsPlugin[];\n  rules?: Rules;\n  overrides?: Override[];\n}\n\n/**\n * The plugin entry. The alias is `rdj`, which is also the prefix in every\n * diagnostic and every disable comment, so a consumer that renames it renames\n * its own rule keys too.\n */\nexport const plugin: JsPlugin = { name: \"rdj\", specifier: \"@rdjperron/lint\" };\n\n/** Every rule the plugin registers, prefixed. `fixtures()` and the verify bin read this list. */\nexport const RULE_IDS = [\n  \"rdj/no-array-filter-map\",\n  \"rdj/no-chained-type-assertions\",\n  \"rdj/no-conditional-empty-object-spread\",\n  \"rdj/no-hardcoded-jsx-text\",\n  \"rdj/no-known-value-widening\",\n  \"rdj/no-module-mocking\",\n  \"rdj/no-object-parameters\",\n  \"rdj/no-reduce-accumulator-copy\",\n  \"rdj/no-reflect-apply\",\n  \"rdj/no-reflect-get\",\n  \"rdj/no-runtime-typeof\",\n  \"rdj/no-shape-in-symbol-names\",\n  \"rdj/no-unknown-parameters\",\n  \"rdj/no-unknown-returns\",\n  \"rdj/no-unknown-type-aliases\",\n  \"rdj/no-unsafe-dictionary-type\",\n  \"rdj/no-use-effect\",\n  \"rdj/no-widen-then-assert\",\n  \"rdj/require-safety-comment-for-type-assertion\",\n  \"rdj/static-public-env\",\n] as const;\n\nexport type RuleId = (typeof RULE_IDS)[number];\n\n/**\n * The base config, for `lint: { extends: [recommended] }`.\n *\n * Measured through `extends` on vite-plus 0.3.1 / oxlint 1.81.0 (2026-09-17):\n * `jsPlugins`, `rules`, `overrides`, `plugins`, `categories` and `options` are\n * inherited by the consumer's config, and the consumer's own entries win.\n * `env`, `settings` and `ignorePatterns` are not inherited, which is why this\n * object carries none of them and the consumer keeps writing its own.\n */\nexport const recommended: Config = {\n  jsPlugins: [plugin],\n  rules: {\n    // The anti-slop rules. Measured on stack-lab 2026-08-20 and 2026-09-13, and\n    // on rummy 2026-09-16 (vite-plus 0.3.1, oxlint 1.81.0): on real hand-written\n    // code they fire only on the patterns they exist to reject, so a hit is the\n    // finding. Land a new one at `warn` in the consumer, fix or scope what\n    // fires, then let this default take over.\n    \"rdj/no-array-filter-map\": \"error\",\n    \"rdj/no-chained-type-assertions\": \"error\",\n    \"rdj/no-conditional-empty-object-spread\": \"error\",\n    \"rdj/no-known-value-widening\": \"error\",\n    \"rdj/no-module-mocking\": \"error\",\n    \"rdj/no-object-parameters\": \"error\",\n    \"rdj/no-reduce-accumulator-copy\": \"error\",\n    \"rdj/no-reflect-apply\": \"error\",\n    \"rdj/no-reflect-get\": \"error\",\n    // A `typeof` inside a type predicate is the decode the rule asks for, named\n    // and reusable, and the pack already exempts a predicate's subject from\n    // `no-unknown-parameters` (rummy, 2026-09-16).\n    \"rdj/no-runtime-typeof\": [\"error\", { allowInTypeGuards: true }],\n    \"rdj/no-shape-in-symbol-names\": \"error\",\n    \"rdj/no-unknown-parameters\": \"error\",\n    \"rdj/no-unknown-returns\": \"error\",\n    \"rdj/no-unknown-type-aliases\": \"error\",\n    \"rdj/no-unsafe-dictionary-type\": \"error\",\n    \"rdj/no-widen-then-assert\": \"error\",\n    \"rdj/require-safety-comment-for-type-assertion\": \"error\",\n    // Derived state, event handlers and a reactive query cover every case; the\n    // one sanctioned wrapper is named through `react(files, { useEffectAllowedIn })`.\n    \"rdj/no-use-effect\": \"error\",\n\n    // `no-hardcoded-jsx-text` and `static-public-env` are absent on purpose:\n    // they belong to a translated app and to an Expo app. `i18n()` and `expo()`\n    // switch them on for the files that want them.\n\n    // Type-aware rules; they need `options.typeAware` in the consumer's config.\n    \"typescript/no-floating-promises\": \"error\",\n    \"typescript/no-misused-promises\": \"error\",\n    \"typescript/await-thenable\": \"error\",\n    // Measured on rummy 2026-09-16 before the cleanup: 5, 5 and 1 hits, zero after.\n    \"typescript/no-unnecessary-type-assertion\": \"error\",\n    \"typescript/no-misused-spread\": \"error\",\n    \"typescript/require-array-sort-compare\": \"error\",\n    \"typescript/no-explicit-any\": \"warn\",\n\n    \"prefer-const\": [\"error\", { destructuring: \"all\" }],\n    \"no-unused-vars\": [\"error\", { argsIgnorePattern: \"^_\", varsIgnorePattern: \"^_\" }],\n    // oxlint 1.77 moved this into `suspicious`, where it contradicts the `^_`\n    // convention above. The prefix wins.\n    \"no-underscore-dangle\": \"off\",\n    eqeqeq: [\"error\", \"always\", { null: \"ignore\" }],\n\n    // Deliberate off-switches, held by both consumers since the 2026-08-20 setup.\n    \"typescript/no-unsafe-type-assertion\": \"off\",\n    \"no-await-in-loop\": \"off\",\n    \"unicorn/consistent-function-scoping\": \"off\",\n    \"promise/always-return\": \"off\",\n  },\n};\n\nexport interface ReactOptions {\n  /**\n   * The one file allowed to call `useEffect`, as a path. Its name goes into the\n   * `no-use-effect` hint for every React file, and the rule is off for it.\n   */\n  useEffectAllowedIn?: string;\n}\n\n/**\n * The React file set: browser globals, the hooks rules, and the compiler's own\n * judgement. A consumer appends its own entries after these, because an override\n * that changes a `react/*` rule must repeat `plugins: [\"react\"]` or oxlint\n * silently drops the entry.\n */\nexport function react(files: string[], options: ReactOptions = {}): Override[] {\n  const { useEffectAllowedIn } = options;\n  const rules: Rules = {\n    \"react/rules-of-hooks\": \"error\",\n    \"react/exhaustive-deps\": \"warn\",\n    // React 19 and the automatic JSX runtime: nothing has to be in scope.\n    \"react/react-in-jsx-scope\": \"off\",\n    // The React Compiler's own rules: a component it silently skips is a\n    // component that never memoizes.\n    \"react/immutability\": \"error\",\n    \"react/refs\": \"error\",\n    \"react/purity\": \"error\",\n    // A module that exports only components refreshes in place; any other\n    // export re-runs every importer.\n    \"react/only-export-components\": \"error\",\n  };\n  const overrides: Override[] = [{ files, plugins: [\"react\"], env: { browser: true }, rules }];\n\n  if (useEffectAllowedIn !== undefined) {\n    rules[\"rdj/no-use-effect\"] = [\n      \"error\",\n      { hint: `The one sanctioned wrapper is ${useEffectAllowedIn}.` },\n    ];\n    overrides.push({\n      // The sanctioned wrapper exists precisely so every other file can be clean.\n      files: [useEffectAllowedIn],\n      rules: { \"rdj/no-use-effect\": \"off\" },\n    });\n  }\n\n  return overrides;\n}\n\nexport interface I18nOptions {\n  /**\n   * The word pattern, a regex source compiled with `u`. The rule's default,\n   * `\\p{L}{3,}`, reads three letters in a row as a word.\n   */\n  pattern?: string;\n}\n\n/** Files whose JSX text belongs in a catalogue rather than in the source. */\nexport function i18n(files: string[], options: I18nOptions = {}): Override[] {\n  const { pattern } = options;\n  return [\n    {\n      files,\n      rules: {\n        \"rdj/no-hardcoded-jsx-text\": pattern === undefined ? \"error\" : [\"error\", { pattern }],\n      },\n    },\n  ];\n}\n\n/** Files Expo's bundler inlines `process.env` into, where only `process.env.NAME` survives. */\nexport function expo(files: string[]): Override[] {\n  return [{ files, rules: { \"rdj/static-public-env\": \"error\" } }];\n}\n\n/** Test files: four rules whose premise a test does not hold. */\nexport function tests(files: string[]): Override[] {\n  return [\n    {\n      files,\n      rules: {\n        // A fixture is allowed to be the wrong type on purpose.\n        \"typescript/no-explicit-any\": \"off\",\n        \"typescript/no-non-null-assertion\": \"off\",\n        // `expect(typeof x).toBe(\"function\")` reads as an unparsed boundary, but\n        // asserting the shape of your own public API is the point of the assertion.\n        \"rdj/no-runtime-typeof\": \"off\",\n        // A justification on every assertion in a test is noise (53 measured on\n        // rummy, 2026-09-16).\n        \"rdj/require-safety-comment-for-type-assertion\": \"off\",\n      },\n    },\n  ];\n}\n\n/** Every rule of the plugin at `error`, so none of them can be missing from the list. */\nconst FIXTURE_RULES = {\n  \"rdj/no-array-filter-map\": \"error\",\n  \"rdj/no-chained-type-assertions\": \"error\",\n  \"rdj/no-conditional-empty-object-spread\": \"error\",\n  \"rdj/no-hardcoded-jsx-text\": \"error\",\n  \"rdj/no-known-value-widening\": \"error\",\n  \"rdj/no-module-mocking\": \"error\",\n  \"rdj/no-object-parameters\": \"error\",\n  \"rdj/no-reduce-accumulator-copy\": \"error\",\n  \"rdj/no-reflect-apply\": \"error\",\n  \"rdj/no-reflect-get\": \"error\",\n  \"rdj/no-runtime-typeof\": \"error\",\n  \"rdj/no-shape-in-symbol-names\": \"error\",\n  \"rdj/no-unknown-parameters\": \"error\",\n  \"rdj/no-unknown-returns\": \"error\",\n  \"rdj/no-unknown-type-aliases\": \"error\",\n  \"rdj/no-unsafe-dictionary-type\": \"error\",\n  \"rdj/no-use-effect\": \"error\",\n  \"rdj/no-widen-then-assert\": \"error\",\n  \"rdj/require-safety-comment-for-type-assertion\": \"error\",\n  \"rdj/static-public-env\": \"error\",\n} satisfies Record<RuleId, \"error\">;\n\n/**\n * The view the verify command lints the shipped fixtures through. Without this\n * override every rule the consumer leaves off reports nothing there, and \"no\n * findings\" is exactly what a dead rule looks like.\n */\nexport function fixtures(view = \"scripts/.lint-fixtures/**\"): Override[] {\n  return [{ files: [view], rules: { ...FIXTURE_RULES } }];\n}\n\n/** The formatting both consumers settled on. Spread it and add what is yours. */\nexport const fmt = {\n  printWidth: 100,\n  singleQuote: false,\n  semi: true,\n  tabWidth: 2,\n  useTabs: false,\n};\n\n/**\n * Paths no linter and no formatter should walk: build output, dependencies, the\n * directories AI coding agents scribble in, and the Vitest JSON report. Spread\n * it into `ignorePatterns` and append the repo's own.\n */\nexport const ignore: string[] = [\n  \"node_modules/**\",\n  \"**/node_modules/**\",\n  \"dist/**\",\n  \"**/dist/**\",\n  ...[\n    \".agents\",\n    \".claude\",\n    \".codex\",\n    \".continue\",\n    \".cursor\",\n    \".gemini\",\n    \".opencode\",\n    \".pi\",\n    \".roo\",\n    \".windsurf\",\n  ].flatMap((dir) => [`${dir}/**`, `**/${dir}/**`]),\n  \"**/test-results.json\",\n];\n\n/** The pre-commit entry: `vp check --fix` is defined for JS and TS sources, nothing else. */\nexport const staged = {\n  \"*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}\": \"vp check --fix\",\n};\n"],"mappings":"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"}

package/dist/index.d.mts

@@ -0,0 +1,5 @@
+//#region src/index.d.ts
+declare const rdjPlugin: import("@oxlint/plugins").Plugin;
+//#endregion
+export { rdjPlugin as default };
+//# sourceMappingURL=index.d.mts.map