@gost-kit/eslint-plugin 0.0.0-stage → 0.1.0

package/dist/lib/optional-call.js

@@ -0,0 +1,55 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+const hasOptionalAccess = (node) => {
+    let current = node;
+    while (true) {
+        if (current.type === AST_NODE_TYPES.CallExpression ||
+            current.type === AST_NODE_TYPES.MemberExpression) {
+            if (current.optional) {
+                return true;
+            }
+            current =
+                current.type === AST_NODE_TYPES.CallExpression
+                    ? current.callee
+                    : current.object;
+        }
+        else if (current.type === AST_NODE_TYPES.TSAsExpression ||
+            current.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+            current.type === AST_NODE_TYPES.TSNonNullExpression ||
+            current.type === AST_NODE_TYPES.TSTypeAssertion ||
+            current.type === AST_NODE_TYPES.TSInstantiationExpression) {
+            current = current.expression;
+        }
+        else {
+            // A nested ChainExpression ends an earlier chain (e.g. `(store?.dispatch)()`).
+            // Arguments are not part of this path; enclosing argument/key gates are checked below.
+            return false;
+        }
+    }
+};
+export const isOptionalCall = (call) => {
+    if (hasOptionalAccess(call)) {
+        return true;
+    }
+    let current = call;
+    while (current.parent) {
+        const parent = current.parent;
+        if (parent.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            parent.type === AST_NODE_TYPES.FunctionExpression ||
+            parent.type === AST_NODE_TYPES.FunctionDeclaration) {
+            return false;
+        }
+        // Optional calls/accesses skip their arguments and computed keys too.
+        if (((parent.type === AST_NODE_TYPES.CallExpression &&
+            parent.arguments.some((argument) => {
+                return argument === current;
+            })) ||
+            (parent.type === AST_NODE_TYPES.MemberExpression &&
+                parent.computed &&
+                parent.property === current)) &&
+            hasOptionalAccess(parent)) {
+            return true;
+        }
+        current = parent;
+    }
+    return false;
+};

package/dist/lib/raw-state.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const createRawStateCheck: (source: TSESLint.SourceCode) => (node: TSESTree.Node) => boolean;

package/dist/lib/raw-state.js

@@ -0,0 +1,27 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { runeCallee } from './rune-callee.js';
+import { findValueVariable } from './value-variable.js';
+// Inspect the original scope: Svelte's typed parser synthesizes rune declarations
+// in a virtual TS file. Plain aliases of raw state capture a nonreactive snapshot.
+export const createRawStateCheck = (source) => {
+    return (node) => {
+        if (node.type !== AST_NODE_TYPES.Identifier) {
+            return false;
+        }
+        const variable = findValueVariable(source.getScope(node), node.name);
+        return (variable?.defs.some((definition) => {
+            if (definition.type !== 'Variable' ||
+                definition.node.id.type !== AST_NODE_TYPES.Identifier ||
+                definition.node.id.name !== node.name) {
+                return false;
+            }
+            const init = definition.node.init;
+            if (init?.type !== AST_NODE_TYPES.CallExpression ||
+                init.callee.type !== AST_NODE_TYPES.MemberExpression ||
+                !runeCallee(init.callee, source, '$state', 'raw')) {
+                return false;
+            }
+            return true;
+        }) ?? false);
+    };
+};

package/dist/lib/reactive-context.d.ts

@@ -0,0 +1,6 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const isDerived: (node: TSESTree.CallExpression, source: TSESLint.SourceCode) => boolean;
+export declare const reactiveContext: (node: TSESTree.Node, source: TSESLint.SourceCode) => {
+    derived: TSESTree.CallExpression;
+    call: TSESTree.CallExpression | TSESTree.NewExpression | TSESTree.TaggedTemplateExpression;
+} | undefined;

package/dist/lib/reactive-context.js

@@ -0,0 +1,48 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { runeCallee } from './rune-callee.js';
+import { memberKey } from './member-key.js';
+export const isDerived = (node, source) => {
+    return !!runeCallee(node.callee, source, '$derived', 'by');
+};
+export const reactiveContext = (node, source) => {
+    let current = node;
+    let call;
+    while (current.parent) {
+        const parent = current.parent;
+        if (parent.type === AST_NODE_TYPES.CallExpression) {
+            if (isDerived(parent, source)) {
+                return call ? { derived: parent, call } : undefined;
+            }
+        }
+        if (parent.type === AST_NODE_TYPES.CallExpression ||
+            parent.type === AST_NODE_TYPES.NewExpression ||
+            parent.type === AST_NODE_TYPES.TaggedTemplateExpression) {
+            call ??= parent;
+        }
+        // Instance fields execute only when an instance is created. Static fields
+        // and computed keys execute while the class expression itself is evaluated.
+        if ((parent.type === AST_NODE_TYPES.PropertyDefinition ||
+            parent.type === AST_NODE_TYPES.AccessorProperty) &&
+            !parent.static &&
+            parent.value === current) {
+            return undefined;
+        }
+        if (parent.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            parent.type === AST_NODE_TYPES.FunctionExpression ||
+            parent.type === AST_NODE_TYPES.FunctionDeclaration) {
+            const owner = parent.parent;
+            if (owner?.type === AST_NODE_TYPES.CallExpression &&
+                owner.callee.type === AST_NODE_TYPES.MemberExpression &&
+                memberKey(owner.callee) === 'by' &&
+                owner.arguments[0] === parent &&
+                !parent.async &&
+                !parent.generator &&
+                isDerived(owner, source)) {
+                return call ? { derived: owner, call } : undefined;
+            }
+            return undefined;
+        }
+        current = parent;
+    }
+    return undefined;
+};

package/dist/lib/rune-callee.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const runeCallee: (callee: TSESTree.CallExpression["callee"], source: TSESLint.SourceCode, name: string, key?: string) => TSESTree.Identifier | undefined;

package/dist/lib/rune-callee.js

@@ -0,0 +1,19 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { memberKey } from './member-key.js';
+import { findValueVariable } from './value-variable.js';
+// Return the intrinsic identifier, preserving static member-key support.
+export const runeCallee = (callee, source, name, key) => {
+    const identifier = callee.type === AST_NODE_TYPES.Identifier
+        ? callee
+        : key &&
+            callee.type === AST_NODE_TYPES.MemberExpression &&
+            memberKey(callee) === key &&
+            callee.object.type === AST_NODE_TYPES.Identifier
+            ? callee.object
+            : undefined;
+    if (identifier?.name !== name) {
+        return undefined;
+    }
+    const variable = findValueVariable(source.getScope(identifier), name);
+    return variable && variable.defs.length > 0 ? undefined : identifier;
+};

package/dist/lib/selector-fix.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+export declare const selectorFix: (state: TSESTree.Expression, derived: TSESTree.CallExpression, call: TSESTree.CallExpression, source: TSESLint.SourceCode) => ((fixer: TSESLint.RuleFixer) => TSESLint.RuleFix[]) | undefined;

package/dist/lib/selector-fix.js

@@ -0,0 +1,122 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { memberKey } from './member-key.js';
+const reserved = new Set([
+    'arguments',
+    'eval',
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+// A deliberately small syntax boundary: a standalone derived with one direct call.
+export const selectorFix = (state, derived, call, source) => {
+    if (derived.callee.type !== AST_NODE_TYPES.Identifier ||
+        derived.arguments[0] !== call ||
+        call.optional ||
+        call.callee.type !== AST_NODE_TYPES.Identifier ||
+        call.arguments.length !== 1) {
+        return undefined;
+    }
+    const selected = call.arguments[0];
+    const declarator = derived.parent;
+    const declaration = declarator?.parent;
+    if (selected.type !== AST_NODE_TYPES.MemberExpression ||
+        declarator?.type !== AST_NODE_TYPES.VariableDeclarator ||
+        declarator.init !== derived ||
+        declaration?.type !== AST_NODE_TYPES.VariableDeclaration ||
+        declaration.declarations.length !== 1 ||
+        declaration.parent.type === AST_NODE_TYPES.ExportNamedDeclaration ||
+        declaration.parent.type === AST_NODE_TYPES.ForStatement ||
+        declaration.parent.type === AST_NODE_TYPES.ForOfStatement ||
+        declaration.parent.type === AST_NODE_TYPES.ForInStatement) {
+        return undefined;
+    }
+    // Accept one immediate feature property only; deeper user-defined getters
+    // and accesses through containers have no static purity guarantee.
+    if (selected.object !== state ||
+        (state.type !== AST_NODE_TYPES.Identifier &&
+            (state.type !== AST_NODE_TYPES.MemberExpression ||
+                state.object.type !== AST_NODE_TYPES.Identifier ||
+                state.optional)) ||
+        selected.optional) {
+        return undefined;
+    }
+    const base = memberKey(selected);
+    if (!base || base.startsWith('$') || !/^[A-Z_a-z][$\w]*$/u.test(base)) {
+        return undefined;
+    }
+    const occupied = new Set();
+    let scope = source.getScope(declaration);
+    while (scope) {
+        scope.variables.forEach((variable) => {
+            occupied.add(variable.name);
+        });
+        scope.through.forEach((reference) => {
+            occupied.add(reference.identifier.name);
+        });
+        scope = scope.upper;
+    }
+    let name = base;
+    let version = 2;
+    while (occupied.has(name) || reserved.has(name)) {
+        name = `${base}V${version}`;
+        version += 1;
+    }
+    // Svelte adds script elements to ESTree; its parser supplies this parent.
+    const parent = declaration.parent;
+    if (parent.type !== AST_NODE_TYPES.Program &&
+        parent.type !== 'SvelteScriptElement') {
+        return undefined;
+    }
+    const indentation = source.lines[declaration.loc.start.line - 1].slice(0, declaration.loc.start.column);
+    const leading = /^\s*$/u.test(indentation) ? indentation : '';
+    const lineEnd = source.text.includes('\r\n') ? '\r\n' : '\n';
+    return (fixer) => {
+        return [
+            fixer.insertTextBefore(declaration, `const ${name} = $derived(${source.getText(selected)});${lineEnd}${leading}`),
+            fixer.replaceText(selected, name),
+        ];
+    };
+};

package/dist/lib/store-state.d.ts

@@ -0,0 +1,2 @@
+import type { ParserServicesWithTypeInformation, TSESTree } from '@typescript-eslint/utils';
+export declare const createStoreStateCheck: (services: ParserServicesWithTypeInformation) => (node: TSESTree.Node) => boolean;

package/dist/lib/store-state.js

@@ -0,0 +1,57 @@
+import ts from 'typescript';
+import { createCommonSourceCheck } from './common-source.js';
+export const createStoreStateCheck = (services) => {
+    const program = services.program;
+    const checker = program.getTypeChecker();
+    const isCommonSource = createCommonSourceCheck();
+    const declarations = new Map();
+    const isStoreDeclaration = (declaration) => {
+        const cached = declarations.get(declaration);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const source = declaration.getSourceFile();
+        let matches = false;
+        if (isCommonSource(source)) {
+            const module = checker.getSymbolAtLocation(source);
+            const exported = module &&
+                checker.getExportsOfModule(module).find((symbol) => {
+                    return symbol.name === 'Store';
+                });
+            const store = exported &&
+                (exported.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(exported)
+                    : exported);
+            matches = store
+                ? (checker
+                    .getDeclaredTypeOfSymbol(store)
+                    .getProperty('state')
+                    ?.getDeclarations()
+                    ?.includes(declaration) ?? false)
+                : false;
+        }
+        declarations.set(declaration, matches);
+        return matches;
+    };
+    const isStore = (type) => {
+        if (type.flags &
+            (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+            return false;
+        }
+        if (type.isUnion()) {
+            const members = type.types.filter((member) => {
+                return !(member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            });
+            return members.length > 0 && members.every(isStore);
+        }
+        return (type
+            .getProperty('state')
+            ?.getDeclarations()
+            ?.some((declaration) => {
+            return isStoreDeclaration(declaration);
+        }) ?? false);
+    };
+    return (node) => {
+        return isStore(services.getTypeAtLocation(node));
+    };
+};

package/dist/lib/svelte-scripts.d.ts

@@ -0,0 +1,5 @@
+import type { AST } from 'svelte-eslint-parser';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+export declare const svelteScripts: (source: TSESLint.SourceCode) => AST.SvelteScriptElement[] | undefined;
+export declare const scriptHasAttribute: (script: AST.SvelteScriptElement, name: string, value?: string) => boolean;
+export declare const inScript: (node: TSESTree.Node, scripts: readonly AST.SvelteScriptElement[]) => boolean;

package/dist/lib/svelte-scripts.js

@@ -0,0 +1,25 @@
+export const svelteScripts = (source) => {
+    const services = source.parserServices;
+    if (!services || !('isSvelte' in services) || services.isSvelte !== true) {
+        return undefined;
+    }
+    // Only the Svelte parser supplies the extended ESTree script elements.
+    return source.ast.body.filter((node) => {
+        return node.type === 'SvelteScriptElement';
+    });
+};
+export const scriptHasAttribute = (script, name, value) => {
+    return script.startTag.attributes.some((attribute) => {
+        return (attribute.type === 'SvelteAttribute' &&
+            attribute.key.name === name &&
+            (value === undefined ||
+                attribute.value.some((item) => {
+                    return item.type === 'SvelteLiteral' && item.value === value;
+                })));
+    });
+};
+export const inScript = (node, scripts) => {
+    return scripts.some((script) => {
+        return node.range[0] >= script.range[0] && node.range[1] <= script.range[1];
+    });
+};

package/dist/lib/ui-handlers.d.ts

@@ -0,0 +1,10 @@
+import type { AST } from 'svelte-eslint-parser';
+import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+type Handler = TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration;
+export declare const createUiHandlerCollector: (source: TSESLint.SourceCode, scripts: readonly AST.SvelteScriptElement[]) => {
+    handlers: Set<Handler>;
+    attribute(node: TSESTree.Node): void;
+    shorthand(node: TSESTree.Node): void;
+    directive(node: TSESTree.Node): void;
+};
+export {};

package/dist/lib/ui-handlers.js

@@ -0,0 +1,84 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { findValueVariable } from './value-variable.js';
+import { inScript } from './svelte-scripts.js';
+export const createUiHandlerCollector = (source, scripts) => {
+    const handlers = new Set();
+    const resolve = (node, inline, seen) => {
+        if (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionDeclaration) {
+            return inline || inScript(node, scripts) ? node : undefined;
+        }
+        if (node.type === AST_NODE_TYPES.TSSatisfiesExpression ||
+            node.type === AST_NODE_TYPES.TSAsExpression ||
+            node.type === AST_NODE_TYPES.TSTypeAssertion ||
+            node.type === AST_NODE_TYPES.TSNonNullExpression ||
+            node.type === AST_NODE_TYPES.ChainExpression) {
+            return resolve(node.expression, inline, seen);
+        }
+        if (node.type !== AST_NODE_TYPES.Identifier) {
+            return undefined;
+        }
+        const variable = findValueVariable(source.getScope(node), node.name);
+        if (!variable ||
+            seen.has(variable) ||
+            variable.references.some((reference) => {
+                return reference.isWrite() && !reference.init;
+            })) {
+            return undefined;
+        }
+        const next = new Set(seen).add(variable);
+        return variable.defs
+            .map((definition) => {
+            if (definition.type === 'FunctionName' &&
+                definition.node.type === AST_NODE_TYPES.FunctionDeclaration) {
+                return resolve(definition.node, false, next);
+            }
+            if (definition.type === 'Variable' &&
+                definition.parent.kind === 'const' &&
+                definition.node.id.type === AST_NODE_TYPES.Identifier &&
+                definition.node.init) {
+                return resolve(definition.node.init, false, next);
+            }
+            return undefined;
+        })
+            .find((handler) => {
+            return !!handler;
+        });
+    };
+    const add = (expression) => {
+        const handler = resolve(expression, true, new Set());
+        if (handler) {
+            handlers.add(handler);
+        }
+    };
+    return {
+        handlers,
+        attribute(node) {
+            // Parser-specific listeners are the only boundary for extended Svelte nodes.
+            const attribute = node;
+            if (!attribute.key.name.startsWith('on') ||
+                attribute.key.name.length <= 2) {
+                return;
+            }
+            attribute.value.forEach((value) => {
+                if (value.type === 'SvelteMustacheTag') {
+                    add(value.expression);
+                }
+            });
+        },
+        shorthand(node) {
+            const attribute = node;
+            if (attribute.key.name.startsWith('on') &&
+                attribute.key.name.length > 2) {
+                add(attribute.value);
+            }
+        },
+        directive(node) {
+            const directive = node;
+            if (directive.kind === 'EventHandler' && directive.expression) {
+                add(directive.expression);
+            }
+        },
+    };
+};

package/dist/lib/value-variable.d.ts

@@ -0,0 +1,2 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+export declare const findValueVariable: (initialScope: TSESLint.Scope.Scope, name: string) => import("@typescript-eslint/scope-manager").Variable | undefined;

package/dist/lib/value-variable.js

@@ -0,0 +1,25 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+// A nearer type-only declaration does not shadow a runtime value in an outer scope.
+export const findValueVariable = (initialScope, name) => {
+    for (let scope = initialScope; scope; scope = scope.upper) {
+        const variable = scope.set.get(name);
+        // Plain JavaScript parsers do not supply the TypeScript namespace flag.
+        if (variable &&
+            variable.isValueVariable !== false &&
+            (variable.defs.length === 0 ||
+                variable.defs.some((definition) => {
+                    if (definition.isVariableDefinition === false) {
+                        return false;
+                    }
+                    if (definition.type !== 'ImportBinding') {
+                        return true;
+                    }
+                    return (definition.parent.importKind !== 'type' &&
+                        !(definition.node.type === AST_NODE_TYPES.ImportSpecifier &&
+                            definition.node.importKind === 'type'));
+                }))) {
+            return variable;
+        }
+    }
+    return undefined;
+};

package/dist/rules/no-component-state.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const noComponentState: ESLintUtils.RuleModule<"componentState", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/no-component-state.js

@@ -0,0 +1,46 @@
+import { AST_NODE_TYPES, ESLintUtils, } from '@typescript-eslint/utils';
+import { runeCallee } from '../lib/rune-callee.js';
+import { createComponentRefCheck } from '../lib/component-refs.js';
+export const noComponentState = ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Disallow component-owned logical state in explicitly selected files.',
+        },
+        schema: [],
+        messages: {
+            componentState: '{{rune}} creates component-owned state. Move logical state to root/feature state and use intent actions, or exclude this independent UI component from the rule scope.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const source = context.sourceCode;
+        const refs = createComponentRefCheck(source);
+        const calls = [];
+        return {
+            SvelteDirective: refs.recordBinding,
+            CallExpression(node) {
+                const callee = node.callee;
+                const identifier = runeCallee(callee, source, '$state', 'raw') ??
+                    runeCallee(callee, source, '$bindable');
+                if (!identifier) {
+                    return;
+                }
+                calls.push({
+                    node,
+                    rune: callee.type === AST_NODE_TYPES.MemberExpression
+                        ? '$state.raw'
+                        : identifier.name,
+                });
+            },
+            'Program:exit'() {
+                calls.forEach(({ node, rune }) => {
+                    if (rune !== '$bindable' && refs.allows(node)) {
+                        return;
+                    }
+                    context.report({ node, messageId: 'componentState', data: { rune } });
+                });
+            },
+        };
+    },
+});

package/dist/rules/require-feature-state-selector.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const requireFeatureStateSelector: ESLintUtils.RuleModule<"selectFeature", [], unknown, ESLintUtils.RuleListener>;

package/dist/rules/require-feature-state-selector.js

@@ -0,0 +1,58 @@
+import { svelteScripts, scriptHasAttribute, inScript, } from '../lib/svelte-scripts.js';
+import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
+import { memberKey } from '../lib/member-key.js';
+import { createStoreStateCheck } from '../lib/store-state.js';
+import { reactiveContext } from '../lib/reactive-context.js';
+import { createRawStateCheck } from '../lib/raw-state.js';
+import { selectorFix } from '../lib/selector-fix.js';
+export const requireFeatureStateSelector = ESLintUtils.RuleCreator.withoutDocs({
+    meta: {
+        type: 'suggestion',
+        docs: { description: 'Select Store state before reactive calls.' },
+        schema: [],
+        fixable: 'code',
+        messages: {
+            selectFeature: 'Select the feature with a separate $derived before computing its presentation: const user = $derived(store.state.user); const view = $derived(presenter(user)); This skips downstream updates when the feature reference is unchanged.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const typedScripts = svelteScripts(context.sourceCode)?.filter((script) => {
+            return scriptHasAttribute(script, 'lang', 'ts');
+        });
+        if (typedScripts?.length === 0) {
+            return {};
+        }
+        const services = ESLintUtils.getParserServices(context);
+        const isStore = createStoreStateCheck(services);
+        const isRawState = createRawStateCheck(context.sourceCode);
+        return {
+            MemberExpression(node) {
+                if (typedScripts && !inScript(node, typedScripts)) {
+                    return;
+                }
+                const storeState = memberKey(node) === 'state' && isStore(node.object);
+                if (!storeState && !isRawState(node.object)) {
+                    return;
+                }
+                const reactive = reactiveContext(node, context.sourceCode);
+                if (!reactive) {
+                    return;
+                }
+                const parent = node.parent;
+                const location = storeState &&
+                    parent.type === AST_NODE_TYPES.MemberExpression &&
+                    parent.object === node
+                    ? parent
+                    : node;
+                context.report({
+                    node: location,
+                    messageId: 'selectFeature',
+                    fix: reactive.call.type === AST_NODE_TYPES.CallExpression
+                        ? selectorFix(storeState ? node : node.object, reactive.derived, reactive.call, context.sourceCode)
+                        : undefined,
+                });
+            },
+        };
+    },
+});

package/dist/rules/single-intent-dispatch.d.ts

@@ -0,0 +1,2 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const singleIntentDispatch: ESLintUtils.RuleModule<"multipleDispatch" | "conditionalDispatch", [], unknown, ESLintUtils.RuleListener>;