eslint-plugin-svelte 2.12.0 → 2.13.1

package/README.md

@@ -298,6 +298,7 @@ These rules relate to possible syntax or logic errors in Svelte code:
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [svelte/no-dom-manipulating](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-dom-manipulating/) | disallow DOM manipulating |  |
 | [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: |

package/lib/rules/html-self-closing.js

@@ -49,14 +49,14 @@ exports.default = (0, utils_1.createRule)("html-self-closing", {
             },
         ],
     },
-    create(ctx) {
+    create(context) {
         let options = {
             void: "always",
             normal: "always",
             component: "always",
             svelte: "always",
         };
-        const option = ctx.options?.[0];
+        const option = context.options?.[0];
         switch (option) {
             case "none":
                 options = {
@@ -103,16 +103,22 @@ exports.default = (0, utils_1.createRule)("html-self-closing", {
             }
             return true;
         }
-        function report(node, close) {
+        function report(node, shouldBeClosed) {
             const elementType = getElementType(node);
-            ctx.report({
+            context.report({
                 node,
-                messageId: close ? "requireClosing" : "disallowClosing",
+                loc: {
+                    start: context
+                        .getSourceCode()
+                        .getLocFromIndex(node.startTag.range[1] - (node.startTag.selfClosing ? 2 : 1)),
+                    end: node.loc.end,
+                },
+                messageId: shouldBeClosed ? "requireClosing" : "disallowClosing",
                 data: {
                     type: TYPE_MESSAGES[elementType],
                 },
                 *fix(fixer) {
-                    if (close) {
+                    if (shouldBeClosed) {
                         for (const child of node.children) {
                             yield fixer.removeRange(child.range);
                         }

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

@@ -1,6 +1,6 @@
 import type { AST } from "svelte-eslint-parser";
 import type { TSESTree } from "@typescript-eslint/types";
-declare type AnyToken = AST.Token | AST.Comment;
+type AnyToken = AST.Token | AST.Comment;
 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/commons.d.ts

@@ -1,13 +1,13 @@
 import type { ASTNode, SourceCode } from "../../types";
 import type { AST } from "svelte-eslint-parser";
 import type { OffsetContext } from "./offset-context";
-export declare type AnyToken = AST.Token | AST.Comment;
-export declare type MaybeNode = {
+export type AnyToken = AST.Token | AST.Comment;
+export type MaybeNode = {
     type: string;
     range: [number, number];
     loc: AST.SourceLocation;
 };
-export declare type IndentOptions = {
+export type IndentOptions = {
     indentChar: " " | "\t";
     indentScript: boolean;
     indentSize: number;
@@ -15,7 +15,7 @@ export declare type IndentOptions = {
     alignAttributesVertically: boolean;
     ignoredNodes: string[];
 };
-export declare type IndentContext = {
+export type IndentContext = {
     sourceCode: SourceCode;
     options: IndentOptions;
     offsets: OffsetContext;

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

@@ -1,5 +1,5 @@
 import type { IndentContext } from "./commons";
 import type { ESNodeListener } from "../../types-for-node";
-declare type NodeListener = ESNodeListener;
+type NodeListener = ESNodeListener;
 export declare function defineVisitor(context: IndentContext): NodeListener;
 export {};

package/lib/rules/indent-helpers/offset-context.d.ts

@@ -5,7 +5,7 @@ declare const enum OffsetDataType {
     align = 1,
     start = 2
 }
-declare type OffsetData = {
+type OffsetData = {
     type: OffsetDataType.normal;
     base: number;
     offset: number;

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

@@ -1,5 +1,5 @@
 import type { SvelteNodeListener } from "../../types-for-node";
 import type { IndentContext } from "./commons";
-declare type NodeListener = SvelteNodeListener;
+type NodeListener = SvelteNodeListener;
 export declare function defineVisitor(context: IndentContext): NodeListener;
 export {};

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

@@ -1,5 +1,5 @@
 import type { IndentContext } from "./commons";
 import type { TSNodeListener } from "../../types-for-node";
-declare type NodeListener = TSNodeListener;
+type NodeListener = TSNodeListener;
 export declare function defineVisitor(context: IndentContext): NodeListener;
 export {};

package/lib/rules/no-dom-manipulating.d.ts

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

package/lib/rules/no-dom-manipulating.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const eslint_utils_1 = require("eslint-utils");
+const DOM_MANIPULATING_METHODS = new Set([
+    "appendChild",
+    "insertBefore",
+    "normalize",
+    "removeChild",
+    "replaceChild",
+    "after",
+    "append",
+    "before",
+    "insertAdjacentElement",
+    "insertAdjacentHTML",
+    "insertAdjacentText",
+    "prepend",
+    "remove",
+    "replaceChildren",
+    "replaceWith",
+]);
+const DOM_MANIPULATING_PROPERTIES = new Set([
+    "textContent",
+    "innerHTML",
+    "outerHTML",
+    "innerText",
+    "outerText",
+]);
+exports.default = (0, utils_1.createRule)("no-dom-manipulating", {
+    meta: {
+        docs: {
+            description: "disallow DOM manipulating",
+            category: "Possible Errors",
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            disallowManipulateDOM: "Don't manipulate the DOM directly. The Svelte runtime can get confused if there is a difference between the actual DOM and the DOM expected by the Svelte runtime.",
+        },
+        type: "problem",
+    },
+    create(context) {
+        const domVariables = new Set();
+        function verifyIdentifier(node) {
+            const member = node.parent;
+            if (member?.type !== "MemberExpression" || member.object !== node) {
+                return;
+            }
+            const name = (0, eslint_utils_1.getPropertyName)(member);
+            if (!name) {
+                return;
+            }
+            let target = member;
+            let parent = target.parent;
+            while (parent?.type === "ChainExpression") {
+                target = parent;
+                parent = parent.parent;
+            }
+            if (!parent) {
+                return;
+            }
+            if (parent.type === "CallExpression") {
+                if (parent.callee !== target || !DOM_MANIPULATING_METHODS.has(name)) {
+                    return;
+                }
+            }
+            else if (parent.type === "AssignmentExpression") {
+                if (parent.left !== target || !DOM_MANIPULATING_PROPERTIES.has(name)) {
+                    return;
+                }
+            }
+            context.report({
+                node: member,
+                messageId: "disallowManipulateDOM",
+            });
+        }
+        return {
+            "SvelteDirective[kind='Binding']"(node) {
+                if (node.key.name.name !== "this" ||
+                    !node.expression ||
+                    node.expression.type !== "Identifier") {
+                    return;
+                }
+                const element = node.parent.parent;
+                if (element.type !== "SvelteElement" || !isHTMLElement(element)) {
+                    return;
+                }
+                const variable = (0, ast_utils_1.findVariable)(context, node.expression);
+                if (!variable ||
+                    (variable.scope.type !== "module" && variable.scope.type !== "global")) {
+                    return;
+                }
+                domVariables.add(variable);
+            },
+            "Program:exit"() {
+                for (const variable of domVariables) {
+                    for (const reference of variable.references) {
+                        verifyIdentifier(reference.identifier);
+                    }
+                }
+            },
+        };
+        function isHTMLElement(node) {
+            return (node.kind === "html" ||
+                (node.kind === "special" && (0, ast_utils_1.getNodeName)(node) === "svelte:element"));
+        }
+    },
+});

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

@@ -47,7 +47,8 @@ exports.default = (0, utils_1.createRule)("prefer-destructured-store-props", {
                 }
             }
             function isReactiveVariableDefinitionWithMemberExpression(node) {
-                return (node.parent?.type === "MemberExpression" &&
+                return (node.type === "Identifier" &&
+                    node.parent?.type === "MemberExpression" &&
                     node.parent.object === node &&
                     (0, eslint_utils_1.getPropertyName)(node.parent) === propName &&
                     node.parent.parent?.type === "AssignmentExpression" &&
@@ -58,7 +59,8 @@ exports.default = (0, utils_1.createRule)("prefer-destructured-store-props", {
                         .parent?.type === "SvelteReactiveStatement");
             }
             function isReactiveVariableDefinitionWithDestructuring(node) {
-                return (node.parent?.type === "AssignmentExpression" &&
+                return (node.type === "Identifier" &&
+                    node.parent?.type === "AssignmentExpression" &&
                     node.parent.right === node &&
                     node.parent.left.type === "ObjectPattern" &&
                     node.parent.parent?.type === "ExpressionStatement" &&

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

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

package/lib/rules/sort-attributes.js

@@ -176,7 +176,7 @@ exports.default = (0, utils_1.createRule)("sort-attributes", {
             const k = cacheKeyText.get(node);
             if (k != null)
                 return k;
-            const result = (0, ast_utils_1.getAttributeKeyText)(node);
+            const result = (0, ast_utils_1.getAttributeKeyText)(node, context);
             cacheKeyText.set(node, result);
             return result;
         }

package/lib/shared/comment-directives.d.ts

@@ -1,6 +1,6 @@
 import type { AST } from "svelte-eslint-parser";
 import type { Linter } from "eslint";
-declare type Define = {
+type Define = {
     loc: AST.Position;
 };
 export declare class CommentDirectives {

package/lib/shared/svelte-compile-warns/ignore-comment.d.ts

@@ -1,11 +1,11 @@
 import type { AST } from "svelte-eslint-parser";
 import type { RuleContext } from "../../types";
-export declare type IgnoreItemWithoutCode = {
+export type IgnoreItemWithoutCode = {
     range: [number, number];
     code: null;
     token: AST.Token | AST.Comment;
 };
-export declare type IgnoreItem = {
+export type IgnoreItem = {
     range: [number, number];
     code: string;
     token: AST.Token | AST.Comment;

package/lib/shared/svelte-compile-warns/index.d.ts

@@ -1,13 +1,13 @@
 import type { AST } from "svelte-eslint-parser";
 import type { RuleContext } from "../../types";
 import type { IgnoreItem } from "./ignore-comment";
-export declare type SvelteCompileWarnings = {
+export type SvelteCompileWarnings = {
     warnings: Warning[];
     unusedIgnores: IgnoreItem[];
     kind: "warn" | "error";
     stripStyleElements: AST.SvelteStyleElement[];
 };
-export declare type Loc = {
+export type Loc = {
     start?: {
         line: number;
         column: number;
@@ -17,7 +17,7 @@ export declare type Loc = {
         column: number;
     };
 };
-export declare type Warning = {
+export type Warning = {
     code?: string;
     message: string;
 } & Loc;

package/lib/shared/svelte-compile-warns/transform/types.d.ts

@@ -1,5 +1,5 @@
 import type { AST } from "svelte-eslint-parser";
-export declare type TransformResult = {
+export type TransformResult = {
     inputRange: AST.Range;
     output: string;
     mappings: string;

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

@@ -1,12 +1,12 @@
 import type { TSESTree, AST_NODE_TYPES } from "@typescript-eslint/types";
 import type { AST } from "svelte-eslint-parser";
-export declare type ASTNode = AST.SvelteNode | Exclude<Omit<TSESTree.Node, "parent">, {
+export type ASTNode = AST.SvelteNode | Exclude<Omit<TSESTree.Node, "parent">, {
     type: AST.SvelteNode["type"];
 }>;
-export declare type ASTNodeWithParent = (Exclude<ASTNode, AST.SvelteProgram> & {
+export type ASTNodeWithParent = (Exclude<ASTNode, AST.SvelteProgram> & {
     parent: ASTNodeWithParent;
 }) | AST.SvelteProgram;
-export declare type ASTNodeListener = {
+export type ASTNodeListener = {
     ArrayExpression?: (node: TSESTree.ArrayExpression & ASTNodeWithParent) => void;
     ArrayPattern?: (node: TSESTree.ArrayPattern & ASTNodeWithParent) => void;
     ArrowFunctionExpression?: (node: TSESTree.ArrowFunctionExpression & ASTNodeWithParent) => void;
@@ -151,6 +151,7 @@ export declare type ASTNodeListener = {
     TSQualifiedName?: (node: TSESTree.TSQualifiedName & ASTNodeWithParent) => void;
     TSReadonlyKeyword?: (node: TSESTree.TSReadonlyKeyword & ASTNodeWithParent) => void;
     TSRestType?: (node: TSESTree.TSRestType & ASTNodeWithParent) => void;
+    TSSatisfiesExpression?: (node: TSESTree.TSSatisfiesExpression & ASTNodeWithParent) => void;
     TSStaticKeyword?: (node: TSESTree.TSStaticKeyword & ASTNodeWithParent) => void;
     TSStringKeyword?: (node: TSESTree.TSStringKeyword & ASTNodeWithParent) => void;
     TSSymbolKeyword?: (node: TSESTree.TSSymbolKeyword & ASTNodeWithParent) => void;
@@ -204,7 +205,7 @@ export declare type ASTNodeListener = {
     SvelteHTMLComment?: (node: AST.SvelteHTMLComment & ASTNodeWithParent) => void;
     SvelteReactiveStatement?: (node: AST.SvelteReactiveStatement & ASTNodeWithParent) => void;
 };
-export declare type ESNodeListener = {
+export type ESNodeListener = {
     ArrayExpression?: (node: TSESTree.ArrayExpression & ASTNodeWithParent) => void;
     ArrayPattern?: (node: TSESTree.ArrayPattern & ASTNodeWithParent) => void;
     ArrowFunctionExpression?: (node: TSESTree.ArrowFunctionExpression & ASTNodeWithParent) => void;
@@ -277,7 +278,7 @@ export declare type ESNodeListener = {
     Program?: (node: AST.SvelteProgram & ASTNodeWithParent) => void;
     SvelteReactiveStatement?: (node: AST.SvelteReactiveStatement & ASTNodeWithParent) => void;
 };
-export declare type TSNodeListener = {
+export type TSNodeListener = {
     Decorator?: (node: TSESTree.Decorator & ASTNodeWithParent) => void;
     ImportAttribute?: (node: TSESTree.ImportAttribute & ASTNodeWithParent) => void;
     StaticBlock?: (node: TSESTree.StaticBlock & ASTNodeWithParent) => void;
@@ -338,6 +339,7 @@ export declare type TSNodeListener = {
     TSQualifiedName?: (node: TSESTree.TSQualifiedName & ASTNodeWithParent) => void;
     TSReadonlyKeyword?: (node: TSESTree.TSReadonlyKeyword & ASTNodeWithParent) => void;
     TSRestType?: (node: TSESTree.TSRestType & ASTNodeWithParent) => void;
+    TSSatisfiesExpression?: (node: TSESTree.TSSatisfiesExpression & ASTNodeWithParent) => void;
     TSStaticKeyword?: (node: TSESTree.TSStaticKeyword & ASTNodeWithParent) => void;
     TSStringKeyword?: (node: TSESTree.TSStringKeyword & ASTNodeWithParent) => void;
     TSSymbolKeyword?: (node: TSESTree.TSSymbolKeyword & ASTNodeWithParent) => void;
@@ -360,7 +362,7 @@ export declare type TSNodeListener = {
     TSUnknownKeyword?: (node: TSESTree.TSUnknownKeyword & ASTNodeWithParent) => void;
     TSVoidKeyword?: (node: TSESTree.TSVoidKeyword & ASTNodeWithParent) => void;
 };
-export declare type SvelteNodeListener = {
+export type SvelteNodeListener = {
     SvelteScriptElement?: (node: AST.SvelteScriptElement & ASTNodeWithParent) => void;
     SvelteStyleElement?: (node: AST.SvelteStyleElement & ASTNodeWithParent) => void;
     SvelteElement?: (node: AST.SvelteElement & ASTNodeWithParent) => void;

package/lib/types.d.ts

@@ -1,7 +1,8 @@
 import type { JSONSchema4 } from "json-schema";
-import type { Linter, Rule, Scope, SourceCode as ESLintSourceCode } from "eslint";
+import type { Linter, Rule, SourceCode as ESLintSourceCode } from "eslint";
 import type { AST } from "svelte-eslint-parser";
 import type { TSESTree } from "@typescript-eslint/types";
+import type { ScopeManager, Scope, Variable } from "@typescript-eslint/scope-manager";
 import type { ASTNode, ASTNodeWithParent, ASTNodeListener } from "./types-for-node";
 export type { ASTNode, ASTNodeWithParent, ASTNodeListener };
 export interface RuleListener extends ASTNodeListener {
@@ -16,7 +17,7 @@ export interface RuleModule {
     meta: RuleMetaData;
     create: (context: RuleContext) => RuleListener;
 }
-export declare type RuleCategory = "Possible Errors" | "Security Vulnerability" | "Best Practices" | "Stylistic Issues" | "Extension Rules" | "System";
+export type RuleCategory = "Possible Errors" | "Security Vulnerability" | "Best Practices" | "Stylistic Issues" | "Extension Rules" | "System";
 export interface RuleMetaData {
     docs: {
         description: string;
@@ -76,7 +77,7 @@ export interface PartialRuleMetaData {
     };
     type: "problem" | "suggestion" | "layout";
 }
-export declare type RuleContext = {
+export type RuleContext = {
     id: string;
     options: any[];
     settings?: {
@@ -99,15 +100,15 @@ export declare type RuleContext = {
     parserOptions: Linter.ParserOptions;
     parserServices: ESLintSourceCode.ParserServices;
     getAncestors(): ASTNode[];
-    getDeclaredVariables(node: TSESTree.Node): Scope.Variable[];
+    getDeclaredVariables(node: TSESTree.Node): Variable[];
     getFilename(): string;
-    getScope(): Scope.Scope;
+    getScope(): Scope;
     getSourceCode(): SourceCode;
     markVariableAsUsed(name: string): boolean;
     report(descriptor: ReportDescriptor): void;
     getCwd?: () => string;
 };
-export declare type NodeOrToken = {
+export type NodeOrToken = {
     type: string;
     loc?: AST.SourceLocation | null;
     range?: [number, number];
@@ -118,22 +119,22 @@ interface ReportDescriptorOptionsBase {
     };
     fix?: null | ((fixer: RuleFixer) => null | Rule.Fix | IterableIterator<Rule.Fix> | Rule.Fix[]);
 }
-declare type SuggestionDescriptorMessage = {
+type SuggestionDescriptorMessage = {
     desc: string;
 } | {
     messageId: string;
 };
-export declare type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
+export type SuggestionReportDescriptor = SuggestionDescriptorMessage & ReportDescriptorOptionsBase;
 interface ReportDescriptorOptions extends ReportDescriptorOptionsBase {
     suggest?: SuggestionReportDescriptor[] | null;
 }
-declare type ReportDescriptor = ReportDescriptorMessage & ReportDescriptorLocation & ReportDescriptorOptions;
-declare type ReportDescriptorMessage = {
+type ReportDescriptor = ReportDescriptorMessage & ReportDescriptorLocation & ReportDescriptorOptions;
+type ReportDescriptorMessage = {
     message: string;
 } | {
     messageId: string;
 };
-declare type ReportDescriptorLocation = {
+type ReportDescriptorLocation = {
     node: NodeOrToken;
 } | {
     loc: AST.SourceLocation | {
@@ -160,7 +161,7 @@ export interface SourceCode {
     lines: string[];
     hasBOM: boolean;
     parserServices: ESLintSourceCode.ParserServices;
-    scopeManager: Scope.ScopeManager;
+    scopeManager: ScopeManager;
     visitorKeys: ESLintSourceCode.VisitorKeys;
     getText(node?: NodeOrToken, beforeCount?: number, afterCount?: number): string;
     getLines(): string[];

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

@@ -1,7 +1,7 @@
 import type { ASTNode, RuleContext, SourceCode } from "../types";
 import type { TSESTree } from "@typescript-eslint/types";
+import type { Scope, Variable } from "@typescript-eslint/scope-manager";
 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: TSESTree.Expression | TSESTree.PrivateIdentifier): string | null;
 export declare function needParentheses(node: TSESTree.Expression, kind: "not" | "logical"): boolean;
@@ -29,10 +29,10 @@ 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: TSESTree.Identifier): Scope.Variable | null;
-export declare function getScope(context: RuleContext, currentNode: TSESTree.Node): Scope.Scope;
+export declare function findVariable(context: RuleContext, node: TSESTree.Identifier): Variable | null;
+export declare function getScope(context: RuleContext, currentNode: TSESTree.Node): Scope;
 export declare function getParent(node: TSESTree.Node): TSESTree.Node | null;
-export declare type QuoteAndRange = {
+export type QuoteAndRange = {
     quote: "unquoted" | "double" | "single";
     range: [number, number];
     firstToken: SvAST.Token | SvAST.Comment;
@@ -47,7 +47,7 @@ export declare function getMustacheTokens(node: SvAST.SvelteDirective | SvAST.Sv
     openToken: SvAST.Token;
     closeToken: SvAST.Token;
 } | null;
-export declare function getAttributeKeyText(node: SvAST.SvelteAttribute | SvAST.SvelteShorthandAttribute | SvAST.SvelteStyleDirective | SvAST.SvelteDirective | SvAST.SvelteSpecialDirective): string;
+export declare function getAttributeKeyText(node: SvAST.SvelteAttribute | SvAST.SvelteShorthandAttribute | SvAST.SvelteStyleDirective | SvAST.SvelteDirective | SvAST.SvelteSpecialDirective, context: RuleContext): string;
 export declare function getDirectiveName(node: SvAST.SvelteDirective): string;
 export declare function getNodeName(node: SvAST.SvelteElement): string;
 export declare function isVoidHtmlElement(node: SvAST.SvelteElement): boolean;

package/lib/utils/ast-utils.js

@@ -276,7 +276,7 @@ function getMustacheTokens(node, sourceCode) {
     };
 }
 exports.getMustacheTokens = getMustacheTokens;
-function getAttributeKeyText(node) {
+function getAttributeKeyText(node, context) {
     switch (node.type) {
         case "SvelteAttribute":
         case "SvelteShorthandAttribute":
@@ -287,7 +287,7 @@ function getAttributeKeyText(node) {
             return node.kind;
         case "SvelteDirective": {
             const dir = getDirectiveName(node);
-            return `${dir}:${node.key.name.name}${node.key.modifiers.length ? `|${node.key.modifiers.join("|")}` : ""}`;
+            return `${dir}:${getSimpleNameFromNode(node.key.name, context)}${node.key.modifiers.length ? `|${node.key.modifiers.join("|")}` : ""}`;
         }
         default:
             throw new Error(`Unknown node type: ${node.type}`);
@@ -339,19 +339,7 @@ function getAttributeValueRangeTokens(attr, sourceCode) {
     };
 }
 function getNodeName(node) {
-    if ("name" in node.name) {
-        return node.name.name;
-    }
-    let object = "";
-    let currentObject = node.name.object;
-    while ("object" in currentObject) {
-        object = `${currentObject.property.name}.${object}`;
-        currentObject = currentObject.object;
-    }
-    if ("name" in currentObject) {
-        object = `${currentObject.name}.${object}`;
-    }
-    return object + node.name.property.name;
+    return getSimpleNameFromNode(node.name);
 }
 exports.getNodeName = getNodeName;
 function isVoidHtmlElement(node) {
@@ -394,3 +382,16 @@ function isExpressionIdentifier(node) {
     return true;
 }
 exports.isExpressionIdentifier = isExpressionIdentifier;
+function getSimpleNameFromNode(node, context) {
+    if (node.type === "Identifier" || node.type === "SvelteName") {
+        return node.name;
+    }
+    if (node.type === "SvelteMemberExpressionName" ||
+        (node.type === "MemberExpression" && !node.computed)) {
+        return `${getSimpleNameFromNode(node.object, context)}.${getSimpleNameFromNode(node.property, context)}`;
+    }
+    if (!context) {
+        throw new Error("Rule context is required");
+    }
+    return context.getSourceCode().getText(node);
+}

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

@@ -2,7 +2,7 @@ import type { AST } from "svelte-eslint-parser";
 import type { RuleContext } from "../../types";
 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 | TSESTree.Expression;
+export type SvelteStyleInterpolation = AST.SvelteMustacheTagText | TSESTree.Expression;
 export interface SvelteStyleNode<E extends SvelteStyleInterpolation> {
     nodes?: SvelteStyleChildNode<E>[];
     range: AST.Range;
@@ -40,4 +40,4 @@ export interface SvelteStyleComment extends SvelteStyleNode<never> {
     type: "comment";
     addInterpolation: (tagOrExpr: SvelteStyleInterpolation) => void;
 }
-export declare type SvelteStyleChildNode<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> = SvelteStyleDeclaration<E> | SvelteStyleComment;
+export type SvelteStyleChildNode<E extends SvelteStyleInterpolation = SvelteStyleInterpolation> = SvelteStyleDeclaration<E> | SvelteStyleComment;

package/lib/utils/css-utils/template-tokenize.d.ts

@@ -1,5 +1,5 @@
 import type { Tokenizer } from "postcss/lib/tokenize";
 import tokenize from "postcss/lib/tokenize";
-declare type Tokenize = typeof tokenize;
+type Tokenize = typeof tokenize;
 declare function templateTokenize(...args: Parameters<Tokenize>): Tokenizer;
 export default templateTokenize;

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

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

package/lib/utils/rules.js

@@ -17,6 +17,7 @@ const max_attributes_per_line_1 = __importDefault(require("../rules/max-attribut
 const mustache_spacing_1 = __importDefault(require("../rules/mustache-spacing"));
 const no_at_debug_tags_1 = __importDefault(require("../rules/no-at-debug-tags"));
 const no_at_html_tags_1 = __importDefault(require("../rules/no-at-html-tags"));
+const no_dom_manipulating_1 = __importDefault(require("../rules/no-dom-manipulating"));
 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"));
@@ -63,6 +64,7 @@ exports.rules = [
     mustache_spacing_1.default,
     no_at_debug_tags_1.default,
     no_at_html_tags_1.default,
+    no_dom_manipulating_1.default,
     no_dupe_else_if_blocks_1.default,
     no_dupe_style_properties_1.default,
     no_dynamic_slot_name_1.default,

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

@@ -1,8 +1,8 @@
 import type { RuleContext, ASTNode } from "../../types";
 import type * as TS from "typescript";
-export declare type TypeScript = typeof TS;
+export type TypeScript = typeof TS;
 export type { TS };
-export declare type TSTools = {
+export type TSTools = {
     service: {
         esTreeNodeToTSNodeMap: ReadonlyMap<unknown, TS.Node>;
         tsNodeToESTreeNodeMap: ReadonlyMap<TS.Node, ASTNode>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "2.12.0",
+  "version": "2.13.1",
   "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",
@@ -73,7 +73,7 @@
     "postcss-load-config": "^3.1.4",
     "postcss-safe-parser": "^6.0.0",
     "sourcemap-codec": "^1.4.8",
-    "svelte-eslint-parser": "^0.20.0"
+    "svelte-eslint-parser": "^0.22.0"
   },
   "devDependencies": {
     "@1stg/browserslist-config": "^1.2.3",
@@ -174,7 +174,7 @@
     "access": "public"
   },
   "typeCoverage": {
-    "atLeast": 98.72,
+    "atLeast": 99.04,
     "cache": true,
     "detail": true,
     "ignoreAsAssertion": true,