@ashstack/lint 0.1.0

package/dist/lib/module.d.ts

@@ -0,0 +1,19 @@
+import type { BanGroup, ModuleManifest, RestrictedImports } from "./types.js";
+/**
+ * Identity helper: types the manifest and keeps the shape honest. The returned
+ * object is handed to oxlint as the plugin (it ignores the manifest extras).
+ */
+export declare const defineModule: (manifest: ModuleManifest) => ModuleManifest;
+declare const shortName: (module: ModuleManifest) => string;
+export interface Composed {
+    jsPlugins: string[];
+    rules: Record<string, "error">;
+    restricted: Required<RestrictedImports>;
+}
+/**
+ * Turn manifests + options into the config fragments an entry spreads in:
+ * which plugin files to load, which rules to enable, and the merged import
+ * bans from the enabled modules plus the enabled ban-only groups.
+ */
+export declare const composeModules: (modules: ModuleManifest[], options: Record<string, boolean | undefined>, banGroups?: BanGroup[]) => Composed;
+export { shortName };

package/dist/lib/module.js

@@ -0,0 +1,49 @@
+import { fileURLToPath } from "node:url";
+import { detect } from "./detect.js";
+/**
+ * Identity helper: types the manifest and keeps the shape honest. The returned
+ * object is handed to oxlint as the plugin (it ignores the manifest extras).
+ */
+export const defineModule = (manifest) => manifest;
+const shortName = (module) => module.meta.name.slice("@ashstack/".length);
+const isModuleEnabled = (module, options) => detect(module.option === undefined ? undefined : options[module.option], module.packages);
+const enabledRuleIds = (module) => {
+    const ids = [];
+    for (const [name, rule] of Object.entries(module.rules)) {
+        if (rule.meta.defaultOff)
+            continue;
+        if (rule.meta.packages && !detect(undefined, rule.meta.packages))
+            continue;
+        ids.push(`${module.meta.name}/${name}`);
+    }
+    return ids;
+};
+const addRestrictedImports = (into, from) => {
+    into.paths.push(...(from?.paths ?? []));
+    into.patterns.push(...(from?.patterns ?? []));
+};
+/**
+ * Turn manifests + options into the config fragments an entry spreads in:
+ * which plugin files to load, which rules to enable, and the merged import
+ * bans from the enabled modules plus the enabled ban-only groups.
+ */
+export const composeModules = (modules, options, banGroups = []) => {
+    const composed = { jsPlugins: [], rules: {}, restricted: { paths: [], patterns: [] } };
+    for (const module of modules) {
+        if (!isModuleEnabled(module, options))
+            continue;
+        const ids = enabledRuleIds(module);
+        if (ids.length > 0)
+            composed.jsPlugins.push(fileURLToPath(module.url));
+        for (const id of ids)
+            composed.rules[id] = "error";
+        addRestrictedImports(composed.restricted, module.restrictedImports);
+    }
+    for (const group of banGroups) {
+        if (!detect(undefined, group.packages))
+            continue;
+        addRestrictedImports(composed.restricted, group.restrictedImports);
+    }
+    return composed;
+};
+export { shortName };

package/dist/lib/types.d.ts

@@ -0,0 +1,114 @@
+import type { OxlintConfig as OxlintNativeConfig } from "oxlint";
+import type { RuleTester } from "oxlint/plugins-dev";
+type OxRule = Parameters<RuleTester["run"]>[1];
+type CreateRule = Extract<OxRule, {
+    create: unknown;
+}>;
+type CreateOnceRule = Extract<OxRule, {
+    createOnce: unknown;
+}>;
+type OxVisitor = ReturnType<CreateRule["create"]>;
+/** A node in the AST oxlint hands JS plugins: a discriminated union on ESTree `type` names. */
+export type AstNode = Parameters<NonNullable<OxVisitor[string]>>[0];
+/** What a rule receives: `options`, `sourceCode`, `report`, `filename`. */
+export type RuleContext = Parameters<CreateRule["create"]>[0];
+export type Visitor = OxVisitor;
+/**
+ * oxlint's rule metadata plus the two fields this package reads: `defaultOff`
+ * for rules a consumer opts into, `packages` for a rule gated on a dependency
+ * of its own. Rule docs are required here — RULES.md is generated from them.
+ */
+export type RuleMeta = NonNullable<CreateRule["meta"]> & {
+    docs: {
+        description: string;
+    };
+    defaultOff?: boolean;
+    packages?: string[];
+};
+export type Rule = OxRule & {
+    meta: RuleMeta;
+};
+/** A rule without its docs: what `problem()` takes before it adds the description. */
+export type RuleBody = (Pick<CreateRule, "create"> | {
+    createOnce: CreateOnceRule["createOnce"];
+}) & {
+    meta?: Partial<RuleMeta>;
+};
+export interface RestrictedPath {
+    name: string;
+    importNames?: string[];
+    message: string;
+}
+export interface RestrictedPattern {
+    group: string[];
+    message: string;
+}
+export interface RestrictedImports {
+    paths?: RestrictedPath[];
+    patterns?: RestrictedPattern[];
+}
+/**
+ * A module is the unit of rule organization: one rule namespace, one plugin
+ * file, one optional toggle. The default export of a module's index file IS
+ * the oxlint plugin (meta + rules); the extra fields make it the single
+ * source of truth for detection, bans, and docs (oxlint ignores them).
+ */
+export interface ModuleManifest {
+    meta: {
+        name: `@ashstack/${string}`;
+    };
+    rules: Record<string, Rule>;
+    /** import.meta.url of the module file — how entries hand oxlint an absolute plugin path */
+    url: string;
+    /** enable when one of these is a dependency; absent = always on */
+    packages?: string[];
+    /** key in the entry options that forces the module on/off; absent = auto-only */
+    option?: string;
+    /** activation line for RULES.md, e.g. "auto-enabled when `zod` is a dependency" */
+    docsWhen: string;
+    /** import bans that ship with (and only with) this module */
+    restrictedImports?: RestrictedImports;
+}
+/** A ban-only group: import bans gated on a library, with no rules of its own. */
+export interface BanGroup {
+    packages: string[];
+    restrictedImports: RestrictedImports;
+}
+export type CoreOptions = {
+    /** `@ashstack/zod/` rules — detected from `zod` */
+    zod?: boolean;
+};
+export type ReactOptions = CoreOptions & {
+    /** `@ashstack/query/` rules — detected from `@tanstack/react-query` */
+    query?: boolean;
+    /** `@ashstack/zustand/` rules — detected from `zustand` */
+    zustand?: boolean;
+    /** `@ashstack/i18n/` rules — detected from i18next/lingui/react-intl/use-intl/next-intl/expo-localization */
+    i18n?: boolean;
+};
+/**
+ * Every toggle is a rule module — one rule namespace each. Import bans and
+ * package-gated single rules are auto-detect only; disable individual rules
+ * by name in your `rules` block.
+ */
+export type ReactNativeOptions = ReactOptions & {
+    /** `@ashstack/unistyles/` rules + StyleSheet/Dimensions/SafeArea import bans — `react-native-unistyles` */
+    unistyles?: boolean;
+    /** `@ashstack/legend-list/` rules + FlatList/FlashList bans — `@legendapp/list` */
+    legendList?: boolean;
+    /** `@ashstack/legend-state/` rules + use$/useSelector ban — `@legendapp/state` */
+    legendState?: boolean;
+    /** `@ashstack/reanimated/` rules + Animated/runOnJS bans — `react-native-reanimated` */
+    reanimated?: boolean;
+    /** `@ashstack/turbo-image/` rules — `react-native-turbo-image` */
+    turboImage?: boolean;
+    /** `@ashstack/skia/` rules — `@shopify/react-native-skia` */
+    skia?: boolean;
+    /** `@ashstack/keyboard` import bans — `react-native-keyboard-controller` */
+    keyboard?: boolean;
+};
+/** The config object an entry returns: oxlint's own shape, so `defineConfig({ extends: [core()] })` typechecks. */
+export type OxlintConfig = OxlintNativeConfig;
+/** The `rules` block of a config: oxlint's own map, so a built-in rule's options are checked. */
+export type RuleMap = NonNullable<OxlintConfig["rules"]>;
+export {};

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/dist/react/index.d.ts

@@ -0,0 +1,9 @@
+import type { OxlintConfig, ReactOptions } from "../lib/types.js";
+export declare const reactModules: import("../lib/types.js").ModuleManifest[];
+/**
+ * React (web) entry — everything in core plus react, jsx-a11y, React Compiler
+ * diagnostics, you-might-not-need-an-effect, and the auto-detected library
+ * modules (query, zustand, i18n).
+ */
+declare const react: (options?: ReactOptions) => OxlintConfig;
+export default react;

package/dist/react/index.js

@@ -0,0 +1,126 @@
+import { fileURLToPath } from "node:url";
+import core, { coreModules } from "../core/index.js";
+import { mergeConfigs } from "../lib/merge.js";
+import { composeModules } from "../lib/module.js";
+import i18nModule from "./rules/i18n/index.js";
+import queryModule from "./rules/query/index.js";
+import zustandModule from "./rules/zustand/index.js";
+export const reactModules = [queryModule, zustandModule, i18nModule];
+const ALLOW_EMPTY_NOOP_HANDLERS = {
+    "eslint/no-empty": "off",
+    "eslint/no-empty-function": "off",
+};
+const REACT_COMPILER_RULES = {
+    "react/error-boundaries": "error",
+    "react/globals": "error",
+    "react/immutability": "error",
+    "react/incompatible-library": "error",
+    "react/preserve-manual-memoization": "error",
+    "react/purity": "error",
+    "react/refs": "error",
+    "react/set-state-in-effect": "error",
+    "react/set-state-in-render": "error",
+    "react/static-components": "error",
+    "react/use-memo": "error",
+    "react/void-use-memo": "error",
+    "react/capitalized-calls": "error",
+    "react/exhaustive-effect-dependencies": "error",
+    "react/hooks": "error",
+    "react/memo-dependencies": "error",
+    "react/no-deriving-state-in-effects": "error",
+    "react/invariant": "error",
+    "react/rule-suppression": "error",
+    "react/syntax": "error",
+    "react/todo": "error",
+    "react/unsupported-syntax": "error",
+};
+const FILE_BASED_ROUTER_FILES = ["**/routes/**", "**/src/app/**", "**/app/**/_layout.tsx", "**/app/**/+*.tsx"];
+const REACT_RULES = {
+    ...ALLOW_EMPTY_NOOP_HANDLERS,
+    "max-lines-per-function": ["error", { max: 120, skipBlankLines: true, skipComments: true }],
+    "react/react-in-jsx-scope": "off",
+    "react/style-prop-object": "off",
+    "react/only-export-components": "off",
+    "react/rules-of-hooks": "error",
+    "react/exhaustive-deps": "error",
+    "react/button-has-type": "error",
+    "react/checked-requires-onchange-or-readonly": "error",
+    "react/iframe-missing-sandbox": "error",
+    "react/jsx-boolean-value": "error",
+    "react/jsx-key": "error",
+    "react/jsx-no-comment-textnodes": "error",
+    "react/jsx-no-constructed-context-values": "error",
+    "react/jsx-no-duplicate-props": "error",
+    "react/jsx-no-target-blank": "error",
+    "react/jsx-no-useless-fragment": "error",
+    "react/no-array-index-key": "error",
+    "react/no-children-prop": "error",
+    "react/no-danger": "error",
+    "react/no-danger-with-children": "error",
+    "react/no-direct-mutation-state": "error",
+    "react/no-is-mounted": "error",
+    "react/no-render-return-value": "error",
+    "react/no-string-refs": "error",
+    "react/no-this-in-sfc": "error",
+    "react/no-unsafe": "error",
+    "react/no-unescaped-entities": "error",
+    "react/no-unstable-nested-components": ["error", { allowAsProps: true }],
+    "react/require-render-return": "error",
+    "react/self-closing-comp": "error",
+    "react/void-dom-elements-no-children": "error",
+    ...REACT_COMPILER_RULES,
+    "jsx-a11y/alt-text": "error",
+    "jsx-a11y/anchor-has-content": "error",
+    "jsx-a11y/anchor-is-valid": "error",
+    "jsx-a11y/click-events-have-key-events": "off",
+    "jsx-a11y/control-has-associated-label": "off",
+    "jsx-a11y/heading-has-content": "error",
+    "jsx-a11y/img-redundant-alt": "error",
+    "jsx-a11y/interactive-supports-focus": "error",
+    "jsx-a11y/label-has-associated-control": "error",
+    "jsx-a11y/no-aria-hidden-on-focusable": "error",
+    "jsx-a11y/no-autofocus": ["error", { ignoreNonDOM: true }],
+    "jsx-a11y/no-noninteractive-element-interactions": "off",
+    "jsx-a11y/no-noninteractive-tabindex": "error",
+    "jsx-a11y/no-redundant-roles": "error",
+    "jsx-a11y/no-static-element-interactions": "error",
+    "jsx-a11y/prefer-tag-over-role": "off",
+    "jsx-a11y/role-has-required-aria-props": "error",
+    "jsx-a11y/role-supports-aria-props": "error",
+    "react-effect/no-derived-state": "error",
+    "react-effect/no-chain-state-updates": "error",
+    "react-effect/no-event-handler": "error",
+    "react-effect/no-adjust-state-on-prop-change": "error",
+    "react-effect/no-reset-all-state-on-prop-change": "error",
+    "react-effect/no-pass-live-state-to-parent": "error",
+    "react-effect/no-pass-data-to-parent": "error",
+    "react-effect/no-external-store-subscription": "error",
+    "react-effect/no-initialize-state": "error",
+    "unicorn/filename-case": ["error", { cases: { kebabCase: true, pascalCase: true } }],
+};
+/**
+ * React (web) entry — everything in core plus react, jsx-a11y, React Compiler
+ * diagnostics, you-might-not-need-an-effect, and the auto-detected library
+ * modules (query, zustand, i18n).
+ */
+const react = (options = {}) => {
+    const composed = composeModules([...coreModules, ...reactModules], options);
+    return mergeConfigs(core(options), {
+        plugins: ["react", "jsx-a11y"],
+        jsPlugins: [
+            {
+                name: "react-effect",
+                specifier: fileURLToPath(import.meta.resolve("eslint-plugin-react-you-might-not-need-an-effect")),
+            },
+            ...composed.jsPlugins,
+        ],
+        rules: { ...REACT_RULES, ...composed.rules },
+        overrides: [
+            {
+                files: FILE_BASED_ROUTER_FILES,
+                rules: { "unicorn/filename-case": "off" },
+            },
+        ],
+    });
+};
+export default react;

package/dist/react/rules/i18n/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/react/rules/i18n/index.js

@@ -0,0 +1,16 @@
+import { defineModule } from "../../../lib/module.js";
+import { noBareAttrs } from "./no-bare-attrs.js";
+import { noBareText } from "./no-bare-text.js";
+import { noBareToast } from "./no-bare-toast.js";
+export default defineModule({
+    meta: { name: "@ashstack/i18n" },
+    url: import.meta.url,
+    packages: ["i18next", "react-i18next", "@lingui/core", "react-intl", "use-intl", "next-intl", "expo-localization"],
+    option: "i18n",
+    docsWhen: "auto-enabled by `react()` when an i18n library (i18next, lingui, react-intl, use-intl, next-intl, expo-localization) is a dependency",
+    rules: {
+        "no-bare-text": noBareText,
+        "no-bare-attrs": noBareAttrs,
+        "no-bare-toast": noBareToast,
+    },
+});

package/dist/react/rules/i18n/no-bare-attrs.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noBareAttrs: Rule;

package/dist/react/rules/i18n/no-bare-attrs.js

@@ -0,0 +1,38 @@
+import { attributeName, optionsOf } from "../../../lib/ast.js";
+const BARE_JSX_ATTRIBUTE = 'Pass `t("<key>")` as this attribute value and add the key to every locale file.';
+const NATIVE_TRANSLATABLE_ATTRIBUTES = ["placeholder", "accessibilityLabel", "accessibilityHint", "title"];
+export const noBareAttrs = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow a plain string literal on a configurable list of user-visible JSX attributes, defaulting to placeholder, accessibilityLabel, accessibilityHint and title.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { attributes: { type: "array", items: { type: "string" }, minItems: 1 } },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        const attributes = new Set();
+        return {
+            before() {
+                attributes.clear();
+                const configured = optionsOf(context, {}).attributes;
+                for (const attribute of configured ?? NATIVE_TRANSLATABLE_ATTRIBUTES) {
+                    attributes.add(attribute);
+                }
+            },
+            JSXAttribute(node) {
+                if (!attributes.has(attributeName(node)))
+                    return;
+                const { value } = node;
+                if (value?.type !== "Literal" || typeof value.value !== "string" || value.value.length === 0)
+                    return;
+                context.report({ node, message: BARE_JSX_ATTRIBUTE });
+            },
+        };
+    },
+};

package/dist/react/rules/i18n/no-bare-text.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noBareText: Rule;

package/dist/react/rules/i18n/no-bare-text.js

@@ -0,0 +1,26 @@
+import { problem, tagIdentifier } from "../../../lib/ast.js";
+const BARE_JSX_TEXT = 'Wrap this text in `t("<key>")`, or `<Trans>` when it holds markup, and add the key to every locale file.';
+const I18N_COMPONENTS = new Set(["Trans", "Plural", "Select"]);
+const BARE_TEXT = /^[A-Za-z][^<{}]{2,}$/;
+export const noBareText = problem("Disallow a JSX element that carries no attributes and whose single child is plain literal text.", {
+    createOnce(context) {
+        return {
+            JSXElement(node) {
+                const opening = node.openingElement;
+                if (opening.attributes.length > 0)
+                    return;
+                const children = node.children.filter(child => child.type !== "JSXText" || child.value.trim() !== "");
+                if (children.length !== 1)
+                    return;
+                const [only] = children;
+                if (only?.type !== "JSXText")
+                    return;
+                if (!BARE_TEXT.test(only.value.trim()))
+                    return;
+                if (I18N_COMPONENTS.has(tagIdentifier(opening.name)))
+                    return;
+                context.report({ node: only, message: BARE_JSX_TEXT });
+            },
+        };
+    },
+});

package/dist/react/rules/i18n/no-bare-toast.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noBareToast: Rule;

package/dist/react/rules/i18n/no-bare-toast.js

@@ -0,0 +1,38 @@
+import { problem } from "../../../lib/ast.js";
+const BARE_TOAST = 'Pass `t("<key>")` to this toast instead of the literal, and add the key to every locale file.';
+const TOAST_METHODS = new Set(["success", "error", "info", "warning", "loading", "message"]);
+const isToastCall = (node) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    const { object, property } = callee;
+    if (object.type !== "Identifier" || object.name !== "toast")
+        return false;
+    return property.type === "Identifier" && TOAST_METHODS.has(property.name);
+};
+const onlyStringArgument = (node) => {
+    if (node.type !== "CallExpression" || node.arguments.length !== 1)
+        return undefined;
+    const [argument] = node.arguments;
+    if (argument?.type !== "Literal" || typeof argument.value !== "string")
+        return undefined;
+    return argument;
+};
+export const noBareToast = problem("Disallow a `toast.*` call whose only argument is a string literal.", {
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (!isToastCall(node))
+                    return;
+                const argument = onlyStringArgument(node);
+                if (argument === undefined)
+                    return;
+                context.report({ node: argument, message: BARE_TOAST });
+            },
+        };
+    },
+});

package/dist/react/rules/query/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../../index.js").ModuleManifest;
+export default _default;

package/dist/react/rules/query/index.js

@@ -0,0 +1,20 @@
+import { defineModule } from "../../../lib/module.js";
+import { nextPageParamUndefined } from "./next-page-param-undefined.js";
+import { noDeprecatedFilters } from "./no-deprecated-filters.js";
+import { noFetchInQueryFn } from "./no-fetch-in-query-fn.js";
+import { noInlineKeys } from "./no-inline-keys.js";
+import { requireDestructuredHooks } from "./require-destructured-hooks.js";
+export default defineModule({
+    meta: { name: "@ashstack/query" },
+    url: import.meta.url,
+    packages: ["@tanstack/react-query"],
+    option: "query",
+    docsWhen: "auto-enabled by `react()` when `@tanstack/react-query` is a dependency",
+    rules: {
+        "no-inline-keys": noInlineKeys,
+        "no-deprecated-filters": noDeprecatedFilters,
+        "require-destructured-hooks": requireDestructuredHooks,
+        "no-fetch-in-query-fn": noFetchInQueryFn,
+        "next-page-param-undefined": nextPageParamUndefined,
+    },
+});

package/dist/react/rules/query/next-page-param-undefined.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const nextPageParamUndefined: Rule;

package/dist/react/rules/query/next-page-param-undefined.js

@@ -0,0 +1,26 @@
+import { FUNCTION_TYPES, crossesFunctionBefore, findInSubtree, gate, problem } from "../../../lib/ast.js";
+import { propertyKeyName } from "./shared.js";
+const NEXT_PAGE_PARAM_NULL = "Return `undefined` to signal there are no more pages. `null` is a valid page param, so returning it reads as a real next cursor and the list keeps fetching forever.";
+const returnsNull = (node) => node.type === "ReturnStatement" && node.argument?.type === "Literal" && node.argument.value === null;
+/** `() => null` returns null without a ReturnStatement to find. */
+const arrowReturningNull = (node) => node.type === "ArrowFunctionExpression" && node.body.type === "Literal" && node.body.value === null
+    ? node.body
+    : null;
+export const nextPageParamUndefined = problem("Disallow `return null` in the body of a `getNextPageParam`.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "getNextPageParam");
+            },
+            Property(node) {
+                if (propertyKeyName(node) !== "getNextPageParam")
+                    return;
+                const { value } = node;
+                const found = arrowReturningNull(value) ?? findInSubtree(value, returnsNull);
+                if (!found || crossesFunctionBefore(found, value, FUNCTION_TYPES))
+                    return;
+                context.report({ node: value, message: NEXT_PAGE_PARAM_NULL });
+            },
+        };
+    },
+});

package/dist/react/rules/query/no-deprecated-filters.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noDeprecatedFilters: Rule;

package/dist/react/rules/query/no-deprecated-filters.js

@@ -0,0 +1,63 @@
+const DEPRECATED_FILTERS = "Pass a filter object here: `.invalidateQueries({ queryKey: someKeys.scope(...) })`. TanStack Query v5 removed the positional `(queryKey)` form.";
+const FILTER_METHODS = new Set([
+    "invalidateQueries",
+    "removeQueries",
+    "refetchQueries",
+    "cancelQueries",
+    "resetQueries",
+]);
+const isFilterMethodCall = (node) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const { callee } = node;
+    if (callee.type !== "MemberExpression" || callee.computed)
+        return false;
+    const { property } = callee;
+    return property.type === "Identifier" && FILTER_METHODS.has(property.name);
+};
+const onlyArgument = (node) => {
+    if (node.type !== "CallExpression" || node.arguments.length !== 1)
+        return undefined;
+    return node.arguments[0];
+};
+const isStringLiteral = (node) => node.type === "Literal" && typeof node.value === "string";
+const filterObjectFor = (context, argument) => {
+    if (argument.type === "ArrayExpression")
+        return `{ queryKey: ${context.sourceCode.getText(argument)} }`;
+    if (isStringLiteral(argument))
+        return `{ queryKey: [${context.sourceCode.getText(argument)}] }`;
+    return null;
+};
+export const noDeprecatedFilters = {
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow the positional key argument that TanStack Query v5 removed from `invalidateQueries` and its sibling methods. The suggestion rewrites it to the filter-object form.",
+        },
+        hasSuggestions: true,
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (!isFilterMethodCall(node))
+                    return;
+                const argument = onlyArgument(node);
+                if (argument === undefined)
+                    return;
+                const filterObject = filterObjectFor(context, argument);
+                if (filterObject === null)
+                    return;
+                context.report({
+                    node: argument,
+                    message: DEPRECATED_FILTERS,
+                    suggest: [
+                        {
+                            desc: "Wrap in a filter object",
+                            fix: fixer => fixer.replaceText(argument, filterObject),
+                        },
+                    ],
+                });
+            },
+        };
+    },
+};

package/dist/react/rules/query/no-fetch-in-query-fn.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noFetchInQueryFn: Rule;

package/dist/react/rules/query/no-fetch-in-query-fn.js

@@ -0,0 +1,22 @@
+import { gate, problem, subtreeHas } from "../../../lib/ast.js";
+import { propertyKeyName } from "./shared.js";
+const FETCH_IN_QUERY_FN = "Call a typed function from the feature's `*.requests.ts` module here instead of `fetch`. That client is what sends the auth header, applies the timeout, retries a 429 or 5xx, and throws the app's error type.";
+const QUERY_FN_KEYS = new Set(["queryFn", "mutationFn"]);
+/** The global `fetch`, not a typed client's `api.fetch()`. */
+const isBareFetch = (node) => node.type === "CallExpression" && node.callee.type === "Identifier" && node.callee.name === "fetch";
+export const noFetchInQueryFn = problem("Disallow a bare `fetch(` inside a `queryFn` or `mutationFn`.", {
+    createOnce(context) {
+        return {
+            before() {
+                return gate(context, "queryFn", "mutationFn");
+            },
+            Property(node) {
+                if (!QUERY_FN_KEYS.has(propertyKeyName(node)))
+                    return;
+                if (!subtreeHas(node.value, isBareFetch))
+                    return;
+                context.report({ node: node.value, message: FETCH_IN_QUERY_FN });
+            },
+        };
+    },
+});

package/dist/react/rules/query/no-inline-keys.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from "../../../lib/types.js";
+export declare const noInlineKeys: Rule;