eslint-plugin-svelte 2.10.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
 
@@ -327,7 +366,6 @@ These rules extend the rules provided by ESLint itself, or other plugins to work
 
 | 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: |
 
@@ -340,6 +378,15 @@ These rules relate to this plugin works:
 | [svelte/comment-directive](https://ota-meshi.github.io/eslint-plugin-svelte/rules/comment-directive/) | support comment-directives in HTML template | :star: |
 | [svelte/system](https://ota-meshi.github.io/eslint-plugin-svelte/rules/system/) | system rule for working this plugin | :star: |
 
+## Deprecated
+
+- :warning: We're going to remove deprecated rules in the next major release. Please migrate to successor/new rules.
+- :innocent: We don't fix bugs which are in deprecated rules since we don't have enough resources.
+
+| Rule ID | Replaced by |
+|:--------|:------------|
+| [svelte/@typescript-eslint/no-unnecessary-condition](https://ota-meshi.github.io/eslint-plugin-svelte/rules/@typescript-eslint/no-unnecessary-condition/) | This rule is no longer needed when using svelte-eslint-parser>=v0.19.0. |
+
 <!--RULES_TABLE_END-->
 <!--RULES_SECTION_END-->
 <!-- prettier-ignore-end -->

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

@@ -76,6 +76,10 @@ exports.default = (0, utils_1.createRule)("@typescript-eslint/no-unnecessary-con
             noStrictNullCheck: "This rule requires the `strictNullChecks` compiler option to be turned on to function correctly.",
         },
         type: "suggestion",
+        deprecated: true,
+        replacedBy: {
+            note: "This rule is no longer needed when using svelte-eslint-parser>=v0.19.0.",
+        },
     },
     create(context) {
         const { allowConstantLoopConditions = false, allowRuleToRunWithoutStrictNullChecksIKnowWhatIAmDoing = false, } = (context.options[0] || {});

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;