eslint-plugin-svelte 2.11.0 → 2.12.0

package/README.md

@@ -188,12 +188,6 @@ See also <https://github.com/ota-meshi/svelte-eslint-parser#readme>.
 
 You can change the behavior of this plugin with some settings.
 
-- `ignoreWarnings` (optional) ... Specifies an array of rules that ignore reports in the template.  
-  For example, set rules on the template that cannot avoid false positives.
-- `compileOptions` (optional) ... Specifies options for Svelte compile. Effects rules that use Svelte compile. The target rules are [svelte/valid-compile](https://ota-meshi.github.io/eslint-plugin-svelte/rules/valid-compile/) and [svelte/no-unused-svelte-ignore](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/). **Note that it has no effect on ESLint's custom parser**.
-  - `postcss` (optional) ... Specifies options related to PostCSS. You can disable the PostCSS process by specifying `false`.
-    - `configFilePath` (optional) ... Specifies the path of the directory containing the PostCSS configuration.
-
 e.g.
 
 ```js
@@ -210,6 +204,47 @@ module.exports = {
           configFilePath: "./path/to/my/postcss.config.js",
         },
       },
+      kit: {
+        files: {
+          routes: "src/routes",
+        },
+      },
+    },
+  },
+  // ...
+}
+```
+
+#### settings.svelte.ignoreWarnings
+
+Specifies an array of rules that ignore reports in the template.  
+For example, set rules on the template that cannot avoid false positives.
+
+#### settings.svelte.compileOptions
+
+Specifies options for Svelte compile. Effects rules that use Svelte compile. The target rules are [svelte/valid-compile](https://ota-meshi.github.io/eslint-plugin-svelte/rules/valid-compile/) and [svelte/no-unused-svelte-ignore](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/). **Note that it has no effect on ESLint's custom parser**.
+
+- `postcss` ... Specifies options related to PostCSS. You can disable the PostCSS process by specifying `false`.
+  - `configFilePath` ... Specifies the path of the directory containing the PostCSS configuration.
+
+#### settings.svelte.kit
+
+If you use SvelteKit with not default configuration, you need to set below configurations.
+The schema is subset of SvelteKit's configuration.
+Therefore please check [SvelteKit docs](https://kit.svelte.dev/docs/configuration) for more details.
+
+e.g.
+
+```js
+module.exports = {
+  // ...
+  settings: {
+    svelte: {
+      kit: {
+        files: {
+          routes: "src/routes",
+        },
+      },
     },
   },
   // ...
@@ -266,12 +301,16 @@ These rules relate to possible syntax or logic errors in Svelte code:
 | [svelte/no-dupe-else-if-blocks](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-dupe-else-if-blocks/) | disallow duplicate conditions in `{#if}` / `{:else if}` chains | :star: |
 | [svelte/no-dupe-style-properties](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-dupe-style-properties/) | disallow duplicate style properties | :star: |
 | [svelte/no-dynamic-slot-name](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-dynamic-slot-name/) | disallow dynamic slot name | :star::wrench: |
+| [svelte/no-export-load-in-svelte-module-in-kit-pages](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-export-load-in-svelte-module-in-kit-pages/) | disallow exporting load functions in `*.svelte` module in Svelte Kit page components. |  |
 | [svelte/no-not-function-handler](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-not-function-handler/) | disallow use of not function in event handler | :star: |
 | [svelte/no-object-in-text-mustaches](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-object-in-text-mustaches/) | disallow objects in text mustache interpolation | :star: |
 | [svelte/no-shorthand-style-property-overrides](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-shorthand-style-property-overrides/) | disallow shorthand style properties that override related longhand properties | :star: |
 | [svelte/no-store-async](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-store-async/) | disallow using async/await inside svelte stores because it causes issues with the auto-unsubscribing features |  |
 | [svelte/no-unknown-style-directive-property](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-unknown-style-directive-property/) | disallow unknown `style:property` | :star: |
+| [svelte/require-store-callbacks-use-set-param](https://ota-meshi.github.io/eslint-plugin-svelte/rules/require-store-callbacks-use-set-param/) | store callbacks must use `set` param |  |
+| [svelte/require-store-reactive-access](https://ota-meshi.github.io/eslint-plugin-svelte/rules/require-store-reactive-access/) | disallow to use of the store itself as an operand. Need to use $ prefix or get function. | :wrench: |
 | [svelte/valid-compile](https://ota-meshi.github.io/eslint-plugin-svelte/rules/valid-compile/) | disallow warnings when compiling. | :star: |
+| [svelte/valid-prop-names-in-kit-pages](https://ota-meshi.github.io/eslint-plugin-svelte/rules/valid-prop-names-in-kit-pages/) | disallow props other than data or errors in Svelte Kit page components. |  |
 
 ## Security Vulnerability
 

package/lib/rules/indent-helpers/ast.d.ts

@@ -1,6 +1,6 @@
 import type { AST } from "svelte-eslint-parser";
-import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 declare type AnyToken = AST.Token | AST.Comment;
-export declare function isWhitespace(token: AnyToken | ESTree.Comment | null | undefined): boolean;
-export declare function isNotWhitespace(token: AnyToken | ESTree.Comment | null | undefined): boolean;
+export declare function isWhitespace(token: AnyToken | TSESTree.Comment | null | undefined): boolean;
+export declare function isNotWhitespace(token: AnyToken | TSESTree.Comment | null | undefined): boolean;
 export {};

package/lib/rules/indent-helpers/es.js

@@ -3,11 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.defineVisitor = void 0;
 const commons_1 = require("./commons");
 const eslint_utils_1 = require("eslint-utils");
+const ast_utils_1 = require("../../utils/ast-utils");
 function defineVisitor(context) {
     const { sourceCode, offsets, options } = context;
     function getRootLeft(node) {
         let target = node;
-        let parent = getParent(target);
+        let parent = (0, ast_utils_1.getParent)(target);
         while (parent &&
             (parent.type === "AssignmentExpression" ||
                 parent.type === "AssignmentPattern" ||
@@ -18,7 +19,7 @@ function defineVisitor(context) {
                 break;
             }
             target = parent;
-            parent = getParent(target);
+            parent = (0, ast_utils_1.getParent)(target);
         }
         return target.left;
     }
@@ -161,12 +162,12 @@ function defineVisitor(context) {
             });
             const alternateToken = sourceCode.getTokenAfter(colonToken);
             let baseNode = node;
-            let parent = getParent(baseNode);
+            let parent = (0, ast_utils_1.getParent)(baseNode);
             while (parent &&
                 parent.type === "ConditionalExpression" &&
                 parent.alternate === baseNode) {
                 baseNode = parent;
-                parent = getParent(baseNode);
+                parent = (0, ast_utils_1.getParent)(baseNode);
             }
             const baseToken = sourceCode.getFirstToken(baseNode);
             offsets.setOffsetToken([questionToken, colonToken], 1, baseToken);
@@ -335,9 +336,9 @@ function defineVisitor(context) {
                 filter: eslint_utils_1.isOpeningParenToken,
                 includeComments: false,
             });
-            let bodyBaseToken;
+            let bodyBaseToken = null;
             if (firstToken.type === "Punctuator") {
-                bodyBaseToken = sourceCode.getFirstToken(getParent(node));
+                bodyBaseToken = sourceCode.getFirstToken((0, ast_utils_1.getParent)(node));
             }
             else {
                 let tokenOffset = 0;
@@ -735,9 +736,6 @@ function defineVisitor(context) {
     };
 }
 exports.defineVisitor = defineVisitor;
-function getParent(node) {
-    return node.parent || null;
-}
 function isOptionalToken(token) {
     return token.type === "Punctuator" && token.value === "?.";
 }

package/lib/rules/no-export-load-in-svelte-module-in-kit-pages.d.ts

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

package/lib/rules/no-export-load-in-svelte-module-in-kit-pages.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const svelte_kit_1 = require("../utils/svelte-kit");
+exports.default = (0, utils_1.createRule)("no-export-load-in-svelte-module-in-kit-pages", {
+    meta: {
+        docs: {
+            description: "disallow exporting load functions in `*.svelte` module in Svelte Kit page components.",
+            category: "Possible Errors",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected: "disallow exporting load functions in `*.svelte` module in Svelte Kit page components.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        if (!(0, svelte_kit_1.isKitPageComponent)(context)) {
+            return {};
+        }
+        let isModule = false;
+        return {
+            [`Program > SvelteScriptElement > SvelteStartTag > SvelteAttribute[key.name="context"] > SvelteLiteral[value="module"]`]: () => {
+                isModule = true;
+            },
+            "Program > SvelteScriptElement:exit": () => {
+                isModule = false;
+            },
+            [`:matches(ExportNamedDeclaration > FunctionDeclaration, ExportNamedDeclaration > VariableDeclaration > VariableDeclarator) > Identifier.id[name="load"]`]: (node) => {
+                if (!isModule)
+                    return {};
+                return context.report({
+                    node,
+                    loc: node.loc,
+                    messageId: "unexpected",
+                });
+            },
+        };
+    },
+});

package/lib/rules/reference-helpers/svelte-store.d.ts

@@ -1,8 +1,12 @@
-import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 import type { RuleContext } from "../../types";
 declare type StoreName = "writable" | "readable" | "derived";
 export declare function extractStoreReferences(context: RuleContext, storeNames?: StoreName[]): Generator<{
-    node: ESTree.CallExpression;
+    node: TSESTree.CallExpression;
     name: string;
 }, void>;
+export declare type StoreChecker = (node: TSESTree.Expression, options?: {
+    consistent?: boolean;
+}) => boolean;
+export declare function createStoreChecker(context: RuleContext): StoreChecker;
 export {};

package/lib/rules/reference-helpers/svelte-store.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractStoreReferences = void 0;
+exports.createStoreChecker = exports.extractStoreReferences = void 0;
 const eslint_utils_1 = require("eslint-utils");
+const ts_utils_1 = require("../../utils/ts-utils");
+const ast_utils_1 = require("../../utils/ast-utils");
 function* extractStoreReferences(context, storeNames = ["writable", "readable", "derived"]) {
     const referenceTracker = new eslint_utils_1.ReferenceTracker(context.getScope());
     for (const { node, path } of referenceTracker.iterateEsmReferences({
@@ -25,3 +27,99 @@ function* extractStoreReferences(context, storeNames = ["writable", "readable",
     }
 }
 exports.extractStoreReferences = extractStoreReferences;
+function createStoreChecker(context) {
+    const tools = (0, ts_utils_1.getTypeScriptTools)(context);
+    const checker = tools
+        ? createStoreCheckerForTS(tools)
+        : createStoreCheckerForES(context);
+    return (node, options) => checker(node, {
+        consistent: options?.consistent ?? false,
+    });
+}
+exports.createStoreChecker = createStoreChecker;
+function createStoreCheckerForES(context) {
+    const storeVariables = new Map();
+    for (const { node } of extractStoreReferences(context)) {
+        const parent = (0, ast_utils_1.getParent)(node);
+        if (!parent ||
+            parent.type !== "VariableDeclarator" ||
+            parent.id.type !== "Identifier") {
+            continue;
+        }
+        const decl = (0, ast_utils_1.getParent)(parent);
+        if (!decl || decl.type !== "VariableDeclaration") {
+            continue;
+        }
+        const variable = (0, ast_utils_1.findVariable)(context, parent.id);
+        if (variable) {
+            storeVariables.set(variable, { const: decl.kind === "const" });
+        }
+    }
+    return (node, options) => {
+        if (node.type !== "Identifier" || node.name.startsWith("$")) {
+            return false;
+        }
+        const variable = (0, ast_utils_1.findVariable)(context, node);
+        if (!variable) {
+            return false;
+        }
+        const info = storeVariables.get(variable);
+        if (!info) {
+            return false;
+        }
+        return options.consistent ? info.const : true;
+    };
+}
+function createStoreCheckerForTS(tools) {
+    const { service } = tools;
+    const checker = service.program.getTypeChecker();
+    const tsNodeMap = service.esTreeNodeToTSNodeMap;
+    return (node, options) => {
+        const tsNode = tsNodeMap.get(node);
+        if (!tsNode) {
+            return false;
+        }
+        const type = checker.getTypeAtLocation(tsNode);
+        return isStoreType(checker.getApparentType(type));
+        function isStoreType(type) {
+            return eachTypeCheck(type, options, (type) => {
+                const subscribe = type.getProperty("subscribe");
+                if (!subscribe) {
+                    return false;
+                }
+                const subscribeType = checker.getTypeOfSymbolAtLocation(subscribe, tsNode);
+                return isStoreSubscribeSignatureType(subscribeType);
+            });
+        }
+        function isStoreSubscribeSignatureType(type) {
+            return eachTypeCheck(type, options, (type) => {
+                for (const signature of type.getCallSignatures()) {
+                    if (signature.parameters.length >= 2 &&
+                        maybeFunctionSymbol(signature.parameters[0]) &&
+                        maybeFunctionSymbol(signature.parameters[1])) {
+                        return true;
+                    }
+                }
+                return false;
+            });
+        }
+        function maybeFunctionSymbol(param) {
+            const type = checker.getApparentType(checker.getTypeOfSymbolAtLocation(param, tsNode));
+            return maybeFunctionType(type);
+        }
+        function maybeFunctionType(type) {
+            return eachTypeCheck(type, { consistent: false }, (type) => {
+                return type.getCallSignatures().length > 0;
+            });
+        }
+    };
+}
+function eachTypeCheck(type, options, check) {
+    if (type.isUnion()) {
+        if (options.consistent) {
+            return type.types.every((t) => eachTypeCheck(t, options, check));
+        }
+        return type.types.some((t) => eachTypeCheck(t, options, check));
+    }
+    return check(type);
+}

package/lib/rules/require-store-callbacks-use-set-param.d.ts

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

package/lib/rules/require-store-callbacks-use-set-param.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const svelte_store_1 = require("./reference-helpers/svelte-store");
+exports.default = (0, utils_1.createRule)("require-store-callbacks-use-set-param", {
+    meta: {
+        docs: {
+            description: "store callbacks must use `set` param",
+            category: "Possible Errors",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected: "Store callbacks must use `set` param.",
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        return {
+            Program() {
+                for (const { node } of (0, svelte_store_1.extractStoreReferences)(context, [
+                    "readable",
+                    "writable",
+                ])) {
+                    const [_, fn] = node.arguments;
+                    if (!fn ||
+                        (fn.type !== "ArrowFunctionExpression" &&
+                            fn.type !== "FunctionExpression")) {
+                        continue;
+                    }
+                    const param = fn.params[0];
+                    if (!param || (param.type === "Identifier" && param.name !== "set")) {
+                        context.report({
+                            node: fn,
+                            loc: fn.loc,
+                            messageId: "unexpected",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/lib/rules/require-store-reactive-access.d.ts

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

package/lib/rules/require-store-reactive-access.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const svelte_store_1 = require("./reference-helpers/svelte-store");
+exports.default = (0, utils_1.createRule)("require-store-reactive-access", {
+    meta: {
+        docs: {
+            description: "disallow to use of the store itself as an operand. Need to use $ prefix or get function.",
+            category: "Possible Errors",
+            recommended: false,
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            usingRawStoreInText: "Use the $ prefix or the get function to access reactive values instead of accessing the raw store.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        if (!context.parserServices.isSvelte) {
+            return {};
+        }
+        const isStore = (0, svelte_store_1.createStoreChecker)(context);
+        function verifyExpression(node, options) {
+            if (!node)
+                return;
+            if (isStore(node, { consistent: options?.consistent })) {
+                context.report({
+                    node,
+                    messageId: "usingRawStoreInText",
+                    fix: node.type === "Identifier" && !options?.disableFix
+                        ? (fixer) => fixer.insertTextBefore(node, "$")
+                        : null,
+                });
+            }
+        }
+        return {
+            SvelteMustacheTag(node) {
+                if (canAcceptStoreMustache(node)) {
+                    return;
+                }
+                verifyExpression(node.expression);
+            },
+            SvelteShorthandAttribute(node) {
+                if (canAcceptStoreAttributeElement(node.parent.parent)) {
+                    return;
+                }
+                verifyExpression(node.value, { disableFix: true });
+            },
+            SvelteSpreadAttribute(node) {
+                verifyExpression(node.argument);
+            },
+            SvelteDirective(node) {
+                if (node.kind === "Action" ||
+                    node.kind === "Animation" ||
+                    node.kind === "Transition") {
+                    if (node.key.name.type !== "Identifier") {
+                        return;
+                    }
+                    verifyExpression(node.key.name);
+                }
+                else if (node.kind === "Binding") {
+                    if (node.key.name.name !== "this" &&
+                        canAcceptStoreAttributeElement(node.parent.parent)) {
+                        return;
+                    }
+                    verifyExpression(node.expression, {
+                        disableFix: node.shorthand,
+                    });
+                }
+                else if (node.kind === "Class") {
+                    verifyExpression(node.expression, {
+                        disableFix: node.shorthand,
+                        consistent: true,
+                    });
+                }
+                else if (node.kind === "EventHandler") {
+                    verifyExpression(node.expression);
+                }
+            },
+            SvelteStyleDirective(node) {
+                if (node.shorthand && node.key.name.type === "Identifier") {
+                    verifyExpression(node.key.name, {
+                        disableFix: true,
+                    });
+                }
+            },
+            SvelteSpecialDirective(node) {
+                if (node.kind === "this") {
+                    verifyExpression(node.expression);
+                }
+            },
+            "SvelteIfBlock, SvelteAwaitBlock"(node) {
+                verifyExpression(node.expression, {
+                    consistent: true,
+                });
+            },
+            SvelteEachBlock(node) {
+                verifyExpression(node.expression);
+            },
+            ["IfStatement, WhileStatement, DoWhileStatement, " +
+                "ConditionalExpression, ForStatement"](node) {
+                verifyExpression(node.test, {
+                    consistent: true,
+                });
+            },
+            "ForInStatement, ForOfStatement"(node) {
+                verifyExpression(node.right);
+            },
+            SwitchStatement(node) {
+                verifyExpression(node.discriminant);
+            },
+            "CallExpression, NewExpression"(node) {
+                if (node.callee.type === "Super") {
+                    return;
+                }
+                verifyExpression(node.callee);
+            },
+            UnaryExpression(node) {
+                verifyExpression(node.argument, {
+                    consistent: node.operator === "!" || node.operator === "typeof",
+                });
+            },
+            "UpdateExpression, SpreadElement"(node) {
+                verifyExpression(node.argument);
+            },
+            AssignmentExpression(node) {
+                if (node.operator !== "=") {
+                    if (node.left.type !== "ObjectPattern" &&
+                        node.left.type !== "ArrayPattern") {
+                        verifyExpression(node.left);
+                    }
+                    verifyExpression(node.right);
+                }
+            },
+            BinaryExpression(node) {
+                if (node.left.type !== "PrivateIdentifier") {
+                    verifyExpression(node.left, {
+                        consistent: node.operator === "==" ||
+                            node.operator === "!=" ||
+                            node.operator === "===" ||
+                            node.operator === "!==",
+                    });
+                }
+                verifyExpression(node.right, {
+                    consistent: node.operator === "==" ||
+                        node.operator === "!=" ||
+                        node.operator === "===" ||
+                        node.operator === "!==",
+                });
+            },
+            LogicalExpression(node) {
+                verifyExpression(node.left, {
+                    consistent: true,
+                });
+            },
+            TemplateLiteral(node) {
+                for (const expr of node.expressions) {
+                    verifyExpression(expr);
+                }
+            },
+            TaggedTemplateExpression(node) {
+                verifyExpression(node.tag);
+            },
+            "Property, PropertyDefinition, MethodDefinition"(node) {
+                if (node.key.type === "PrivateIdentifier" || !node.computed) {
+                    return;
+                }
+                verifyExpression(node.key);
+            },
+            ImportExpression(node) {
+                verifyExpression(node.source);
+            },
+            AwaitExpression(node) {
+                verifyExpression(node.argument, {
+                    consistent: true,
+                });
+            },
+        };
+        function canAcceptStoreMustache(node) {
+            if (node.parent.type !== "SvelteAttribute") {
+                return false;
+            }
+            const attr = node.parent;
+            if (attr.value.length > 1) {
+                return false;
+            }
+            if (attr.key.name.startsWith("--")) {
+                return false;
+            }
+            const element = attr.parent.parent;
+            return canAcceptStoreAttributeElement(element);
+        }
+        function canAcceptStoreAttributeElement(node) {
+            if (node.type !== "SvelteElement") {
+                return false;
+            }
+            if (node.kind === "html" ||
+                (node.kind === "special" && node.name.name === "svelte:element")) {
+                return false;
+            }
+            return true;
+        }
+    },
+});

package/lib/rules/valid-prop-names-in-kit-pages.d.ts

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

package/lib/rules/valid-prop-names-in-kit-pages.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const svelte_kit_1 = require("../utils/svelte-kit");
+const EXPECTED_PROP_NAMES = ["data", "errors"];
+exports.default = (0, utils_1.createRule)("valid-prop-names-in-kit-pages", {
+    meta: {
+        docs: {
+            description: "disallow props other than data or errors in Svelte Kit page components.",
+            category: "Possible Errors",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            unexpected: "disallow props other than data or errors in Svelte Kit page components.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        if (!(0, svelte_kit_1.isKitPageComponent)(context))
+            return {};
+        let isScript = false;
+        return {
+            "Program > SvelteScriptElement > SvelteStartTag": (node) => {
+                isScript = !node.attributes.some((a) => a.type === "SvelteAttribute" &&
+                    a.key.name === "context" &&
+                    a.value.some((v) => v.type === "SvelteLiteral" && v.value === "module"));
+            },
+            "Program > SvelteScriptElement:exit": () => {
+                isScript = false;
+            },
+            "ExportNamedDeclaration > VariableDeclaration > VariableDeclarator": (node) => {
+                if (!isScript)
+                    return;
+                if (node.id.type === "Identifier") {
+                    if (!EXPECTED_PROP_NAMES.includes(node.id.name)) {
+                        context.report({
+                            node,
+                            loc: node.loc,
+                            messageId: "unexpected",
+                        });
+                    }
+                    return;
+                }
+                if (node.id.type !== "ObjectPattern")
+                    return;
+                for (const p of node.id.properties) {
+                    if (p.type === "Property" &&
+                        p.value.type === "Identifier" &&
+                        !EXPECTED_PROP_NAMES.includes(p.value.name)) {
+                        context.report({
+                            node: p.value,
+                            loc: p.value.loc,
+                            messageId: "unexpected",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/lib/types-for-node.d.ts

@@ -1,10 +1,9 @@
 import type { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/types";
 import type { AST } from "svelte-eslint-parser";
-import type * as ESTree from "estree";
-export declare type ASTNode = AST.SvelteNode | ESTree.Node | Exclude<TSESTree.Node, {
-    type: ESTree.Node["type"];
+export declare type ASTNode = AST.SvelteNode | Exclude<Omit<TSESTree.Node, "parent">, {
+    type: AST.SvelteNode["type"];
 }>;
-export declare type ASTNodeWithParent = (Exclude<ASTNode, ESTree.Program> & {
+export declare type ASTNodeWithParent = (Exclude<ASTNode, AST.SvelteProgram> & {
     parent: ASTNodeWithParent;
 }) | AST.SvelteProgram;
 export declare type ASTNodeListener = {
@@ -206,75 +205,75 @@ export declare type ASTNodeListener = {
     SvelteReactiveStatement?: (node: AST.SvelteReactiveStatement & ASTNodeWithParent) => void;
 };
 export declare type ESNodeListener = {
-    ArrayExpression?: (node: ESTree.ArrayExpression & ASTNodeWithParent) => void;
-    ArrayPattern?: (node: ESTree.ArrayPattern & ASTNodeWithParent) => void;
-    ArrowFunctionExpression?: (node: ESTree.ArrowFunctionExpression & ASTNodeWithParent) => void;
-    AssignmentExpression?: (node: ESTree.AssignmentExpression & ASTNodeWithParent) => void;
-    AssignmentPattern?: (node: ESTree.AssignmentPattern & ASTNodeWithParent) => void;
-    AwaitExpression?: (node: ESTree.AwaitExpression & ASTNodeWithParent) => void;
-    BinaryExpression?: (node: ESTree.BinaryExpression & ASTNodeWithParent) => void;
-    BlockStatement?: (node: ESTree.BlockStatement & ASTNodeWithParent) => void;
-    BreakStatement?: (node: ESTree.BreakStatement & ASTNodeWithParent) => void;
-    CallExpression?: (node: ESTree.CallExpression & ASTNodeWithParent) => void;
-    CatchClause?: (node: ESTree.CatchClause & ASTNodeWithParent) => void;
-    ChainExpression?: (node: ESTree.ChainExpression & ASTNodeWithParent) => void;
-    ClassBody?: (node: ESTree.ClassBody & ASTNodeWithParent) => void;
-    ClassDeclaration?: (node: ESTree.ClassDeclaration & ASTNodeWithParent) => void;
-    ClassExpression?: (node: ESTree.ClassExpression & ASTNodeWithParent) => void;
-    ConditionalExpression?: (node: ESTree.ConditionalExpression & ASTNodeWithParent) => void;
-    ContinueStatement?: (node: ESTree.ContinueStatement & ASTNodeWithParent) => void;
-    DebuggerStatement?: (node: ESTree.DebuggerStatement & ASTNodeWithParent) => void;
-    DoWhileStatement?: (node: ESTree.DoWhileStatement & ASTNodeWithParent) => void;
-    EmptyStatement?: (node: ESTree.EmptyStatement & ASTNodeWithParent) => void;
-    ExportAllDeclaration?: (node: ESTree.ExportAllDeclaration & ASTNodeWithParent) => void;
-    ExportDefaultDeclaration?: (node: ESTree.ExportDefaultDeclaration & ASTNodeWithParent) => void;
-    ExportNamedDeclaration?: (node: ESTree.ExportNamedDeclaration & ASTNodeWithParent) => void;
-    ExportSpecifier?: (node: ESTree.ExportSpecifier & ASTNodeWithParent) => void;
-    ExpressionStatement?: (node: ESTree.ExpressionStatement & ASTNodeWithParent) => void;
-    ForInStatement?: (node: ESTree.ForInStatement & ASTNodeWithParent) => void;
-    ForOfStatement?: (node: ESTree.ForOfStatement & ASTNodeWithParent) => void;
-    ForStatement?: (node: ESTree.ForStatement & ASTNodeWithParent) => void;
-    FunctionDeclaration?: (node: ESTree.FunctionDeclaration & ASTNodeWithParent) => void;
-    FunctionExpression?: (node: ESTree.FunctionExpression & ASTNodeWithParent) => void;
-    Identifier?: (node: ESTree.Identifier & ASTNodeWithParent) => void;
-    IfStatement?: (node: ESTree.IfStatement & ASTNodeWithParent) => void;
-    ImportDeclaration?: (node: ESTree.ImportDeclaration & ASTNodeWithParent) => void;
-    ImportDefaultSpecifier?: (node: ESTree.ImportDefaultSpecifier & ASTNodeWithParent) => void;
-    ImportExpression?: (node: ESTree.ImportExpression & ASTNodeWithParent) => void;
-    ImportNamespaceSpecifier?: (node: ESTree.ImportNamespaceSpecifier & ASTNodeWithParent) => void;
-    ImportSpecifier?: (node: ESTree.ImportSpecifier & ASTNodeWithParent) => void;
-    LabeledStatement?: (node: ESTree.LabeledStatement & ASTNodeWithParent) => void;
-    Literal?: (node: ESTree.Literal & ASTNodeWithParent) => void;
-    LogicalExpression?: (node: ESTree.LogicalExpression & ASTNodeWithParent) => void;
-    MemberExpression?: (node: ESTree.MemberExpression & ASTNodeWithParent) => void;
-    MetaProperty?: (node: ESTree.MetaProperty & ASTNodeWithParent) => void;
-    MethodDefinition?: (node: ESTree.MethodDefinition & ASTNodeWithParent) => void;
-    NewExpression?: (node: ESTree.NewExpression & ASTNodeWithParent) => void;
-    ObjectExpression?: (node: ESTree.ObjectExpression & ASTNodeWithParent) => void;
-    ObjectPattern?: (node: ESTree.ObjectPattern & ASTNodeWithParent) => void;
-    PrivateIdentifier?: (node: ESTree.PrivateIdentifier & ASTNodeWithParent) => void;
-    Property?: (node: ESTree.Property & ASTNodeWithParent) => void;
-    PropertyDefinition?: (node: ESTree.PropertyDefinition & ASTNodeWithParent) => void;
-    RestElement?: (node: ESTree.RestElement & ASTNodeWithParent) => void;
-    ReturnStatement?: (node: ESTree.ReturnStatement & ASTNodeWithParent) => void;
-    SequenceExpression?: (node: ESTree.SequenceExpression & ASTNodeWithParent) => void;
-    SpreadElement?: (node: ESTree.SpreadElement & ASTNodeWithParent) => void;
-    Super?: (node: ESTree.Super & ASTNodeWithParent) => void;
-    SwitchCase?: (node: ESTree.SwitchCase & ASTNodeWithParent) => void;
-    SwitchStatement?: (node: ESTree.SwitchStatement & ASTNodeWithParent) => void;
-    TaggedTemplateExpression?: (node: ESTree.TaggedTemplateExpression & ASTNodeWithParent) => void;
-    TemplateElement?: (node: ESTree.TemplateElement & ASTNodeWithParent) => void;
-    TemplateLiteral?: (node: ESTree.TemplateLiteral & ASTNodeWithParent) => void;
-    ThisExpression?: (node: ESTree.ThisExpression & ASTNodeWithParent) => void;
-    ThrowStatement?: (node: ESTree.ThrowStatement & ASTNodeWithParent) => void;
-    TryStatement?: (node: ESTree.TryStatement & ASTNodeWithParent) => void;
-    UnaryExpression?: (node: ESTree.UnaryExpression & ASTNodeWithParent) => void;
-    UpdateExpression?: (node: ESTree.UpdateExpression & ASTNodeWithParent) => void;
-    VariableDeclaration?: (node: ESTree.VariableDeclaration & ASTNodeWithParent) => void;
-    VariableDeclarator?: (node: ESTree.VariableDeclarator & ASTNodeWithParent) => void;
-    WhileStatement?: (node: ESTree.WhileStatement & ASTNodeWithParent) => void;
-    WithStatement?: (node: ESTree.WithStatement & ASTNodeWithParent) => void;
-    YieldExpression?: (node: ESTree.YieldExpression & ASTNodeWithParent) => void;
+    ArrayExpression?: (node: TSESTree.ArrayExpression & ASTNodeWithParent) => void;
+    ArrayPattern?: (node: TSESTree.ArrayPattern & ASTNodeWithParent) => void;
+    ArrowFunctionExpression?: (node: TSESTree.ArrowFunctionExpression & ASTNodeWithParent) => void;
+    AssignmentExpression?: (node: TSESTree.AssignmentExpression & ASTNodeWithParent) => void;
+    AssignmentPattern?: (node: TSESTree.AssignmentPattern & ASTNodeWithParent) => void;
+    AwaitExpression?: (node: TSESTree.AwaitExpression & ASTNodeWithParent) => void;
+    BinaryExpression?: (node: TSESTree.BinaryExpression & ASTNodeWithParent) => void;
+    BlockStatement?: (node: TSESTree.BlockStatement & ASTNodeWithParent) => void;
+    BreakStatement?: (node: TSESTree.BreakStatement & ASTNodeWithParent) => void;
+    CallExpression?: (node: TSESTree.CallExpression & ASTNodeWithParent) => void;
+    CatchClause?: (node: TSESTree.CatchClause & ASTNodeWithParent) => void;
+    ChainExpression?: (node: TSESTree.ChainExpression & ASTNodeWithParent) => void;
+    ClassBody?: (node: TSESTree.ClassBody & ASTNodeWithParent) => void;
+    ClassDeclaration?: (node: TSESTree.ClassDeclaration & ASTNodeWithParent) => void;
+    ClassExpression?: (node: TSESTree.ClassExpression & ASTNodeWithParent) => void;
+    ConditionalExpression?: (node: TSESTree.ConditionalExpression & ASTNodeWithParent) => void;
+    ContinueStatement?: (node: TSESTree.ContinueStatement & ASTNodeWithParent) => void;
+    DebuggerStatement?: (node: TSESTree.DebuggerStatement & ASTNodeWithParent) => void;
+    DoWhileStatement?: (node: TSESTree.DoWhileStatement & ASTNodeWithParent) => void;
+    EmptyStatement?: (node: TSESTree.EmptyStatement & ASTNodeWithParent) => void;
+    ExportAllDeclaration?: (node: TSESTree.ExportAllDeclaration & ASTNodeWithParent) => void;
+    ExportDefaultDeclaration?: (node: TSESTree.ExportDefaultDeclaration & ASTNodeWithParent) => void;
+    ExportNamedDeclaration?: (node: TSESTree.ExportNamedDeclaration & ASTNodeWithParent) => void;
+    ExportSpecifier?: (node: TSESTree.ExportSpecifier & ASTNodeWithParent) => void;
+    ExpressionStatement?: (node: TSESTree.ExpressionStatement & ASTNodeWithParent) => void;
+    ForInStatement?: (node: TSESTree.ForInStatement & ASTNodeWithParent) => void;
+    ForOfStatement?: (node: TSESTree.ForOfStatement & ASTNodeWithParent) => void;
+    ForStatement?: (node: TSESTree.ForStatement & ASTNodeWithParent) => void;
+    FunctionDeclaration?: (node: TSESTree.FunctionDeclaration & ASTNodeWithParent) => void;
+    FunctionExpression?: (node: TSESTree.FunctionExpression & ASTNodeWithParent) => void;
+    Identifier?: (node: TSESTree.Identifier & ASTNodeWithParent) => void;
+    IfStatement?: (node: TSESTree.IfStatement & ASTNodeWithParent) => void;
+    ImportDeclaration?: (node: TSESTree.ImportDeclaration & ASTNodeWithParent) => void;
+    ImportDefaultSpecifier?: (node: TSESTree.ImportDefaultSpecifier & ASTNodeWithParent) => void;
+    ImportExpression?: (node: TSESTree.ImportExpression & ASTNodeWithParent) => void;
+    ImportNamespaceSpecifier?: (node: TSESTree.ImportNamespaceSpecifier & ASTNodeWithParent) => void;
+    ImportSpecifier?: (node: TSESTree.ImportSpecifier & ASTNodeWithParent) => void;
+    LabeledStatement?: (node: TSESTree.LabeledStatement & ASTNodeWithParent) => void;
+    Literal?: (node: TSESTree.Literal & ASTNodeWithParent) => void;
+    LogicalExpression?: (node: TSESTree.LogicalExpression & ASTNodeWithParent) => void;
+    MemberExpression?: (node: TSESTree.MemberExpression & ASTNodeWithParent) => void;
+    MetaProperty?: (node: TSESTree.MetaProperty & ASTNodeWithParent) => void;
+    MethodDefinition?: (node: TSESTree.MethodDefinition & ASTNodeWithParent) => void;
+    NewExpression?: (node: TSESTree.NewExpression & ASTNodeWithParent) => void;
+    ObjectExpression?: (node: TSESTree.ObjectExpression & ASTNodeWithParent) => void;
+    ObjectPattern?: (node: TSESTree.ObjectPattern & ASTNodeWithParent) => void;
+    PrivateIdentifier?: (node: TSESTree.PrivateIdentifier & ASTNodeWithParent) => void;
+    Property?: (node: TSESTree.Property & ASTNodeWithParent) => void;
+    PropertyDefinition?: (node: TSESTree.PropertyDefinition & ASTNodeWithParent) => void;
+    RestElement?: (node: TSESTree.RestElement & ASTNodeWithParent) => void;
+    ReturnStatement?: (node: TSESTree.ReturnStatement & ASTNodeWithParent) => void;
+    SequenceExpression?: (node: TSESTree.SequenceExpression & ASTNodeWithParent) => void;
+    SpreadElement?: (node: TSESTree.SpreadElement & ASTNodeWithParent) => void;
+    Super?: (node: TSESTree.Super & ASTNodeWithParent) => void;
+    SwitchCase?: (node: TSESTree.SwitchCase & ASTNodeWithParent) => void;
+    SwitchStatement?: (node: TSESTree.SwitchStatement & ASTNodeWithParent) => void;
+    TaggedTemplateExpression?: (node: TSESTree.TaggedTemplateExpression & ASTNodeWithParent) => void;
+    TemplateElement?: (node: TSESTree.TemplateElement & ASTNodeWithParent) => void;
+    TemplateLiteral?: (node: TSESTree.TemplateLiteral & ASTNodeWithParent) => void;
+    ThisExpression?: (node: TSESTree.ThisExpression & ASTNodeWithParent) => void;
+    ThrowStatement?: (node: TSESTree.ThrowStatement & ASTNodeWithParent) => void;
+    TryStatement?: (node: TSESTree.TryStatement & ASTNodeWithParent) => void;
+    UnaryExpression?: (node: TSESTree.UnaryExpression & ASTNodeWithParent) => void;
+    UpdateExpression?: (node: TSESTree.UpdateExpression & ASTNodeWithParent) => void;
+    VariableDeclaration?: (node: TSESTree.VariableDeclaration & ASTNodeWithParent) => void;
+    VariableDeclarator?: (node: TSESTree.VariableDeclarator & ASTNodeWithParent) => void;
+    WhileStatement?: (node: TSESTree.WhileStatement & ASTNodeWithParent) => void;
+    WithStatement?: (node: TSESTree.WithStatement & ASTNodeWithParent) => void;
+    YieldExpression?: (node: TSESTree.YieldExpression & ASTNodeWithParent) => void;
     Program?: (node: AST.SvelteProgram & ASTNodeWithParent) => void;
     SvelteReactiveStatement?: (node: AST.SvelteReactiveStatement & ASTNodeWithParent) => void;
 };

package/lib/types.d.ts

@@ -1,7 +1,7 @@
 import type { JSONSchema4 } from "json-schema";
 import type { Linter, Rule, Scope, SourceCode as ESLintSourceCode } from "eslint";
 import type { AST } from "svelte-eslint-parser";
-import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 import type { ASTNode, ASTNodeWithParent, ASTNodeListener } from "./types-for-node";
 export type { ASTNode, ASTNodeWithParent, ASTNodeListener };
 export interface RuleListener extends ASTNodeListener {
@@ -80,7 +80,7 @@ export declare type RuleContext = {
     id: string;
     options: any[];
     settings?: {
-        ["svelte"]?: {
+        svelte?: {
             ignoreWarnings?: unknown;
             compileOptions?: {
                 babel?: boolean;
@@ -88,13 +88,18 @@ export declare type RuleContext = {
                     configFilePath?: unknown;
                 };
             };
+            kit?: {
+                files?: {
+                    routes?: string;
+                };
+            };
         };
     };
     parserPath: string;
     parserOptions: Linter.ParserOptions;
     parserServices: ESLintSourceCode.ParserServices;
     getAncestors(): ASTNode[];
-    getDeclaredVariables(node: ESTree.Node): Scope.Variable[];
+    getDeclaredVariables(node: TSESTree.Node): Scope.Variable[];
     getFilename(): string;
     getScope(): Scope.Scope;
     getSourceCode(): SourceCode;

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

@@ -1,11 +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 | TSESTree.Expression): string | null;
-export declare function needParentheses(node: ESTree.Expression, kind: "not" | "logical"): boolean;
+export declare function getStringIfConstant(node: TSESTree.Expression | TSESTree.PrivateIdentifier): string | null;
+export declare function needParentheses(node: TSESTree.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 & {
         name: "svelte:element";
@@ -30,8 +29,9 @@ 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 | TSESTree.Identifier): Scope.Variable | null;
-export declare function getScope(context: RuleContext, currentNode: ESTree.Node): Scope.Scope;
+export declare function findVariable(context: RuleContext, node: TSESTree.Identifier): Scope.Variable | null;
+export declare function getScope(context: RuleContext, currentNode: TSESTree.Node): Scope.Scope;
+export declare function getParent(node: TSESTree.Node): TSESTree.Node | null;
 export declare type QuoteAndRange = {
     quote: "unquoted" | "double" | "single";
     range: [number, number];

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.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;
+exports.isExpressionIdentifier = exports.isVoidHtmlElement = exports.getNodeName = exports.getDirectiveName = exports.getAttributeKeyText = exports.getMustacheTokens = exports.getAttributeValueQuoteAndRange = exports.getParent = 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) {
@@ -194,6 +194,10 @@ function getScope(context, currentNode) {
     return scopeManager.scopes[0];
 }
 exports.getScope = getScope;
+function getParent(node) {
+    return node.parent || null;
+}
+exports.getParent = getParent;
 function getAttributeValueQuoteAndRange(attr, sourceCode) {
     const valueTokens = getAttributeValueRangeTokens(attr, sourceCode);
     if (valueTokens == null) {

package/lib/utils/cache.d.ts

@@ -0,0 +1,4 @@
+export declare function createCache<T>(): {
+    get: (key: string) => T | null;
+    set: (key: string, value: T) => void;
+};

package/lib/utils/cache.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCache = void 0;
+const SKIP_TIME = 5000;
+function createCache() {
+    const map = new Map();
+    function get(key) {
+        const entry = map.get(key);
+        const now = Date.now();
+        if (entry) {
+            if (entry.expire > now) {
+                entry.expire = now + SKIP_TIME;
+                return entry.value;
+            }
+            map.delete(key);
+        }
+        return null;
+    }
+    function set(key, value) {
+        const entry = map.get(key);
+        const expire = Date.now() + SKIP_TIME;
+        if (entry) {
+            entry.value = value;
+            entry.expire = expire;
+        }
+        else {
+            map.set(key, { value, expire });
+        }
+    }
+    return { get, set };
+}
+exports.createCache = createCache;

package/lib/utils/css-utils/style-attribute.d.ts

@@ -1,8 +1,8 @@
 import type { AST } from "svelte-eslint-parser";
 import type { RuleContext } from "../../types";
-import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 export declare function parseStyleAttributeValue(node: AST.SvelteAttribute, context: RuleContext): SvelteStyleRoot<AST.SvelteMustacheTagText> | null;
-export declare type SvelteStyleInterpolation = AST.SvelteMustacheTagText | ESTree.Expression;
+export declare type SvelteStyleInterpolation = AST.SvelteMustacheTagText | TSESTree.Expression;
 export interface SvelteStyleNode<E extends SvelteStyleInterpolation> {
     nodes?: SvelteStyleChildNode<E>[];
     range: AST.Range;
@@ -15,8 +15,8 @@ export interface SvelteStyleRoot<E extends SvelteStyleInterpolation = SvelteStyl
 export interface SvelteStyleInline<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> extends SvelteStyleNode<E> {
     type: "inline";
     node: E;
-    getInlineStyle(node: ESTree.Expression): SvelteStyleRoot<ESTree.Expression> | null;
-    getAllInlineStyles(): Map<ESTree.Expression, SvelteStyleRoot<ESTree.Expression>>;
+    getInlineStyle(node: TSESTree.Expression): SvelteStyleRoot<TSESTree.Expression> | null;
+    getAllInlineStyles(): Map<TSESTree.Expression, SvelteStyleRoot<TSESTree.Expression>>;
 }
 export interface SvelteStyleDeclaration<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> extends SvelteStyleNode<E> {
     type: "decl";

package/lib/utils/eslint-core.d.ts

@@ -1,5 +1,5 @@
 import type { RuleListener, RuleContext, RuleModule } from "../types";
-import type * as ESTree from "estree";
+import type { TSESTree } from "@typescript-eslint/types";
 import type { AST as SvAST } from "svelte-eslint-parser";
 export declare function defineWrapperListener(coreRule: RuleModule, context: RuleContext, proxyOptions: {
     createListenerProxy?: (listener: RuleListener) => RuleListener;
@@ -7,7 +7,7 @@ export declare function defineWrapperListener(coreRule: RuleModule, context: Rul
 export declare function getProxyNode(node: {
     type: string;
 }, properties: any): any;
-export declare function buildProxyListener(base: RuleListener, convertNode: (node: SvAST.SvelteNode | (ESTree.Node & {
-    parent: SvAST.SvelteNode | ESTree.Node | null;
+export declare function buildProxyListener(base: RuleListener, convertNode: (node: SvAST.SvelteNode | (TSESTree.Node & {
+    parent: SvAST.SvelteNode | TSESTree.Node | null;
 })) => any): RuleListener;
 export declare function getCoreRule(ruleName: string): RuleModule;

package/lib/utils/get-package-json.d.ts

@@ -0,0 +1,5 @@
+declare type PackageJson = Record<string, any> & {
+    filePath: string;
+};
+export declare function getPackageJson(startPath?: string): PackageJson | null;
+export {};

package/lib/utils/get-package-json.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageJson = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cache_1 = require("./cache");
+const isRunOnBrowser = !fs_1.default.readFileSync;
+const cache = (0, cache_1.createCache)();
+function readPackageJson(dir) {
+    if (isRunOnBrowser)
+        return null;
+    const filePath = path_1.default.join(dir, "package.json");
+    try {
+        const text = fs_1.default.readFileSync(filePath, "utf8");
+        const data = JSON.parse(text);
+        if (typeof data === "object" && data !== null) {
+            data.filePath = filePath;
+            return data;
+        }
+    }
+    catch (_err) {
+    }
+    return null;
+}
+function getPackageJson(startPath = "a.js") {
+    if (isRunOnBrowser)
+        return null;
+    const startDir = path_1.default.dirname(path_1.default.resolve(startPath));
+    let dir = startDir;
+    let prevDir = "";
+    let data = null;
+    do {
+        data = cache.get(dir);
+        if (data) {
+            if (dir !== startDir) {
+                cache.set(startDir, data);
+            }
+            return data;
+        }
+        data = readPackageJson(dir);
+        if (data) {
+            cache.set(dir, data);
+            cache.set(startDir, data);
+            return data;
+        }
+        prevDir = dir;
+        dir = path_1.default.resolve(dir, "..");
+    } while (dir !== prevDir);
+    cache.set(startDir, null);
+    return null;
+}
+exports.getPackageJson = getPackageJson;

package/lib/utils/rules.js

@@ -20,6 +20,7 @@ const no_at_html_tags_1 = __importDefault(require("../rules/no-at-html-tags"));
 const no_dupe_else_if_blocks_1 = __importDefault(require("../rules/no-dupe-else-if-blocks"));
 const no_dupe_style_properties_1 = __importDefault(require("../rules/no-dupe-style-properties"));
 const no_dynamic_slot_name_1 = __importDefault(require("../rules/no-dynamic-slot-name"));
+const no_export_load_in_svelte_module_in_kit_pages_1 = __importDefault(require("../rules/no-export-load-in-svelte-module-in-kit-pages"));
 const no_extra_reactive_curlies_1 = __importDefault(require("../rules/no-extra-reactive-curlies"));
 const no_inner_declarations_1 = __importDefault(require("../rules/no-inner-declarations"));
 const no_not_function_handler_1 = __importDefault(require("../rules/no-not-function-handler"));
@@ -38,6 +39,8 @@ const prefer_class_directive_1 = __importDefault(require("../rules/prefer-class-
 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_store_callbacks_use_set_param_1 = __importDefault(require("../rules/require-store-callbacks-use-set-param"));
+const require_store_reactive_access_1 = __importDefault(require("../rules/require-store-reactive-access"));
 const require_stores_init_1 = __importDefault(require("../rules/require-stores-init"));
 const shorthand_attribute_1 = __importDefault(require("../rules/shorthand-attribute"));
 const shorthand_directive_1 = __importDefault(require("../rules/shorthand-directive"));
@@ -45,6 +48,7 @@ const sort_attributes_1 = __importDefault(require("../rules/sort-attributes"));
 const spaced_html_comment_1 = __importDefault(require("../rules/spaced-html-comment"));
 const system_1 = __importDefault(require("../rules/system"));
 const valid_compile_1 = __importDefault(require("../rules/valid-compile"));
+const valid_prop_names_in_kit_pages_1 = __importDefault(require("../rules/valid-prop-names-in-kit-pages"));
 exports.rules = [
     no_unnecessary_condition_1.default,
     button_has_type_1.default,
@@ -62,6 +66,7 @@ exports.rules = [
     no_dupe_else_if_blocks_1.default,
     no_dupe_style_properties_1.default,
     no_dynamic_slot_name_1.default,
+    no_export_load_in_svelte_module_in_kit_pages_1.default,
     no_extra_reactive_curlies_1.default,
     no_inner_declarations_1.default,
     no_not_function_handler_1.default,
@@ -80,6 +85,8 @@ exports.rules = [
     prefer_destructured_store_props_1.default,
     prefer_style_directive_1.default,
     require_optimized_style_attribute_1.default,
+    require_store_callbacks_use_set_param_1.default,
+    require_store_reactive_access_1.default,
     require_stores_init_1.default,
     shorthand_attribute_1.default,
     shorthand_directive_1.default,
@@ -87,4 +94,5 @@ exports.rules = [
     spaced_html_comment_1.default,
     system_1.default,
     valid_compile_1.default,
+    valid_prop_names_in_kit_pages_1.default,
 ];

package/lib/utils/svelte-kit.d.ts

@@ -0,0 +1,2 @@
+import type { RuleContext } from "../types";
+export declare function isKitPageComponent(context: RuleContext): boolean;

package/lib/utils/svelte-kit.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKitPageComponent = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const get_package_json_1 = require("./get-package-json");
+const isRunOnBrowser = !fs_1.default.readFileSync;
+function isKitPageComponent(context) {
+    if (isRunOnBrowser)
+        return true;
+    if (!hasSvelteKit(context.getFilename()))
+        return false;
+    const routes = context.settings?.svelte?.kit?.files?.routes?.replace(/^\//, "") ??
+        "src/routes";
+    const filePath = context.getFilename();
+    const projectRootDir = getProjectRootDir(context.getFilename()) ?? "";
+    const fileName = filePath.split("/").pop() || filePath;
+    return (filePath.startsWith(path_1.default.join(projectRootDir, routes)) &&
+        Boolean(/^\+.+\.svelte$/.test(fileName)));
+}
+exports.isKitPageComponent = isKitPageComponent;
+function hasSvelteKit(filePath) {
+    if (isRunOnBrowser)
+        return true;
+    try {
+        const packageJson = (0, get_package_json_1.getPackageJson)(filePath);
+        if (!packageJson)
+            return false;
+        if (packageJson.name === "eslint-plugin-svelte")
+            return true;
+        return Boolean(packageJson.dependencies["@sveltejs/kit"] ??
+            packageJson.devDependencies["@sveltejs/kit"]);
+    }
+    catch (_e) {
+        return false;
+    }
+}
+function getProjectRootDir(filePath) {
+    if (isRunOnBrowser)
+        return null;
+    const packageJsonFilePath = (0, get_package_json_1.getPackageJson)(filePath)?.filePath;
+    if (!packageJsonFilePath)
+        return null;
+    return path_1.default.dirname(path_1.default.resolve(packageJsonFilePath));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "2.11.0",
+  "version": "2.12.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",
@@ -34,7 +34,7 @@
     "docs:build": "yarn svelte-kit build",
     "docs:preview": "yarn svelte-kit preview",
     "docs:watch": "yarn svelte-kit dev",
-    "format-for-gen-file": "eslint src/types-for-node.ts src/utils/rules.ts src/configs --fix",
+    "format-for-gen-file": "eslint src/types-for-node.ts src/utils/rules.ts src/configs typings/estree/index.d.ts --fix",
     "install-with-ignore-engines": "yarn --ignore-engines",
     "lint": "run-p lint:*",
     "lint-fix": "yarn lint:es --fix && yarn lint:style --fix",
@@ -68,12 +68,12 @@
     "debug": "^4.3.1",
     "eslint-utils": "^3.0.0",
     "esutils": "^2.0.3",
-    "known-css-properties": "^0.25.0",
+    "known-css-properties": "^0.26.0",
     "postcss": "^8.4.5",
     "postcss-load-config": "^3.1.4",
     "postcss-safe-parser": "^6.0.0",
     "sourcemap-codec": "^1.4.8",
-    "svelte-eslint-parser": "^0.19.0"
+    "svelte-eslint-parser": "^0.20.0"
   },
   "devDependencies": {
     "@1stg/browserslist-config": "^1.2.3",
@@ -100,7 +100,6 @@
     "@types/eslint-scope": "^3.7.0",
     "@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",
@@ -131,10 +130,10 @@
     "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-mdx": "^2.0.2",
     "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-node-dependencies": "^0.9.0",
+    "eslint-plugin-node-dependencies": "^0.10.0",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-regexp": "^1.0.0",
-    "eslint-plugin-svelte": "^2.0.0",
+    "eslint-plugin-svelte": "^2.11.0",
     "eslint-plugin-yml": "^1.0.0",
     "eslint-scope": "^7.1.1",
     "estree-walker": "^3.0.0",
@@ -163,6 +162,7 @@
     "stylus": "^0.59.0",
     "svelte": "^3.46.1",
     "svelte-adapter-ghpages": "0.0.2",
+    "svelte-i18n": "^3.4.0",
     "type-coverage": "^2.22.0",
     "typescript": "^4.5.2",
     "vite": "^3.1.0-0",
@@ -174,7 +174,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 98.71,
+    "atLeast": 98.72,
     "cache": true,
     "detail": true,
     "ignoreAsAssertion": true,