eslint-plugin-svelte 2.8.0 → 2.9.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.
 
@@ -322,10 +322,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/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/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">;

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"));
@@ -44,6 +45,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,

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.9.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",
@@ -112,6 +112,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",