eslint-plugin-svelte 2.8.0 → 2.10.0

package/README.md

@@ -89,7 +89,7 @@ This plugin provides configs:
 
 - `plugin:svelte/base` ... Configuration to enable correct Svelte parsing.
 - `plugin:svelte/recommended` ... Above, plus rules to prevent errors or unintended behavior.
-- `plugin:svelte/prettier` ... Turn off rules that may conflict with [Prettier](https://prettier.io/) ([prettier-plugin-svelte](https://github.com/sveltejs/prettier-plugin-svelte)).
+- `plugin:svelte/prettier` ... Turns off rules that may conflict with [Prettier](https://prettier.io/) (You still need to configure prettier to work with svelte yourself, for example by using [prettier-plugin-svelte](https://github.com/sveltejs/prettier-plugin-svelte).).
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-svelte/rules/) to get the `rules` that this plugin provides.
 
@@ -294,6 +294,7 @@ These rules relate to better ways of doing things to help you avoid problems:
 | [svelte/no-reactive-literals](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-reactive-literals/) | don't assign literal values in reactive statements | :bulb: |
 | [svelte/no-unused-svelte-ignore](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/) | disallow unused svelte-ignore comments | :star: |
 | [svelte/no-useless-mustaches](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-useless-mustaches/) | disallow unnecessary mustache interpolations | :wrench: |
+| [svelte/prefer-destructured-store-props](https://ota-meshi.github.io/eslint-plugin-svelte/rules/prefer-destructured-store-props/) | destructure values from object stores for better change tracking & fewer redraws | :bulb: |
 | [svelte/require-optimized-style-attribute](https://ota-meshi.github.io/eslint-plugin-svelte/rules/require-optimized-style-attribute/) | require style attributes that can be optimized |  |
 | [svelte/require-stores-init](https://ota-meshi.github.io/eslint-plugin-svelte/rules/require-stores-init/) | require initial value in store |  |
 
@@ -322,10 +323,11 @@ These rules relate to style guidelines, and are therefore quite subjective:
 
 ## Extension Rules
 
-These rules extend the rules provided by ESLint itself to work well in Svelte:
+These rules extend the rules provided by ESLint itself, or other plugins to work well in Svelte:
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [svelte/@typescript-eslint/no-unnecessary-condition](https://ota-meshi.github.io/eslint-plugin-svelte/rules/@typescript-eslint/no-unnecessary-condition/) | disallow conditionals where the type is always truthy or always falsy | :wrench: |
 | [svelte/no-inner-declarations](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-inner-declarations/) | disallow variable or `function` declarations in nested blocks | :star: |
 | [svelte/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-trailing-spaces/) | disallow trailing whitespace at the end of lines | :wrench: |
 

package/lib/rules/@typescript-eslint/no-unnecessary-condition.d.ts

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

package/lib/rules/@typescript-eslint/no-unnecessary-condition.js

@@ -0,0 +1,448 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../../utils");
+const ts_utils_1 = require("../../utils/ts-utils");
+function unionTypeParts(type) {
+    return [...iterate(type)];
+    function* iterate(t) {
+        if (t.isUnion()) {
+            for (const type of t.types) {
+                yield* iterate(type);
+            }
+        }
+        else {
+            yield t;
+        }
+    }
+}
+function isPossiblyFalsy(type, tsTools) {
+    return (unionTypeParts(type)
+        .filter((t) => !(0, ts_utils_1.isTruthyLiteral)(t, tsTools))
+        .some((type) => (0, ts_utils_1.isPossiblyFalsyType)(type, tsTools.ts)));
+}
+function isPossiblyTruthy(type, tsTools) {
+    return unionTypeParts(type).some((type) => !(0, ts_utils_1.isFalsyType)(type, tsTools));
+}
+function isPossiblyNullish(type, tsTools) {
+    return (0, ts_utils_1.isNullableType)(type, tsTools.ts);
+}
+function isAlwaysNullish(type, tsTools) {
+    return (0, ts_utils_1.isNullishType)(type, tsTools.ts);
+}
+function isLiteral(type, tsTools) {
+    return ((0, ts_utils_1.isBooleanLiteralType)(type, tsTools.ts) ||
+        (0, ts_utils_1.isNullishType)(type, tsTools.ts) ||
+        type.isLiteral());
+}
+exports.default = (0, utils_1.createRule)("@typescript-eslint/no-unnecessary-condition", {
+    meta: {
+        docs: {
+            description: "disallow conditionals where the type is always truthy or always falsy",
+            category: "Extension Rules",
+            recommended: false,
+            extensionRule: {
+                plugin: "@typescript-eslint/eslint-plugin",
+                url: "https://typescript-eslint.io/rules/no-unnecessary-condition/",
+            },
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowConstantLoopConditions: {
+                        description: "Whether to ignore constant loop conditions, such as `while (true)`.",
+                        type: "boolean",
+                    },
+                    allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing: {
+                        description: "Whether to not error when running with a tsconfig that has strictNullChecks turned.",
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        fixable: "code",
+        messages: {
+            alwaysTruthy: "Unnecessary conditional, value is always truthy.",
+            alwaysFalsy: "Unnecessary conditional, value is always falsy.",
+            alwaysTruthyFunc: "This callback should return a conditional, but return is always truthy.",
+            alwaysFalsyFunc: "This callback should return a conditional, but return is always falsy.",
+            neverNullish: "Unnecessary conditional, expected left-hand side of `??` operator to be possibly null or undefined.",
+            alwaysNullish: "Unnecessary conditional, left-hand side of `??` operator is always `null` or `undefined`.",
+            literalBooleanExpression: "Unnecessary conditional, both sides of the expression are literal values.",
+            noOverlapBooleanExpression: "Unnecessary conditional, the types have no overlap.",
+            never: "Unnecessary conditional, value is `never`.",
+            neverOptionalChain: "Unnecessary optional chain on a non-nullish value.",
+            noStrictNullCheck: "This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.",
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        const { allowConstantLoopConditions = false, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing = false, } = (context.options[0] || {});
+        const tools = (0, ts_utils_1.getTypeScriptTools)(context);
+        if (!tools) {
+            return {};
+        }
+        const { service, ts } = tools;
+        const checker = service.program.getTypeChecker();
+        const sourceCode = context.getSourceCode();
+        const compilerOptions = service.program.getCompilerOptions();
+        const isStrictNullChecks = compilerOptions.strict
+            ? compilerOptions.strictNullChecks !== false
+            : compilerOptions.strictNullChecks;
+        if (!isStrictNullChecks &&
+            allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing !== true) {
+            context.report({
+                loc: {
+                    start: { line: 0, column: 0 },
+                    end: { line: 0, column: 0 },
+                },
+                messageId: "noStrictNullCheck",
+            });
+        }
+        const mutableVarReferenceIds = [];
+        const scriptElements = [];
+        let inSvelteReactiveStatement = false;
+        for (const scope of [
+            sourceCode.scopeManager.globalScope,
+            sourceCode.scopeManager.globalScope?.childScopes.find((scope) => scope.type === "module"),
+        ]) {
+            if (!scope)
+                continue;
+            for (const variable of scope.variables) {
+                if (variable.defs.some((def) => def.type === "Variable" &&
+                    (def.parent.kind === "var" || def.parent.kind === "let"))) {
+                    for (const reference of variable.references) {
+                        mutableVarReferenceIds.push(reference.identifier);
+                    }
+                }
+            }
+        }
+        for (const body of sourceCode.ast.body) {
+            if (body.type === "SvelteScriptElement") {
+                scriptElements.push(body);
+            }
+        }
+        function hasSvelteReactiveVar(node) {
+            const inReactiveScope = inSvelteReactiveStatement ||
+                (scriptElements.length &&
+                    scriptElements.every((elem) => node.range[1] <= elem.range[0] || elem.range[1] <= node.range[0]));
+            if (!inReactiveScope) {
+                return false;
+            }
+            return mutableVarReferenceIds.some((id) => node.range[0] <= id.range[0] && id.range[1] <= node.range[1]);
+        }
+        function getNodeType(node) {
+            const tsNode = service.esTreeNodeToTSNodeMap.get(node);
+            return tsNode && (0, ts_utils_1.getConstrainedTypeAtLocation)(checker, tsNode);
+        }
+        function nodeIsArrayType(node) {
+            const nodeType = getNodeType(node);
+            if (!nodeType) {
+                return false;
+            }
+            return checker.isArrayType(nodeType);
+        }
+        function nodeIsTupleType(node) {
+            const nodeType = getNodeType(node);
+            return Boolean(nodeType && (0, ts_utils_1.isTupleType)(nodeType, ts));
+        }
+        function isArrayIndexExpression(node) {
+            return (node.type === "MemberExpression" &&
+                node.computed &&
+                (nodeIsArrayType(node.object) ||
+                    (nodeIsTupleType(node.object) &&
+                        node.property.type !== "Literal")));
+        }
+        function checkNode(node, isUnaryNotArgument = false) {
+            if (hasSvelteReactiveVar(node)) {
+                return;
+            }
+            if (node.type === "UnaryExpression" && node.operator === "!") {
+                checkNode(node.argument, true);
+                return;
+            }
+            if (isArrayIndexExpression(node)) {
+                return;
+            }
+            if (node.type === "LogicalExpression" && node.operator !== "??") {
+                checkNode(node.right);
+                return;
+            }
+            const type = getNodeType(node);
+            if (!type ||
+                unionTypeParts(type).some((part) => (0, ts_utils_1.isAnyType)(part, ts) ||
+                    (0, ts_utils_1.isUnknownType)(part, ts) ||
+                    part.isTypeParameter())) {
+                return;
+            }
+            let messageId = null;
+            if (unionTypeParts(type).some((part) => (0, ts_utils_1.isNeverType)(part, ts))) {
+                messageId = "never";
+            }
+            else if (!isPossiblyTruthy(type, tools)) {
+                messageId = !isUnaryNotArgument ? "alwaysFalsy" : "alwaysTruthy";
+            }
+            else if (!isPossiblyFalsy(type, tools)) {
+                messageId = !isUnaryNotArgument ? "alwaysTruthy" : "alwaysFalsy";
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        function checkNodeForNullish(node) {
+            if (hasSvelteReactiveVar(node)) {
+                return;
+            }
+            const type = getNodeType(node);
+            if (!type || (0, ts_utils_1.isAnyType)(type, ts) || (0, ts_utils_1.isUnknownType)(type, ts)) {
+                return;
+            }
+            let messageId = null;
+            if (unionTypeParts(type).some((part) => (0, ts_utils_1.isNeverType)(part, ts))) {
+                messageId = "never";
+            }
+            else if (!isPossiblyNullish(type, tools)) {
+                if (!isArrayIndexExpression(node) &&
+                    !(node.type === "ChainExpression" &&
+                        node.expression.type !== "TSNonNullExpression" &&
+                        optionChainContainsOptionArrayIndex(node.expression))) {
+                    messageId = "neverNullish";
+                }
+            }
+            else if (isAlwaysNullish(type, tools)) {
+                messageId = "alwaysNullish";
+            }
+            if (messageId) {
+                context.report({ node, messageId });
+            }
+        }
+        const BOOL_OPERATORS = new Set([
+            "<",
+            ">",
+            "<=",
+            ">=",
+            "==",
+            "===",
+            "!=",
+            "!==",
+        ]);
+        function checkIfBinaryExpressionIsNecessaryConditional(node) {
+            if (hasSvelteReactiveVar(node)) {
+                return;
+            }
+            if (!BOOL_OPERATORS.has(node.operator)) {
+                return;
+            }
+            const leftType = getNodeType(node.left);
+            const rightType = getNodeType(node.right);
+            if (!leftType || !rightType) {
+                return;
+            }
+            if (isLiteral(leftType, tools) && isLiteral(rightType, tools)) {
+                context.report({ node, messageId: "literalBooleanExpression" });
+                return;
+            }
+            if (isStrictNullChecks) {
+                const UNDEFINED = ts.TypeFlags.Undefined;
+                const NULL = ts.TypeFlags.Null;
+                const isComparable = (type, f) => {
+                    let flag = f;
+                    flag |=
+                        ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.TypeParameter;
+                    if (node.operator === "==" || node.operator === "!=") {
+                        flag |= NULL | UNDEFINED;
+                    }
+                    return unionTypeParts(type).some((t) => (t.flags & flag) !== 0);
+                };
+                if ((leftType.flags === UNDEFINED &&
+                    !isComparable(rightType, UNDEFINED)) ||
+                    (rightType.flags === UNDEFINED &&
+                        !isComparable(leftType, UNDEFINED)) ||
+                    (leftType.flags === NULL && !isComparable(rightType, NULL)) ||
+                    (rightType.flags === NULL && !isComparable(leftType, NULL))) {
+                    context.report({ node, messageId: "noOverlapBooleanExpression" });
+                }
+            }
+        }
+        function checkLogicalExpressionForUnnecessaryConditionals(node) {
+            if (node.operator === "??") {
+                checkNodeForNullish(node.left);
+                return;
+            }
+            checkNode(node.left);
+        }
+        function checkIfLoopIsNecessaryConditional(node) {
+            if (node.test === null) {
+                return;
+            }
+            if (allowConstantLoopConditions) {
+                const nodeType = getNodeType(node.test);
+                if (nodeType &&
+                    (0, ts_utils_1.isBooleanLiteralType)(nodeType, ts) &&
+                    checker.typeToString(nodeType) === "true")
+                    return;
+            }
+            checkNode(node.test);
+        }
+        const ARRAY_PREDICATE_FUNCTIONS = new Set([
+            "filter",
+            "find",
+            "some",
+            "every",
+        ]);
+        function isArrayPredicateFunction(node) {
+            const { callee } = node;
+            return (callee.type === "MemberExpression" &&
+                callee.property.type === "Identifier" &&
+                ARRAY_PREDICATE_FUNCTIONS.has(callee.property.name) &&
+                (nodeIsArrayType(callee.object) || nodeIsTupleType(callee.object)));
+        }
+        function checkCallExpression(node) {
+            if (isArrayPredicateFunction(node) && node.arguments.length) {
+                const callback = node.arguments[0];
+                if ((callback.type === "ArrowFunctionExpression" ||
+                    callback.type === "FunctionExpression") &&
+                    callback.body) {
+                    if (callback.body.type !== "BlockStatement") {
+                        checkNode(callback.body);
+                        return;
+                    }
+                    const callbackBody = callback.body.body;
+                    if (callbackBody.length === 1 &&
+                        callbackBody[0].type === "ReturnStatement" &&
+                        callbackBody[0].argument) {
+                        checkNode(callbackBody[0].argument);
+                        return;
+                    }
+                }
+                const nodeType = getNodeType(callback);
+                if (!nodeType) {
+                    return;
+                }
+                const returnTypes = (0, ts_utils_1.getCallSignaturesOfType)(nodeType).map((sig) => sig.getReturnType());
+                if (returnTypes.length === 0) {
+                    return;
+                }
+                if (returnTypes.some((t) => (0, ts_utils_1.isAnyType)(t, ts) || (0, ts_utils_1.isUnknownType)(t, ts))) {
+                    return;
+                }
+                if (!returnTypes.some((t) => isPossiblyFalsy(t, tools))) {
+                    context.report({
+                        node: callback,
+                        messageId: "alwaysTruthyFunc",
+                    });
+                    return;
+                }
+                if (!returnTypes.some((t) => isPossiblyTruthy(t, tools))) {
+                    context.report({
+                        node: callback,
+                        messageId: "alwaysFalsyFunc",
+                    });
+                }
+            }
+        }
+        function optionChainContainsOptionArrayIndex(node) {
+            const lhsNode = node.type === "CallExpression" ? node.callee : node.object;
+            if (node.optional && isArrayIndexExpression(lhsNode)) {
+                return true;
+            }
+            if (lhsNode.type === "MemberExpression" ||
+                lhsNode.type === "CallExpression") {
+                return optionChainContainsOptionArrayIndex(lhsNode);
+            }
+            return false;
+        }
+        function isNullablePropertyType(objType, propertyType) {
+            if (propertyType.isUnion()) {
+                return propertyType.types.some((type) => isNullablePropertyType(objType, type));
+            }
+            if (propertyType.isNumberLiteral() || propertyType.isStringLiteral()) {
+                const propType = (0, ts_utils_1.getTypeOfPropertyOfType)(objType, propertyType.value.toString(), checker);
+                if (propType) {
+                    return (0, ts_utils_1.isNullableType)(propType, ts);
+                }
+            }
+            const typeName = (0, ts_utils_1.getTypeName)(propertyType, tools);
+            return Boolean((typeName === "string" &&
+                checker.getIndexInfoOfType(objType, ts.IndexKind.String)) ||
+                (typeName === "number" &&
+                    checker.getIndexInfoOfType(objType, ts.IndexKind.Number)));
+        }
+        function isNullableOriginFromPrev(node) {
+            const prevType = getNodeType(node.object);
+            const property = node.property;
+            if (prevType && prevType.isUnion() && property.type === "Identifier") {
+                const isOwnNullable = prevType.types.some((type) => {
+                    if (node.computed) {
+                        const propertyType = getNodeType(node.property);
+                        return Boolean(propertyType && isNullablePropertyType(type, propertyType));
+                    }
+                    const propType = (0, ts_utils_1.getTypeOfPropertyOfType)(type, property.name, checker);
+                    return propType && (0, ts_utils_1.isNullableType)(propType, ts);
+                });
+                return !isOwnNullable && (0, ts_utils_1.isNullableType)(prevType, ts);
+            }
+            return false;
+        }
+        function isOptionableExpression(node) {
+            const type = getNodeType(node);
+            if (!type) {
+                return false;
+            }
+            const isOwnNullable = node.type === "MemberExpression"
+                ? !isNullableOriginFromPrev(node)
+                : true;
+            return ((0, ts_utils_1.isAnyType)(type, ts) ||
+                (0, ts_utils_1.isUnknownType)(type, ts) ||
+                ((0, ts_utils_1.isNullableType)(type, ts) && isOwnNullable));
+        }
+        function checkOptionalChain(node, beforeOperator, fix) {
+            if (!node.optional) {
+                return;
+            }
+            if (optionChainContainsOptionArrayIndex(node)) {
+                return;
+            }
+            const nodeToCheck = node.type === "CallExpression" ? node.callee : node.object;
+            if (hasSvelteReactiveVar(nodeToCheck)) {
+                return;
+            }
+            if (isOptionableExpression(nodeToCheck)) {
+                return;
+            }
+            const questionDotOperator = sourceCode.getTokenAfter(beforeOperator, {
+                includeComments: false,
+                filter: (token) => token.type === "Punctuator" && token.value === "?.",
+            });
+            context.report({
+                node,
+                loc: questionDotOperator.loc,
+                messageId: "neverOptionalChain",
+                fix(fixer) {
+                    return fixer.replaceText(questionDotOperator, fix);
+                },
+            });
+        }
+        function checkOptionalMemberExpression(node) {
+            checkOptionalChain(node, node.object, node.computed ? "" : ".");
+        }
+        function checkOptionalCallExpression(node) {
+            checkOptionalChain(node, node.callee, "");
+        }
+        return {
+            SvelteReactiveStatement: () => (inSvelteReactiveStatement = true),
+            "SvelteReactiveStatement:exit": () => (inSvelteReactiveStatement = false),
+            BinaryExpression: checkIfBinaryExpressionIsNecessaryConditional,
+            CallExpression: checkCallExpression,
+            ConditionalExpression: (node) => checkNode(node.test),
+            DoWhileStatement: checkIfLoopIsNecessaryConditional,
+            ForStatement: checkIfLoopIsNecessaryConditional,
+            IfStatement: (node) => checkNode(node.test),
+            LogicalExpression: checkLogicalExpressionForUnnecessaryConditionals,
+            WhileStatement: checkIfLoopIsNecessaryConditional,
+            "MemberExpression[optional = true]": checkOptionalMemberExpression,
+            "CallExpression[optional = true]": checkOptionalCallExpression,
+        };
+    },
+});

package/lib/rules/prefer-destructured-store-props.d.ts

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

package/lib/rules/prefer-destructured-store-props.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const eslint_utils_1 = require("eslint-utils");
+const esutils_1 = require("esutils");
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+exports.default = (0, utils_1.createRule)("prefer-destructured-store-props", {
+    meta: {
+        docs: {
+            description: "destructure values from object stores for better change tracking & fewer redraws",
+            category: "Best Practices",
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            useDestructuring: `Destructure {{property}} from {{store}} for better change tracking & fewer redraws`,
+            fixUseDestructuring: `Using destructuring like $: ({ {{property}} } = {{store}}); will run faster`,
+            fixUseVariable: `Using the predefined reactive variable {{variable}}`,
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        let mainScript = null;
+        const reports = [];
+        let inScriptElement = false;
+        const storeMemberAccessStack = [];
+        function* findReactiveVariable(object, propName) {
+            const storeVar = (0, ast_utils_1.findVariable)(context, object);
+            if (!storeVar) {
+                return;
+            }
+            for (const reference of storeVar.references) {
+                const id = reference.identifier;
+                if (id.name !== object.name)
+                    continue;
+                if (isReactiveVariableDefinitionWithMemberExpression(id)) {
+                    yield id.parent.parent.left;
+                }
+                else if (isReactiveVariableDefinitionWithDestructuring(id)) {
+                    const prop = id.parent.left.properties.find((prop) => prop.type === "Property" &&
+                        prop.value.type === "Identifier" &&
+                        (0, eslint_utils_1.getPropertyName)(prop) === propName);
+                    if (prop) {
+                        yield prop.value;
+                    }
+                }
+            }
+            function isReactiveVariableDefinitionWithMemberExpression(node) {
+                return (node.parent?.type === "MemberExpression" &&
+                    node.parent.object === node &&
+                    (0, eslint_utils_1.getPropertyName)(node.parent) === propName &&
+                    node.parent.parent?.type === "AssignmentExpression" &&
+                    node.parent.parent.right === node.parent &&
+                    node.parent.parent.left.type === "Identifier" &&
+                    node.parent.parent.parent?.type === "ExpressionStatement" &&
+                    node.parent.parent.parent
+                        .parent?.type === "SvelteReactiveStatement");
+            }
+            function isReactiveVariableDefinitionWithDestructuring(node) {
+                return (node.parent?.type === "AssignmentExpression" &&
+                    node.parent.right === node &&
+                    node.parent.left.type === "ObjectPattern" &&
+                    node.parent.parent?.type === "ExpressionStatement" &&
+                    node.parent.parent.parent
+                        ?.type === "SvelteReactiveStatement");
+            }
+        }
+        function hasTopLevelVariable(name) {
+            const scopeManager = context.getSourceCode().scopeManager;
+            if (scopeManager.globalScope?.set.has(name)) {
+                return true;
+            }
+            const moduleScope = scopeManager.globalScope?.childScopes.find((s) => s.type === "module");
+            return moduleScope?.set.has(name) || false;
+        }
+        return {
+            SvelteScriptElement(node) {
+                inScriptElement = true;
+                const scriptContext = (0, ast_utils_1.findAttribute)(node, "context");
+                const contextValue = scriptContext?.value.length === 1 && scriptContext.value[0];
+                if (contextValue &&
+                    contextValue.type === "SvelteLiteral" &&
+                    contextValue.value === "module") {
+                    return;
+                }
+                mainScript = node;
+            },
+            "SvelteScriptElement:exit"() {
+                inScriptElement = false;
+            },
+            "MemberExpression[object.type='Identifier'][object.name=/^\\$/]"(node) {
+                if (inScriptElement)
+                    return;
+                storeMemberAccessStack.unshift({ node, identifiers: [] });
+            },
+            Identifier(node) {
+                storeMemberAccessStack[0]?.identifiers.push(node);
+            },
+            "MemberExpression[object.type='Identifier'][object.name=/^\\$/]:exit"(node) {
+                if (storeMemberAccessStack[0]?.node !== node)
+                    return;
+                const { identifiers } = storeMemberAccessStack.shift();
+                for (const id of identifiers) {
+                    if (!(0, ast_utils_1.isExpressionIdentifier)(id))
+                        continue;
+                    const variable = (0, ast_utils_1.findVariable)(context, id);
+                    const isTopLevel = !variable ||
+                        variable.scope.type === "module" ||
+                        variable.scope.type === "global";
+                    if (!isTopLevel) {
+                        return;
+                    }
+                }
+                reports.push(node);
+            },
+            "Program:exit"() {
+                const scriptEndTag = mainScript && mainScript.endTag;
+                for (const node of reports) {
+                    const store = node.object.name;
+                    const suggest = [];
+                    if (!node.computed) {
+                        for (const variable of findReactiveVariable(node.object, node.property.name)) {
+                            suggest.push({
+                                messageId: "fixUseVariable",
+                                data: {
+                                    variable: variable.name,
+                                },
+                                fix(fixer) {
+                                    return fixer.replaceText(node, variable.name);
+                                },
+                            });
+                        }
+                        if (scriptEndTag) {
+                            suggest.push({
+                                messageId: "fixUseDestructuring",
+                                data: {
+                                    store,
+                                    property: node.property.name,
+                                },
+                                fix(fixer) {
+                                    const propName = node.property.name;
+                                    let varName = propName;
+                                    if (varName.startsWith("$")) {
+                                        varName = varName.slice(1);
+                                    }
+                                    const baseName = varName;
+                                    let suffix = 0;
+                                    if (esutils_1.keyword.isReservedWordES6(varName, true) ||
+                                        esutils_1.keyword.isRestrictedWord(varName)) {
+                                        varName = `${baseName}${++suffix}`;
+                                    }
+                                    while (hasTopLevelVariable(varName)) {
+                                        varName = `${baseName}${++suffix}`;
+                                    }
+                                    return [
+                                        fixer.insertTextAfterRange([scriptEndTag.range[0], scriptEndTag.range[0]], `$: ({ ${propName}${propName !== varName ? `: ${varName}` : ""} } = ${store});\n`),
+                                        fixer.replaceText(node, varName),
+                                    ];
+                                },
+                            });
+                        }
+                    }
+                    context.report({
+                        node,
+                        messageId: "useDestructuring",
+                        data: {
+                            store,
+                            property: !node.computed
+                                ? node.property.name
+                                : context
+                                    .getSourceCode()
+                                    .getText(node.property)
+                                    .replace(/\s+/g, " "),
+                        },
+                        suggest,
+                    });
+                }
+            },
+        };
+    },
+});

package/lib/rules/system.js

@@ -60,7 +60,7 @@ exports.default = (0, utils_1.createRule)("system", {
                     loc: node.startTag.loc.end,
                 });
                 if (node.endTag) {
-                    directives.enableBlock(node.endTag.loc.start, isIgnoreRule, {
+                    directives.disableBlock(node.endTag.loc.start, isIgnoreRule, {
                         loc: node.endTag.loc.start,
                     });
                 }

package/lib/shared/svelte-compile-warns/transform/babel.js

@@ -33,7 +33,7 @@ function transform(node, context) {
             mappings: output.map.mappings,
         };
     }
-    catch (e) {
+    catch (_e) {
         return null;
     }
 }

package/lib/shared/svelte-compile-warns/transform/less.js

@@ -35,7 +35,7 @@ function transform(node, context) {
             mappings: JSON.parse(output.map).mappings,
         };
     }
-    catch (e) {
+    catch (_e) {
         return null;
     }
 }

package/lib/shared/svelte-compile-warns/transform/postcss.js

@@ -38,7 +38,7 @@ function transform(node, context) {
             mappings: result.map.toJSON().mappings,
         };
     }
-    catch (e) {
+    catch (_e) {
         return null;
     }
 }

package/lib/shared/svelte-compile-warns/transform/sass.js

@@ -29,7 +29,7 @@ function transform(node, context, type) {
             mappings: output.sourceMap.mappings,
         };
     }
-    catch (e) {
+    catch (_e) {
         return null;
     }
 }

package/lib/shared/svelte-compile-warns/transform/stylus.js

@@ -34,7 +34,7 @@ function transform(node, context) {
                 .mappings,
         };
     }
-    catch (e) {
+    catch (_e) {
         return null;
     }
 }

package/lib/types.d.ts

@@ -22,7 +22,10 @@ export interface RuleMetaData {
         description: string;
         category: RuleCategory;
         recommended: boolean | "base";
-        extensionRule?: string;
+        extensionRule?: string | {
+            plugin: string;
+            url: string;
+        };
         url: string;
         ruleId: string;
         ruleName: string;
@@ -47,7 +50,10 @@ export interface PartialRuleMetaData {
     docs: {
         description: string;
         recommended: boolean | "base";
-        extensionRule?: string;
+        extensionRule?: string | {
+            plugin: string;
+            url: string;
+        };
         default?: "error" | "warn";
     } & ({
         category: Exclude<RuleCategory, "Stylistic Issues">;
@@ -108,7 +114,7 @@ declare type SuggestionDescriptorMessage = {
 } | {
     messageId: string;
 };
-declare type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
+export declare type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
 interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
     suggest?: SuggestionReportDescriptor[] | null;
 }

package/lib/utils/ast-utils.d.ts

@@ -1,9 +1,10 @@
 import type { ASTNode, RuleContext, SourceCode } from "../types";
 import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 import type { AST as SvAST } from "svelte-eslint-parser";
 import type { Scope } from "eslint";
 export declare function equalTokens(left: ASTNode, right: ASTNode, sourceCode: SourceCode): boolean;
-export declare function getStringIfConstant(node: ESTree.Expression): string | null;
+export declare function getStringIfConstant(node: ESTree.Expression | TSESTree.Expression): string | null;
 export declare function needParentheses(node: ESTree.Expression, kind: "not" | "logical"): boolean;
 export declare function isHTMLElementLike(node: SvAST.SvelteElement | SvAST.SvelteScriptElement | SvAST.SvelteStyleElement): node is SvAST.SvelteHTMLElement | (SvAST.SvelteSpecialElement & {
     name: SvAST.SvelteName & {
@@ -29,7 +30,7 @@ export declare function findBindDirective<N extends string>(node: SvAST.SvelteEl
 }) | null;
 export declare function getStaticAttributeValue(node: SvAST.SvelteAttribute): string | null;
 export declare function getLangValue(node: SvAST.SvelteScriptElement | SvAST.SvelteStyleElement): string | null;
-export declare function findVariable(context: RuleContext, node: ESTree.Identifier): Scope.Variable | null;
+export declare function findVariable(context: RuleContext, node: ESTree.Identifier | TSESTree.Identifier): Scope.Variable | null;
 export declare function getScope(context: RuleContext, currentNode: ESTree.Node): Scope.Scope;
 export declare type QuoteAndRange = {
     quote: "unquoted" | "double" | "single";
@@ -50,3 +51,4 @@ export declare function getAttributeKeyText(node: SvAST.SvelteAttribute | SvAST.
 export declare function getDirectiveName(node: SvAST.SvelteDirective): string;
 export declare function getNodeName(node: SvAST.SvelteElement): string;
 export declare function isVoidHtmlElement(node: SvAST.SvelteElement): boolean;
+export declare function isExpressionIdentifier(node: TSESTree.Identifier): boolean;

package/lib/utils/ast-utils.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isVoidHtmlElement = exports.getNodeName = exports.getDirectiveName = exports.getAttributeKeyText = exports.getMustacheTokens = exports.getAttributeValueQuoteAndRange = exports.getScope = exports.findVariable = exports.getLangValue = exports.getStaticAttributeValue = exports.findBindDirective = exports.findShorthandAttribute = exports.findAttribute = exports.isHTMLElementLike = exports.needParentheses = exports.getStringIfConstant = exports.equalTokens = void 0;
+exports.isExpressionIdentifier = exports.isVoidHtmlElement = exports.getNodeName = exports.getDirectiveName = exports.getAttributeKeyText = exports.getMustacheTokens = exports.getAttributeValueQuoteAndRange = exports.getScope = exports.findVariable = exports.getLangValue = exports.getStaticAttributeValue = exports.findBindDirective = exports.findShorthandAttribute = exports.findAttribute = exports.isHTMLElementLike = exports.needParentheses = exports.getStringIfConstant = exports.equalTokens = void 0;
 const eslintUtils = __importStar(require("eslint-utils"));
 const void_elements_1 = __importDefault(require("./void-elements"));
 function equalTokens(left, right, sourceCode) {
@@ -168,7 +168,15 @@ function getLangValue(node) {
 }
 exports.getLangValue = getLangValue;
 function findVariable(context, node) {
-    return eslintUtils.findVariable(getScope(context, node), node);
+    const initialScope = eslintUtils.getInnermostScope(getScope(context, node), node);
+    const variable = eslintUtils.findVariable(initialScope, node);
+    if (variable) {
+        return variable;
+    }
+    if (!node.name.startsWith("$")) {
+        return variable;
+    }
+    return eslintUtils.findVariable(initialScope, node.name.slice(1));
 }
 exports.findVariable = findVariable;
 function getScope(context, currentNode) {
@@ -346,3 +354,39 @@ function isVoidHtmlElement(node) {
     return void_elements_1.default.includes(getNodeName(node));
 }
 exports.isVoidHtmlElement = isVoidHtmlElement;
+function isExpressionIdentifier(node) {
+    const parent = node.parent;
+    if (!parent) {
+        return true;
+    }
+    if (parent.type === "MemberExpression") {
+        return !parent.computed || parent.property !== node;
+    }
+    if (parent.type === "Property" ||
+        parent.type === "MethodDefinition" ||
+        parent.type === "PropertyDefinition") {
+        return !parent.computed || parent.key !== node;
+    }
+    if (parent.type === "FunctionDeclaration" ||
+        parent.type === "FunctionExpression" ||
+        parent.type === "ClassDeclaration" ||
+        parent.type === "ClassExpression") {
+        return parent.id !== node;
+    }
+    if (parent.type === "LabeledStatement" ||
+        parent.type === "BreakStatement" ||
+        parent.type === "ContinueStatement") {
+        return parent.label !== node;
+    }
+    if (parent.type === "MetaProperty") {
+        return parent.property !== node;
+    }
+    if (parent.type === "ImportSpecifier") {
+        return parent.imported !== node;
+    }
+    if (parent.type === "ExportSpecifier") {
+        return parent.exported !== node;
+    }
+    return true;
+}
+exports.isExpressionIdentifier = isExpressionIdentifier;

package/lib/utils/rules.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rules = void 0;
+const no_unnecessary_condition_1 = __importDefault(require("../rules/@typescript-eslint/no-unnecessary-condition"));
 const button_has_type_1 = __importDefault(require("../rules/button-has-type"));
 const comment_directive_1 = __importDefault(require("../rules/comment-directive"));
 const derived_has_same_inputs_outputs_1 = __importDefault(require("../rules/derived-has-same-inputs-outputs"));
@@ -34,6 +35,7 @@ const no_unknown_style_directive_property_1 = __importDefault(require("../rules/
 const no_unused_svelte_ignore_1 = __importDefault(require("../rules/no-unused-svelte-ignore"));
 const no_useless_mustaches_1 = __importDefault(require("../rules/no-useless-mustaches"));
 const prefer_class_directive_1 = __importDefault(require("../rules/prefer-class-directive"));
+const prefer_destructured_store_props_1 = __importDefault(require("../rules/prefer-destructured-store-props"));
 const prefer_style_directive_1 = __importDefault(require("../rules/prefer-style-directive"));
 const require_optimized_style_attribute_1 = __importDefault(require("../rules/require-optimized-style-attribute"));
 const require_stores_init_1 = __importDefault(require("../rules/require-stores-init"));
@@ -44,6 +46,7 @@ const spaced_html_comment_1 = __importDefault(require("../rules/spaced-html-comm
 const system_1 = __importDefault(require("../rules/system"));
 const valid_compile_1 = __importDefault(require("../rules/valid-compile"));
 exports.rules = [
+    no_unnecessary_condition_1.default,
     button_has_type_1.default,
     comment_directive_1.default,
     derived_has_same_inputs_outputs_1.default,
@@ -74,6 +77,7 @@ exports.rules = [
     no_unused_svelte_ignore_1.default,
     no_useless_mustaches_1.default,
     prefer_class_directive_1.default,
+    prefer_destructured_store_props_1.default,
     prefer_style_directive_1.default,
     require_optimized_style_attribute_1.default,
     require_stores_init_1.default,

package/lib/utils/ts-utils/index.d.ts

@@ -0,0 +1,35 @@
+import type { RuleContext, ASTNode } from "../../types";
+import type * as TS from "typescript";
+export declare type TypeScript = typeof TS;
+export type { TS };
+export declare type TSTools = {
+    service: {
+        esTreeNodeToTSNodeMap: ReadonlyMap<unknown, TS.Node>;
+        tsNodeToESTreeNodeMap: ReadonlyMap<TS.Node, ASTNode>;
+        program: TS.Program;
+        hasFullTypeInformation: boolean;
+    };
+    ts: TypeScript;
+};
+export declare function getTypeScriptTools(context: RuleContext): TSTools | null;
+export declare function getTypeScript(context: RuleContext): TypeScript | undefined;
+export declare function isTruthyLiteral(type: TS.Type, tsTools: TSTools): boolean;
+export declare function isFalsyType(type: TS.Type, tsTools: TSTools): boolean;
+export declare function isNullishType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNullableType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isBooleanLiteralType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isObjectType(type: TS.Type, ts: TypeScript): type is TS.ObjectType;
+export declare function isReferenceObjectType(type: TS.Type, ts: TypeScript): type is TS.TypeReference;
+export declare function isTupleObjectType(type: TS.Type, ts: TypeScript): type is TS.TupleType;
+export declare function isTupleType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isAnyType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isUnknownType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNeverType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isUndefinedType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isVoidType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isNullType(type: TS.Type, ts: TypeScript): boolean;
+export declare function isPossiblyFalsyType(type: TS.Type, ts: TypeScript): boolean;
+export declare function getCallSignaturesOfType(type: TS.Type): readonly TS.Signature[];
+export declare function getConstrainedTypeAtLocation(checker: TS.TypeChecker, node: TS.Node): TS.Type;
+export declare function getTypeName(type: TS.Type, tsTools: TSTools): string;
+export declare function getTypeOfPropertyOfType(type: TS.Type, name: string, checker: TS.TypeChecker): TS.Type | undefined;

package/lib/utils/ts-utils/index.js

@@ -0,0 +1,205 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeOfPropertyOfType = exports.getTypeName = exports.getConstrainedTypeAtLocation = exports.getCallSignaturesOfType = exports.isPossiblyFalsyType = exports.isNullType = exports.isVoidType = exports.isUndefinedType = exports.isNeverType = exports.isUnknownType = exports.isAnyType = exports.isTupleType = exports.isTupleObjectType = exports.isReferenceObjectType = exports.isObjectType = exports.isBooleanLiteralType = exports.isNullableType = exports.isNullishType = exports.isFalsyType = exports.isTruthyLiteral = exports.getTypeScript = exports.getTypeScriptTools = void 0;
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+function getTypeScriptTools(context) {
+    const ts = getTypeScript(context);
+    if (!ts) {
+        return null;
+    }
+    const { program, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap } = context.parserServices;
+    if (!program || !esTreeNodeToTSNodeMap || !tsNodeToESTreeNodeMap) {
+        return null;
+    }
+    const hasFullTypeInformation = context.parserServices.hasFullTypeInformation ?? true;
+    if (!hasFullTypeInformation) {
+        return null;
+    }
+    return {
+        service: {
+            esTreeNodeToTSNodeMap,
+            tsNodeToESTreeNodeMap,
+            hasFullTypeInformation,
+            program,
+        },
+        ts,
+    };
+}
+exports.getTypeScriptTools = getTypeScriptTools;
+let cacheTypeScript;
+function getTypeScript(context) {
+    if (cacheTypeScript) {
+        return cacheTypeScript;
+    }
+    try {
+        const cwd = context.getCwd?.() ?? process.cwd();
+        const relativeTo = path_1.default.join(cwd, "__placeholder__.js");
+        cacheTypeScript = module_1.default.createRequire(relativeTo)("typescript");
+    }
+    catch {
+    }
+    if (cacheTypeScript) {
+        return cacheTypeScript;
+    }
+    try {
+        cacheTypeScript ?? (cacheTypeScript = require("typescript"));
+    }
+    catch {
+    }
+    return cacheTypeScript;
+}
+exports.getTypeScript = getTypeScript;
+function isTruthyLiteral(type, tsTools) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isTruthyLiteral(t, tsTools));
+    }
+    return ((isBooleanLiteralType(type, tsTools.ts) &&
+        tsTools.service.program.getTypeChecker().typeToString(type) === "true") ||
+        (type.isLiteral() && Boolean(type.value)));
+}
+exports.isTruthyLiteral = isTruthyLiteral;
+function isFalsyType(type, tsTools) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isFalsyType(t, tsTools));
+    }
+    if (isUndefinedType(type, tsTools.ts) ||
+        isNullType(type, tsTools.ts) ||
+        isVoidType(type, tsTools.ts))
+        return true;
+    if (type.isLiteral())
+        return !type.value;
+    return (isBooleanLiteralType(type, tsTools.ts) &&
+        tsTools.service.program.getTypeChecker().typeToString(type) === "false");
+}
+exports.isFalsyType = isFalsyType;
+function isNullishType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isNullishType(t, ts));
+    }
+    return isNullType(type, ts) || isUndefinedType(type, ts);
+}
+exports.isNullishType = isNullishType;
+function isNullableType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isNullableType(t, ts));
+    }
+    return isNullType(type, ts) || isUndefinedType(type, ts);
+}
+exports.isNullableType = isNullableType;
+function isBooleanLiteralType(type, ts) {
+    return (type.flags & ts.TypeFlags.BooleanLiteral) !== 0;
+}
+exports.isBooleanLiteralType = isBooleanLiteralType;
+function isObjectType(type, ts) {
+    return (type.flags & ts.TypeFlags.Object) !== 0;
+}
+exports.isObjectType = isObjectType;
+function isReferenceObjectType(type, ts) {
+    return (isObjectType(type, ts) &&
+        (type.objectFlags & ts.ObjectFlags.Reference) !== 0);
+}
+exports.isReferenceObjectType = isReferenceObjectType;
+function isTupleObjectType(type, ts) {
+    return (isObjectType(type, ts) && (type.objectFlags & ts.ObjectFlags.Tuple) !== 0);
+}
+exports.isTupleObjectType = isTupleObjectType;
+function isTupleType(type, ts) {
+    return (isTupleObjectType(type, ts) ||
+        (isReferenceObjectType(type, ts) && isTupleObjectType(type.target, ts)));
+}
+exports.isTupleType = isTupleType;
+function isAnyType(type, ts) {
+    return (type.flags & ts.TypeFlags.Any) !== 0;
+}
+exports.isAnyType = isAnyType;
+function isUnknownType(type, ts) {
+    return (type.flags & ts.TypeFlags.Unknown) !== 0;
+}
+exports.isUnknownType = isUnknownType;
+function isNeverType(type, ts) {
+    return (type.flags & ts.TypeFlags.Never) !== 0;
+}
+exports.isNeverType = isNeverType;
+function isUndefinedType(type, ts) {
+    return (type.flags & ts.TypeFlags.Undefined) !== 0;
+}
+exports.isUndefinedType = isUndefinedType;
+function isVoidType(type, ts) {
+    return (type.flags & ts.TypeFlags.Void) !== 0;
+}
+exports.isVoidType = isVoidType;
+function isNullType(type, ts) {
+    return (type.flags & ts.TypeFlags.Null) !== 0;
+}
+exports.isNullType = isNullType;
+function isPossiblyFalsyType(type, ts) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isPossiblyFalsyType(t, ts));
+    }
+    return (type.flags & ts.TypeFlags.PossiblyFalsy) !== 0;
+}
+exports.isPossiblyFalsyType = isPossiblyFalsyType;
+function getCallSignaturesOfType(type) {
+    if (type.isUnion()) {
+        return type.types.flatMap((t) => getCallSignaturesOfType(t));
+    }
+    if (type.isIntersection()) {
+        let signatures = [];
+        for (const t of type.types) {
+            const sig = getCallSignaturesOfType(t);
+            if (sig.length !== 0) {
+                if (signatures.length) {
+                    return [];
+                }
+                signatures = sig;
+            }
+        }
+        return signatures;
+    }
+    return type.getCallSignatures();
+}
+exports.getCallSignaturesOfType = getCallSignaturesOfType;
+function getConstrainedTypeAtLocation(checker, node) {
+    const nodeType = checker.getTypeAtLocation(node);
+    const constrained = checker.getBaseConstraintOfType(nodeType);
+    return constrained ?? nodeType;
+}
+exports.getConstrainedTypeAtLocation = getConstrainedTypeAtLocation;
+function getTypeName(type, tsTools) {
+    const { ts } = tsTools;
+    if ((type.flags & ts.TypeFlags.StringLike) !== 0) {
+        return "string";
+    }
+    const typeChecker = tsTools.service.program.getTypeChecker();
+    if ((type.flags & ts.TypeFlags.TypeParameter) !== 0) {
+        const symbol = type.getSymbol();
+        const decls = symbol?.getDeclarations();
+        const typeParamDecl = decls?.[0];
+        if (ts.isTypeParameterDeclaration(typeParamDecl) &&
+            typeParamDecl.constraint != null) {
+            return getTypeName(typeChecker.getTypeFromTypeNode(typeParamDecl.constraint), tsTools);
+        }
+    }
+    if (type.isUnion() &&
+        type.types
+            .map((value) => getTypeName(value, tsTools))
+            .every((t) => t === "string")) {
+        return "string";
+    }
+    if (type.isIntersection() &&
+        type.types
+            .map((value) => getTypeName(value, tsTools))
+            .some((t) => t === "string")) {
+        return "string";
+    }
+    return typeChecker.typeToString(type);
+}
+exports.getTypeName = getTypeName;
+function getTypeOfPropertyOfType(type, name, checker) {
+    return checker.getTypeOfPropertyOfType(type, name);
+}
+exports.getTypeOfPropertyOfType = getTypeOfPropertyOfType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "ESLint plugin for Svelte using AST",
   "repository": "git+https://github.com/ota-meshi/eslint-plugin-svelte.git",
   "homepage": "https://ota-meshi.github.io/eslint-plugin-svelte",
@@ -67,6 +67,7 @@
   "dependencies": {
     "debug": "^4.3.1",
     "eslint-utils": "^3.0.0",
+    "esutils": "^2.0.3",
     "known-css-properties": "^0.25.0",
     "postcss": "^8.4.5",
     "postcss-load-config": "^3.1.4",
@@ -88,7 +89,7 @@
     "@changesets/changelog-github": "^0.4.6",
     "@changesets/cli": "^2.24.2",
     "@fontsource/fira-mono": "^4.5.0",
-    "@ota-meshi/eslint-plugin": "^0.12.0",
+    "@ota-meshi/eslint-plugin": "^0.13.0",
     "@sindresorhus/slugify": "^2.1.0",
     "@sveltejs/adapter-static": "^1.0.0-next.40",
     "@sveltejs/kit": "^1.0.0-next.456",
@@ -100,11 +101,12 @@
     "@types/eslint-utils": "^3.0.1",
     "@types/eslint-visitor-keys": "^1.0.0",
     "@types/estree": "^1.0.0",
+    "@types/esutils": "^2.0.0",
     "@types/less": "^3.0.3",
     "@types/markdown-it": "^12.2.3",
     "@types/markdown-it-container": "^2.0.5",
     "@types/markdown-it-emoji": "^2.0.2",
-    "@types/mocha": "^9.0.0",
+    "@types/mocha": "^10.0.0",
     "@types/node": "^16.0.0",
     "@types/postcss-safe-parser": "^5.0.1",
     "@types/prismjs": "^1.26.0",
@@ -112,6 +114,7 @@
     "@typescript-eslint/eslint-plugin": "^5.4.0",
     "@typescript-eslint/parser": "^5.4.1-0",
     "@typescript-eslint/parser-v4": "npm:@typescript-eslint/parser@4",
+    "@typescript/vfs": "^1.4.0",
     "assert": "^2.0.0",
     "commitlint": "^17.0.3",
     "env-cmd": "^10.1.0",
@@ -171,7 +174,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 98.64,
+    "atLeast": 98.71,
     "cache": true,
     "detail": true,
     "ignoreAsAssertion": true,