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

package/dist/lib/dispatch-type.js

@@ -0,0 +1,103 @@
+import ts from 'typescript';
+import { createCommonSourceCheck } from './common-source.js';
+export const createDispatchCheck = (services) => {
+    const checker = services.program.getTypeChecker();
+    const isCommonSource = createCommonSourceCheck();
+    const signatures = new Set();
+    const symbols = new Map();
+    const isPublicDispatch = (symbol) => {
+        const cached = symbols.get(symbol);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const matches = symbol.getDeclarations()?.some((declaration) => {
+            const source = declaration.getSourceFile();
+            if (!isCommonSource(source)) {
+                return false;
+            }
+            const module = checker.getSymbolAtLocation(source);
+            const exported = module &&
+                checker.getExportsOfModule(module).find((item) => {
+                    return item.name === 'Dispatch';
+                });
+            const target = exported &&
+                (exported.flags & ts.SymbolFlags.Alias
+                    ? checker.getAliasedSymbol(exported)
+                    : exported);
+            if (target !== symbol) {
+                return false;
+            }
+            checker
+                .getDeclaredTypeOfSymbol(target)
+                .getCallSignatures()
+                .forEach((signature) => {
+                if (signature.declaration) {
+                    signatures.add(signature.declaration);
+                }
+            });
+            return true;
+        }) ?? false;
+        symbols.set(symbol, matches);
+        return matches;
+    };
+    const hasDispatchAlias = (original, seen) => {
+        const symbol = original.flags & ts.SymbolFlags.Alias
+            ? checker.getAliasedSymbol(original)
+            : original;
+        if (seen.has(symbol)) {
+            return false;
+        }
+        if (isPublicDispatch(symbol)) {
+            return true;
+        }
+        const next = new Set(seen).add(symbol);
+        return (symbol.getDeclarations()?.some((declaration) => {
+            if (!ts.isTypeAliasDeclaration(declaration)) {
+                return false;
+            }
+            let target = declaration.type;
+            while (ts.isParenthesizedTypeNode(target)) {
+                target = target.type;
+            }
+            if (!ts.isTypeReferenceNode(target)) {
+                return false;
+            }
+            const referenced = checker.getSymbolAtLocation(target.typeName);
+            return !!referenced && hasDispatchAlias(referenced, next);
+        }) ?? false);
+    };
+    const isDispatch = (type, seen) => {
+        if (seen.has(type) ||
+            type.flags &
+                (ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) {
+            return false;
+        }
+        const next = new Set(seen).add(type);
+        if (type.isUnion()) {
+            const members = type.types.filter((member) => {
+                return !(member.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined));
+            });
+            return (members.length > 0 &&
+                members.every((member) => {
+                    return isDispatch(member, next);
+                }));
+        }
+        const symbol = type.aliasSymbol;
+        if (!symbol) {
+            return false;
+        }
+        if (!hasDispatchAlias(symbol, new Set())) {
+            return false;
+        }
+        // TS may intern structurally equal aliases. Their signature declarations
+        // still distinguish a local callback from the public Dispatch contract.
+        const calls = type.getCallSignatures();
+        return (calls.length > 0 &&
+            calls.every((signature) => {
+                return !!signature.declaration && signatures.has(signature.declaration);
+            }));
+    };
+    return (node) => {
+        return isDispatch(services.getTypeAtLocation(node), new Set());
+    };
+};

package/dist/lib/handler-body.d.ts

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

package/dist/lib/handler-body.js

@@ -0,0 +1,32 @@
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+// Visit only the handler's own evaluation. Deferred function bodies are separate callbacks.
+export const visitHandlerBody = (root, source, visit) => {
+    const walk = (node) => {
+        if (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionExpression ||
+            node.type === AST_NODE_TYPES.FunctionDeclaration) {
+            return;
+        }
+        visit(node);
+        (source.visitorKeys[node.type] ?? []).forEach((key) => {
+            if ((node.type === AST_NODE_TYPES.PropertyDefinition ||
+                node.type === AST_NODE_TYPES.AccessorProperty) &&
+                !node.static &&
+                key === 'value') {
+                return;
+            }
+            const value = node[key];
+            if (Array.isArray(value)) {
+                value.forEach((child) => {
+                    if (child) {
+                        walk(child);
+                    }
+                });
+            }
+            else if (value) {
+                walk(value);
+            }
+        });
+    };
+    walk(root);
+};

package/dist/lib/member-key.d.ts

@@ -0,0 +1,4 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare const memberKey: (node: TSESTree.MemberExpression, { numeric }?: {
+    numeric?: boolean;
+}) => string | undefined;

package/dist/lib/member-key.js

@@ -0,0 +1,18 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+export const memberKey = (node, { numeric = false } = {}) => {
+    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    if (node.computed && node.property.type === AST_NODE_TYPES.Literal) {
+        if (node.property.raw.startsWith("'") ||
+            node.property.raw.startsWith('"')) {
+            return String(node.property.value);
+        }
+        // Match numeric AST literals, including values such as 1e999; finiteness
+        // would change syntax classification. Existing callers remain names-only.
+        if (numeric && typeof node.property.value === 'number') {
+            return String(node.property.value);
+        }
+    }
+    return undefined;
+};

package/dist/lib/optional-call.d.ts

@@ -0,0 +1,2 @@
+import { type TSESTree } from '@typescript-eslint/utils';
+export declare const isOptionalCall: (call: TSESTree.CallExpression) => boolean;

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/ready-boolean-expression.d.ts

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

package/dist/lib/ready-boolean-expression.js

@@ -0,0 +1,17 @@
+import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { memberKey } from './member-key.js';
+export const readyBooleanExpression = (node) => {
+    if (node.type === AST_NODE_TYPES.Identifier) {
+        return true;
+    }
+    if (node.type === AST_NODE_TYPES.ChainExpression) {
+        return readyBooleanExpression(node.expression);
+    }
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return false;
+    }
+    const staticKey = memberKey(node, { numeric: true }) !== undefined;
+    return (staticKey &&
+        node.object.type !== AST_NODE_TYPES.Super &&
+        readyBooleanExpression(node.object));
+};

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 {};