@himynameisdave/oxlint-config 1.0.0

package/dist/index.js

@@ -0,0 +1,23 @@
+import { defineConfig } from 'oxlint';
+import base from './base.js';
+import svelte from './svelte.js';
+import typeAware from './type-aware.js';
+import vitest from './vitest.js';
+export { default as base } from './base.js';
+export { default as svelte } from './svelte.js';
+export { default as typeAware } from './type-aware.js';
+export { default as vitest } from './vitest.js';
+/**
+ * Kitchen sink: base + svelte + vitest + type-aware, in override-safe order.
+ * Requires `oxlint-tsgolint` installed (type-aware rules are on).
+ *
+ * For à la carte composition, extend the named exports instead:
+ *
+ * ```ts
+ * import base from "@himynameisdave/oxlint-config/base";
+ * export default defineConfig({ extends: [base] });
+ * ```
+ */
+export default defineConfig({
+    extends: [base, svelte, vitest, typeAware]
+});

package/dist/svelte.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Svelte overrides: rule adjustments for `.svelte` (and `.svelte.ts`/`.svelte.js`
+ * rune modules).
+ *
+ * **Svelte 5 (runes) only.** Svelte 4 / legacy-mode syntax errors on purpose: `$:`
+ * reactive statements trip `eslint/no-labels` and `export let` props trip
+ * `import/no-mutable-exports`. See the "Svelte support" section of the README for the
+ * exact rules to relax if you still ship legacy components.
+ *
+ * Extend AFTER base so these overrides win:
+ *
+ * ```ts
+ * export default defineConfig({ extends: [base, svelte] });
+ * ```
+ */
+declare const _default: {
+    overrides: {
+        files: string[];
+        rules: {
+            'eslint/prefer-const': "off";
+            'eslint/prefer-destructuring': "off";
+            'eslint/max-classes-per-file': "off";
+            'import/no-namespace': "off";
+        };
+    }[];
+};
+export default _default;

package/dist/svelte.js

@@ -0,0 +1,35 @@
+import { defineConfig } from 'oxlint';
+/**
+ * Svelte overrides: rule adjustments for `.svelte` (and `.svelte.ts`/`.svelte.js`
+ * rune modules).
+ *
+ * **Svelte 5 (runes) only.** Svelte 4 / legacy-mode syntax errors on purpose: `$:`
+ * reactive statements trip `eslint/no-labels` and `export let` props trip
+ * `import/no-mutable-exports`. See the "Svelte support" section of the README for the
+ * exact rules to relax if you still ship legacy components.
+ *
+ * Extend AFTER base so these overrides win:
+ *
+ * ```ts
+ * export default defineConfig({ extends: [base, svelte] });
+ * ```
+ */
+export default defineConfig({
+    overrides: [
+        {
+            files: ['**/*.svelte', '**/*.svelte.ts', '**/*.svelte.js'],
+            rules: {
+                // Svelte 5 runes ($state, $derived, $props) declare reactive state with
+                // `let` (the compiler reassigns it), so const-ifying is a false positive.
+                'eslint/prefer-const': 'off',
+                // Rune destructuring (`let { data } = $props()`) trips the same way.
+                'eslint/prefer-destructuring': 'off',
+                // Component modules commonly hold a component + tiny helper classes.
+                'eslint/max-classes-per-file': 'off',
+                // import * as Dialog is the compound-component idiom (shadcn-svelte,
+                // bits-ui): <Dialog.Root><Dialog.Trigger/> needs the namespace.
+                'import/no-namespace': 'off'
+            }
+        }
+    ]
+});

package/dist/type-aware.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Type-aware rules: everything here needs type information, which means the
+ * `oxlint-tsgolint` package installed and linting run with `--type-aware`
+ * (or this file's `options.typeAware` — set below, so extending is enough).
+ *
+ * These are the highest-value rules in the whole config — they catch the bugs
+ * syntax-level linting can't see (floating promises, impossible conditions,
+ * unsound assertions).
+ */
+declare const _default: {
+    options: {
+        typeAware: true;
+    };
+    rules: {
+        'typescript/await-thenable': "error";
+        'typescript/consistent-return': "off";
+        'typescript/consistent-type-exports': "error";
+        'typescript/dot-notation': "error";
+        'typescript/no-array-delete': "error";
+        'typescript/no-base-to-string': "error";
+        'typescript/no-confusing-void-expression': "error";
+        'typescript/no-deprecated': "error";
+        'typescript/no-duplicate-type-constituents': "error";
+        'typescript/no-floating-promises': "error";
+        'typescript/no-for-in-array': "error";
+        'typescript/no-implied-eval': "error";
+        'typescript/no-meaningless-void-operator': "error";
+        'typescript/no-misused-promises': "error";
+        'typescript/no-misused-spread': "error";
+        'typescript/no-mixed-enums': "error";
+        'typescript/no-redundant-type-constituents': "error";
+        'typescript/no-unnecessary-boolean-literal-compare': "error";
+        'typescript/no-unnecessary-condition': "error";
+        'typescript/no-unnecessary-qualifier': "error";
+        'typescript/no-unnecessary-template-expression': "error";
+        'typescript/no-unnecessary-type-arguments': "error";
+        'typescript/no-unnecessary-type-assertion': "error";
+        'typescript/no-unnecessary-type-conversion': "error";
+        'typescript/no-unnecessary-type-parameters': "error";
+        'typescript/no-unsafe-enum-comparison': "error";
+        'typescript/no-unsafe-unary-minus': "error";
+        'typescript/no-useless-default-assignment': "error";
+        'typescript/non-nullable-type-assertion-style': "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-readonly': "error";
+        'typescript/prefer-readonly-parameter-types': ["error", {
+            ignoreInferredTypes: true;
+            allow: {
+                from: "lib";
+                name: string;
+            }[];
+        }];
+        'typescript/prefer-reduce-type-parameter': "error";
+        'typescript/prefer-regexp-exec': "error";
+        'typescript/prefer-return-this-type': "error";
+        'typescript/prefer-string-starts-ends-with': "error";
+        'typescript/promise-function-async': "error";
+        'typescript/related-getter-setter-pairs': "error";
+        'typescript/require-array-sort-compare': "error";
+        'typescript/require-await': "off";
+        'typescript/restrict-plus-operands': "error";
+        'typescript/restrict-template-expressions': "error";
+        'typescript/return-await': ["error", "in-try-catch"];
+        'typescript/strict-boolean-expressions': "off";
+        'typescript/strict-void-return': "error";
+        'typescript/switch-exhaustiveness-check': "error";
+        'typescript/unbound-method': "error";
+        'typescript/use-unknown-in-catch-callback-variable': "error";
+        'typescript/no-unsafe-argument': "off";
+        'typescript/no-unsafe-assignment': "off";
+        'typescript/no-unsafe-call': "off";
+        'typescript/no-unsafe-member-access': "off";
+        'typescript/no-unsafe-return': "off";
+        'typescript/no-unsafe-type-assertion': "off";
+        'eslint/no-implied-eval': "off";
+        'eslint/no-throw-literal': "off";
+        'eslint/prefer-promise-reject-errors': "off";
+        'unicorn/prefer-array-find': "off";
+        'unicorn/prefer-includes': "off";
+        'unicorn/prefer-string-starts-ends-with': "off";
+    };
+};
+export default _default;

package/dist/type-aware.js

@@ -0,0 +1,189 @@
+import { defineConfig } from 'oxlint';
+/**
+ * Type-aware rules: everything here needs type information, which means the
+ * `oxlint-tsgolint` package installed and linting run with `--type-aware`
+ * (or this file's `options.typeAware` — set below, so extending is enough).
+ *
+ * These are the highest-value rules in the whole config — they catch the bugs
+ * syntax-level linting can't see (floating promises, impossible conditions,
+ * unsound assertions).
+ */
+export default defineConfig({
+    options: {
+        typeAware: true
+    },
+    rules: {
+        // await on a non-Thenable is dead syntax that implies async behavior.
+        'typescript/await-thenable': 'error',
+        // tsconfig's noImplicitReturns enforces this at compile time with fewer false positives.
+        'typescript/consistent-return': 'off',
+        // export type for type-only exports — keeps them erasable by any transpiler.
+        'typescript/consistent-type-exports': 'error',
+        // obj["key"] for a statically-known key is obj.key.
+        'typescript/dot-notation': 'error',
+        // NOTE: tsgolint also implements naming-convention and prefer-destructuring,
+        // but oxlint 1.75 doesn't register those rule names yet — add them here once
+        // they land upstream.
+        // delete arr[i] leaves a hole, not a shorter array — splice/filter instead.
+        'typescript/no-array-delete': 'error',
+        // `${object}` renders "[object Object]" — the type system knows and can stop it.
+        'typescript/no-base-to-string': 'error',
+        // const x = voidFn() assigns undefined while looking meaningful.
+        'typescript/no-confusing-void-expression': 'error',
+        // Using @deprecated APIs is scheduled breakage; migrate at lint time, not upgrade time.
+        'typescript/no-deprecated': 'error',
+        // string | string unions signal a broken type expression.
+        'typescript/no-duplicate-type-constituents': 'error',
+        // An unawaited promise swallows its rejection — the #1 async bug this stack catches.
+        'typescript/no-floating-promises': 'error',
+        // for-in over an array iterates string keys and prototype pollution.
+        'typescript/no-for-in-array': 'error',
+        // setTimeout("string") — the type-aware twin of the base rule (see off below).
+        'typescript/no-implied-eval': 'error',
+        // void x to discard a value the type system says is already void.
+        'typescript/no-meaningless-void-operator': 'error',
+        // A promise where a boolean/void is expected (if (asyncCheck()) — always truthy).
+        'typescript/no-misused-promises': 'error',
+        // Spreading a Promise/function/Map into an object silently produces garbage.
+        'typescript/no-misused-spread': 'error',
+        // Enums mixing string and number members defeat both mental models.
+        'typescript/no-mixed-enums': 'error',
+        // `string | never` and friends — a constituent that changes nothing signals a typo.
+        'typescript/no-redundant-type-constituents': 'error',
+        // x === true on a boolean is x.
+        'typescript/no-unnecessary-boolean-literal-compare': 'error',
+        // A condition the types prove always-true/false is dead code or a wrong type.
+        'typescript/no-unnecessary-condition': 'error',
+        // Namespace.member where member is already in scope.
+        'typescript/no-unnecessary-qualifier': 'error',
+        // `${"literal"}` — a template around nothing dynamic.
+        'typescript/no-unnecessary-template-expression': 'error',
+        // Type args matching the defaults restate the obvious.
+        'typescript/no-unnecessary-type-arguments': 'error',
+        // `as T` where the value is already T teaches readers to ignore assertions.
+        'typescript/no-unnecessary-type-assertion': 'error',
+        // String(alreadyString) — conversion of a value already that type.
+        'typescript/no-unnecessary-type-conversion': 'error',
+        // A type param used once constrains nothing — inline it.
+        'typescript/no-unnecessary-type-parameters': 'error',
+        // enumValue === "raw string" bypasses the enum's whole point.
+        'typescript/no-unsafe-enum-comparison': 'error',
+        // Unary minus on non-numbers produces NaN silently.
+        'typescript/no-unsafe-unary-minus': 'error',
+        // param = defaultValue where the type already guarantees non-undefined.
+        'typescript/no-useless-default-assignment': 'error',
+        // x as T where x! expresses exactly "remove null" — say the narrower thing.
+        'typescript/non-nullable-type-assertion-style': 'error',
+        // throw of non-Error values loses stack traces (type-aware big sibling of
+        // eslint/no-throw-literal, which is off below).
+        'typescript/only-throw-error': 'error',
+        // filter(...)[0] over the whole array; find stops early (supersedes unicorn's twin, off below).
+        'typescript/prefer-find': 'error',
+        // indexOf !== -1 is includes, with types (supersedes unicorn's twin, off below).
+        'typescript/prefer-includes': 'error',
+        // || treats 0/"" as missing; ?? means "nullish only". A/B disagreed — stricter B wins.
+        'typescript/prefer-nullish-coalescing': 'error',
+        // a && a.b chains have an a?.b spelling that can't typo the guard.
+        'typescript/prefer-optional-chain': 'error',
+        // Rejections must be Errors for stacks (supersedes eslint/prefer-promise-reject-errors below).
+        'typescript/prefer-promise-reject-errors': 'error',
+        // A private field never reassigned is readonly — let the type say so.
+        'typescript/prefer-readonly': 'error',
+        // Parameters you don't mutate should say so — readonly params make mutation
+        // a visible API decision. ignoreInferredTypes spares callback params; the allow
+        // list exempts inherently-mutable platform types. Consumers append their own
+        // framework types (RequestEvent, Page, ...) via their overrides.
+        'typescript/prefer-readonly-parameter-types': [
+            'error',
+            {
+                ignoreInferredTypes: true,
+                allow: [
+                    { from: 'lib', name: 'Date' },
+                    { from: 'lib', name: 'URL' },
+                    { from: 'lib', name: 'URLSearchParams' },
+                    { from: 'lib', name: 'FormData' },
+                    { from: 'lib', name: 'Request' },
+                    { from: 'lib', name: 'Response' },
+                    { from: 'lib', name: 'Headers' },
+                    { from: 'lib', name: 'RegExp' }
+                ]
+            }
+        ],
+        // reduce<T>(...) over reduce(...) as T — the type param checks, the cast lies.
+        'typescript/prefer-reduce-type-parameter': 'error',
+        // exec() over match() for single-match regexes — same result, no branching on flags.
+        'typescript/prefer-regexp-exec': 'error',
+        // Chainable methods returning `this` should say `this`, not the class name.
+        'typescript/prefer-return-this-type': 'error',
+        // startsWith over regex/indexOf checks, with types confirming string-ness
+        // (supersedes unicorn's twin, off below).
+        'typescript/prefer-string-starts-ends-with': 'error',
+        // A function returning Promise should be async — the keyword is the documentation.
+        'typescript/promise-function-async': 'error',
+        // A getter/setter pair with mismatched types breaks obj.x = obj.x.
+        'typescript/related-getter-setter-pairs': 'error',
+        // sort() without a comparator sorts numbers as strings ([1, 10, 2]).
+        'typescript/require-array-sort-compare': 'error',
+        // async-without-await wrappers are common API-uniformity tools (off per smallreads).
+        'typescript/require-await': 'off',
+        // "str" + num coercion — make the conversion explicit.
+        'typescript/restrict-plus-operands': 'error',
+        // `${obj}` in templates — same [object Object] family as no-base-to-string.
+        'typescript/restrict-template-expressions': 'error',
+        // `return promise` inside try/catch returns before it can reject, so the catch
+        // never runs: that's a real bug, not a style choice. in-try-catch mode targets
+        // only that case (verified: it does not fire on a plain return outside try/catch).
+        'typescript/return-await': ['error', 'in-try-catch'],
+        // if (str) conflating "" with absence is idiomatic JS; requiring !== "" everywhere
+        // fights the language (off per smallreads).
+        'typescript/strict-boolean-expressions': 'off',
+        // Returning a value from a void-typed callback gets silently discarded.
+        'typescript/strict-void-return': 'error',
+        // A switch on a union that misses a member compiles today, breaks when the union grows.
+        'typescript/switch-exhaustiveness-check': 'error',
+        // Passing obj.method unbound loses `this` at the callsite.
+        'typescript/unbound-method': 'error',
+        // catch (e: unknown) in callbacks — forces narrowing instead of assuming Error.
+        'typescript/use-unknown-in-catch-callback-variable': 'error',
+        /* ------------------------------------------------------------------ *
+         * The unsafe-* family: all off. They exist to quarantine `any`, but
+         * no-explicit-any already bans introducing it — what remains is `any`
+         * leaking from third-party APIs, where these produce walls of noise
+         * at every boundary (both source configs agree).
+         * ------------------------------------------------------------------ */
+        // any as a function argument.
+        'typescript/no-unsafe-argument': 'off',
+        // Assigning an any value.
+        'typescript/no-unsafe-assignment': 'off',
+        // Calling an any value.
+        'typescript/no-unsafe-call': 'off',
+        // Member access on an any value.
+        'typescript/no-unsafe-member-access': 'off',
+        // Returning an any value.
+        'typescript/no-unsafe-return': 'off',
+        // Bans any `as` cast that isn't provably safe: fires even without `any`
+        // involved (verified: `wide as Narrow` errors with no `any` in sight), so
+        // it isn't really part of the any-quarantine family above, despite sitting
+        // beside it. Off because boundary casts (JSON.parse(...) as T, DOM node casts)
+        // are unavoidable in app code; tests exempt it anyway in base's override.
+        // Revisit if #6's dogfood data ever shows a low hit count on real code.
+        'typescript/no-unsafe-type-assertion': 'off',
+        /* ------------------------------------------------------------------ *
+         * Base-rule handoffs: the type-aware extension version above replaces
+         * the syntax-only base rule, so turn the base one off to avoid double
+         * reports on the same line.
+         * ------------------------------------------------------------------ */
+        // Superseded by typescript/no-implied-eval.
+        'eslint/no-implied-eval': 'off',
+        // Superseded by typescript/only-throw-error.
+        'eslint/no-throw-literal': 'off',
+        // Superseded by typescript/prefer-promise-reject-errors.
+        'eslint/prefer-promise-reject-errors': 'off',
+        // Superseded by typescript/prefer-find.
+        'unicorn/prefer-array-find': 'off',
+        // Superseded by typescript/prefer-includes.
+        'unicorn/prefer-includes': 'off',
+        // Superseded by typescript/prefer-string-starts-ends-with.
+        'unicorn/prefer-string-starts-ends-with': 'off'
+    }
+});

package/dist/vitest.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Vitest add-on: every rule from oxlint's `vitest` plugin, decided explicitly.
+ * Opt in alongside base if your tests run under Vitest:
+ *
+ * ```ts
+ * export default defineConfig({ extends: [base, vitest] });
+ * ```
+ *
+ * These rules only fire on test-shaped syntax (describe/it/test/expect), so
+ * they are inert in app code; no `files` scoping needed.
+ *
+ * Known limitation: oxlint resolves test functions by import source (`vitest`,
+ * `@jest/globals`) or bare globals. `import { it } from 'bun:test'` is NOT
+ * recognized, so none of these rules fire on bun:test-style suites. Bun users
+ * get no coverage from this add-on until oxlint supports bun:test upstream.
+ */
+declare const _default: {
+    plugins: "vitest"[];
+    rules: {
+        'vitest/expect-expect': "error";
+        'vitest/hoisted-apis-on-top': "error";
+        'vitest/no-conditional-expect': "error";
+        'vitest/no-conditional-tests': "error";
+        'vitest/no-disabled-tests': "error";
+        'vitest/no-focused-tests': "error";
+        'vitest/no-standalone-expect': "error";
+        'vitest/prefer-snapshot-hint': "error";
+        'vitest/require-awaited-expect-poll': "error";
+        'vitest/require-local-test-context-for-concurrent-snapshots': "error";
+        'vitest/require-mock-type-parameters': "error";
+        'vitest/require-to-throw-message': "error";
+        'vitest/valid-describe-callback': "error";
+        'vitest/valid-expect': "error";
+        'vitest/valid-expect-in-promise': "error";
+        'vitest/valid-title': "error";
+        'vitest/warn-todo': "off";
+        'vitest/no-commented-out-tests': "error";
+        'vitest/no-conditional-in-test': "off";
+        'vitest/consistent-each-for': "off";
+        'vitest/consistent-test-filename': "off";
+        'vitest/consistent-test-it': "error";
+        'vitest/consistent-vitest-vi': "error";
+        'vitest/max-expects': "off";
+        'vitest/max-nested-describe': "off";
+        'vitest/no-alias-methods': "error";
+        'vitest/no-duplicate-hooks': "error";
+        'vitest/no-hooks': "off";
+        'vitest/no-identical-title': "error";
+        'vitest/no-import-node-test': "error";
+        'vitest/no-importing-vitest-globals': "off";
+        'vitest/no-interpolation-in-snapshots': "error";
+        'vitest/no-large-snapshots': "off";
+        'vitest/no-mocks-import': "error";
+        'vitest/no-restricted-matchers': "off";
+        'vitest/no-restricted-vi-methods': "off";
+        'vitest/no-test-prefixes': "error";
+        'vitest/no-test-return-statement': "error";
+        'vitest/no-unneeded-async-expect-function': "error";
+        'vitest/padding-around-after-all-blocks': "off";
+        'vitest/padding-around-test-blocks': "off";
+        'vitest/prefer-called-exactly-once-with': "error";
+        'vitest/prefer-called-once': "error";
+        'vitest/prefer-called-times': "off";
+        'vitest/prefer-called-with': "error";
+        'vitest/prefer-comparison-matcher': "error";
+        'vitest/prefer-describe-function-title': "error";
+        'vitest/prefer-each': "error";
+        'vitest/prefer-equality-matcher': "error";
+        'vitest/prefer-expect-assertions': "off";
+        'vitest/prefer-expect-resolves': "error";
+        'vitest/prefer-expect-type-of': "error";
+        'vitest/prefer-hooks-in-order': "error";
+        'vitest/prefer-hooks-on-top': "error";
+        'vitest/prefer-import-in-mock': "error";
+        'vitest/prefer-importing-vitest-globals': "error";
+        'vitest/prefer-lowercase-title': "off";
+        'vitest/prefer-mock-promise-shorthand': "error";
+        'vitest/prefer-mock-return-shorthand': "error";
+        'vitest/prefer-spy-on': "error";
+        'vitest/prefer-strict-boolean-matchers': "error";
+        'vitest/prefer-strict-equal': "error";
+        'vitest/prefer-to-be': "error";
+        'vitest/prefer-to-be-falsy': "off";
+        'vitest/prefer-to-be-object': "off";
+        'vitest/prefer-to-be-truthy': "off";
+        'vitest/prefer-to-contain': "error";
+        'vitest/prefer-to-have-been-called-times': "error";
+        'vitest/prefer-to-have-length': "error";
+        'vitest/prefer-todo': "error";
+        'vitest/require-hook': "off";
+        'vitest/require-top-level-describe': "off";
+        'vitest/require-test-timeout': "off";
+    };
+};
+export default _default;