eslint-plugin-svelte 2.2.0 → 2.4.0

package/README.md

@@ -35,7 +35,7 @@ The [svelte-eslint-parser] and the `eslint-plugin-svelte` can not be used with t
 
 ## Migration Guide
 
-To migrate from `eslint-plugin-svelte` v1, or `@ota-meshi/eslint-plugin-svelte`, please refer to the [migration guide](https://ota-meshi.github.io/eslint-plugin-svelte/migration/).
+To migrate from `eslint-plugin-svelte` v1, or [`@ota-meshi/eslint-plugin-svelte`](https://www.npmjs.com/package/@ota-meshi/eslint-plugin-svelte), please refer to the [migration guide](https://ota-meshi.github.io/eslint-plugin-svelte/migration/).
 
 ## :book: Documentation
 
@@ -244,8 +244,9 @@ Example **.vscode/settings.json**:
 
 <!--RULES_SECTION_START-->
 
-The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) automatically fixes problems reported by rules which have a wrench :wrench: below.  
-The rules with the following star :star: are included in the configs.
+:wrench: Indicates that the rule is fixable, and using `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fixing-problems) can automatically fix some of the reported problems.  
+:bulb: Indicates that some problems reported by the rule are manually fixable by editor [suggestions](https://eslint.org/docs/developer-guide/working-with-rules#providing-suggestions).  
+:star: Indicates that the rule is included in the `plugin:svelte/recommended` config.
 
 <!--RULES_TABLE_START-->
 
@@ -281,6 +282,7 @@ These rules relate to better ways of doing things to help you avoid problems:
 |:--------|:------------|:---|
 | [svelte/button-has-type](https://ota-meshi.github.io/eslint-plugin-svelte/rules/button-has-type/) | disallow usage of button without an explicit type attribute |  |
 | [svelte/no-at-debug-tags](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-at-debug-tags/) | disallow the use of `{@debug}` | :star: |
+| [svelte/no-reactive-literals](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-reactive-literals/) | Don't assign literal values in reactive statements | :bulb: |
 | [svelte/no-unused-svelte-ignore](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-unused-svelte-ignore/) | disallow unused svelte-ignore comments | :star: |
 | [svelte/no-useless-mustaches](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-useless-mustaches/) | disallow unnecessary mustache interpolations | :wrench: |
 | [svelte/require-optimized-style-attribute](https://ota-meshi.github.io/eslint-plugin-svelte/rules/require-optimized-style-attribute/) | require style attributes that can be optimized |  |
@@ -292,14 +294,18 @@ These rules relate to style guidelines, and are therefore quite subjective:
 | Rule ID | Description |    |
 |:--------|:------------|:---|
 | [svelte/first-attribute-linebreak](https://ota-meshi.github.io/eslint-plugin-svelte/rules/first-attribute-linebreak/) | enforce the location of first attribute | :wrench: |
+| [svelte/html-closing-bracket-spacing](https://ota-meshi.github.io/eslint-plugin-svelte/rules/html-closing-bracket-spacing/) | require or disallow a space before tag's closing brackets | :wrench: |
 | [svelte/html-quotes](https://ota-meshi.github.io/eslint-plugin-svelte/rules/html-quotes/) | enforce quotes style of HTML attributes | :wrench: |
 | [svelte/indent](https://ota-meshi.github.io/eslint-plugin-svelte/rules/indent/) | enforce consistent indentation | :wrench: |
 | [svelte/max-attributes-per-line](https://ota-meshi.github.io/eslint-plugin-svelte/rules/max-attributes-per-line/) | enforce the maximum number of attributes per line | :wrench: |
 | [svelte/mustache-spacing](https://ota-meshi.github.io/eslint-plugin-svelte/rules/mustache-spacing/) | enforce unified spacing in mustache | :wrench: |
+| [svelte/no-extra-reactive-curlies](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-extra-reactive-curlies/) | disallow wrapping single reactive statements in curly braces | :bulb: |
+| [svelte/no-spaces-around-equal-signs-in-attribute](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-spaces-around-equal-signs-in-attribute/) | disallow spaces around equal signs in attribute | :wrench: |
 | [svelte/prefer-class-directive](https://ota-meshi.github.io/eslint-plugin-svelte/rules/prefer-class-directive/) | require class directives instead of ternary expressions | :wrench: |
 | [svelte/prefer-style-directive](https://ota-meshi.github.io/eslint-plugin-svelte/rules/prefer-style-directive/) | require style directives instead of style attribute | :wrench: |
 | [svelte/shorthand-attribute](https://ota-meshi.github.io/eslint-plugin-svelte/rules/shorthand-attribute/) | enforce use of shorthand syntax in attribute | :wrench: |
 | [svelte/shorthand-directive](https://ota-meshi.github.io/eslint-plugin-svelte/rules/shorthand-directive/) | enforce use of shorthand syntax in directives | :wrench: |
+| [svelte/sort-attributes](https://ota-meshi.github.io/eslint-plugin-svelte/rules/sort-attributes/) | enforce order of attributes | :wrench: |
 | [svelte/spaced-html-comment](https://ota-meshi.github.io/eslint-plugin-svelte/rules/spaced-html-comment/) | enforce consistent spacing after the `<!--` and before the `-->` in a HTML comment | :wrench: |
 
 ## Extension Rules
@@ -334,7 +340,9 @@ Please use GitHub's Issues/PRs.
 
 - `yarn test` runs tests.
 - `yarn cover` runs tests and measures coverage.
+- `yarn new [new-rule-name]` generate the files needed to implement the new rule.
 - `yarn update` runs in order to update readme and recommended configuration.
+- `yarn docs:watch` launch the document site in development mode.
 
 ### Test the Rule
 

package/lib/configs/prettier.d.ts

@@ -2,10 +2,12 @@ declare const _default: {
     extends: string[];
     rules: {
         "svelte/first-attribute-linebreak": string;
+        "svelte/html-closing-bracket-spacing": string;
         "svelte/html-quotes": string;
         "svelte/indent": string;
         "svelte/max-attributes-per-line": string;
         "svelte/mustache-spacing": string;
+        "svelte/no-spaces-around-equal-signs-in-attribute": string;
         "svelte/shorthand-attribute": string;
         "svelte/shorthand-directive": string;
     };

package/lib/configs/prettier.js

@@ -9,10 +9,12 @@ module.exports = {
     extends: [baseExtend],
     rules: {
         "svelte/first-attribute-linebreak": "off",
+        "svelte/html-closing-bracket-spacing": "off",
         "svelte/html-quotes": "off",
         "svelte/indent": "off",
         "svelte/max-attributes-per-line": "off",
         "svelte/mustache-spacing": "off",
+        "svelte/no-spaces-around-equal-signs-in-attribute": "off",
         "svelte/shorthand-attribute": "off",
         "svelte/shorthand-directive": "off",
     },

package/lib/index.d.ts

@@ -37,10 +37,12 @@ declare const _default: {
             extends: string[];
             rules: {
                 "svelte/first-attribute-linebreak": string;
+                "svelte/html-closing-bracket-spacing": string;
                 "svelte/html-quotes": string;
                 "svelte/indent": string;
                 "svelte/max-attributes-per-line": string;
                 "svelte/mustache-spacing": string;
+                "svelte/no-spaces-around-equal-signs-in-attribute": string;
                 "svelte/shorthand-attribute": string;
                 "svelte/shorthand-directive": string;
             };

package/lib/rules/html-closing-bracket-spacing.d.ts

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

package/lib/rules/html-closing-bracket-spacing.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = (0, utils_1.createRule)("html-closing-bracket-spacing", {
+    meta: {
+        docs: {
+            description: "require or disallow a space before tag's closing brackets",
+            category: "Stylistic Issues",
+            conflictWithPrettier: true,
+            recommended: false,
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    startTag: {
+                        enum: ["always", "never", "ignore"],
+                    },
+                    endTag: {
+                        enum: ["always", "never", "ignore"],
+                    },
+                    selfClosingTag: {
+                        enum: ["always", "never", "ignore"],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            expectedSpace: "Expected space before '>', but not found.",
+            unexpectedSpace: "Expected no space before '>', but found.",
+        },
+        fixable: "whitespace",
+        type: "layout",
+    },
+    create(ctx) {
+        const options = {
+            startTag: "never",
+            endTag: "never",
+            selfClosingTag: "always",
+            ...ctx.options[0],
+        };
+        const src = ctx.getSourceCode();
+        function containsNewline(string) {
+            return string.includes("\n");
+        }
+        function report(node, shouldHave) {
+            const tagSrc = src.getText(node);
+            const match = /(\s*)\/?>$/.exec(tagSrc);
+            const end = node.range[1];
+            const start = node.range[1] - match[0].length;
+            const loc = {
+                start: src.getLocFromIndex(start),
+                end: src.getLocFromIndex(end),
+            };
+            ctx.report({
+                loc,
+                messageId: shouldHave ? "expectedSpace" : "unexpectedSpace",
+                *fix(fixer) {
+                    if (shouldHave) {
+                        yield fixer.insertTextBeforeRange([start, end], " ");
+                    }
+                    else {
+                        const spaces = match[1];
+                        yield fixer.removeRange([start, start + spaces.length]);
+                    }
+                },
+            });
+        }
+        return {
+            "SvelteStartTag, SvelteEndTag"(node) {
+                const tagType = node.type === "SvelteEndTag"
+                    ? "endTag"
+                    : node.selfClosing
+                        ? "selfClosingTag"
+                        : "startTag";
+                if (options[tagType] === "ignore")
+                    return;
+                const tagSrc = src.getText(node);
+                const match = /(\s*)\/?>$/.exec(tagSrc);
+                if (containsNewline(match[1]))
+                    return;
+                if (options[tagType] === "always" && !match[1]) {
+                    report(node, true);
+                }
+                else if (options[tagType] === "never" && match[1]) {
+                    report(node, false);
+                }
+            },
+        };
+    },
+});

package/lib/rules/no-extra-reactive-curlies.d.ts

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

package/lib/rules/no-extra-reactive-curlies.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = (0, utils_1.createRule)("no-extra-reactive-curlies", {
+    meta: {
+        docs: {
+            description: "disallow wrapping single reactive statements in curly braces",
+            category: "Stylistic Issues",
+            recommended: false,
+            conflictWithPrettier: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            extraCurlies: `Do not wrap reactive statements in curly braces unless necessary.`,
+            removeExtraCurlies: `Remove the unnecessary curly braces.`,
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        return {
+            [`SvelteReactiveStatement > BlockStatement[body.length=1]`]: (node) => {
+                const source = context.getSourceCode();
+                return context.report({
+                    node,
+                    loc: node.loc,
+                    messageId: "extraCurlies",
+                    suggest: [
+                        {
+                            messageId: "removeExtraCurlies",
+                            fix(fixer) {
+                                const tokens = source.getTokens(node, { includeComments: true });
+                                return [
+                                    fixer.removeRange([tokens[0].range[0], tokens[1].range[0]]),
+                                    fixer.removeRange([
+                                        tokens[tokens.length - 2].range[1],
+                                        tokens[tokens.length - 1].range[1],
+                                    ]),
+                                ];
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/lib/rules/no-reactive-literals.d.ts

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

package/lib/rules/no-reactive-literals.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = (0, utils_1.createRule)("no-reactive-literals", {
+    meta: {
+        docs: {
+            description: "Don't assign literal values in reactive statements",
+            category: "Best Practices",
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noReactiveLiterals: `Do not assign literal values inside reactive statements unless absolutely necessary.`,
+            fixReactiveLiteral: `Move the literal out of the reactive statement into an assignment`,
+        },
+        type: "suggestion",
+    },
+    create(context) {
+        return {
+            [`SvelteReactiveStatement > ExpressionStatement > AssignmentExpression${[
+                `[right.type="Literal"]`,
+                `[right.type="ArrayExpression"][right.elements.length=0]`,
+                `[right.type="ObjectExpression"][right.properties.length=0]`,
+            ].join(",")}`](node) {
+                const parent = node.parent?.parent;
+                if (!parent) {
+                    return false;
+                }
+                const source = context.getSourceCode();
+                return context.report({
+                    node: parent,
+                    loc: parent.loc,
+                    messageId: "noReactiveLiterals",
+                    suggest: [
+                        {
+                            messageId: "fixReactiveLiteral",
+                            fix(fixer) {
+                                return [
+                                    fixer.insertTextBefore(parent, `let ${source.getText(node)}`),
+                                    fixer.remove(parent),
+                                ];
+                            },
+                        },
+                    ],
+                });
+            },
+        };
+    },
+});

package/lib/rules/no-spaces-around-equal-signs-in-attribute.d.ts

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

package/lib/rules/no-spaces-around-equal-signs-in-attribute.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+exports.default = (0, utils_1.createRule)("no-spaces-around-equal-signs-in-attribute", {
+    meta: {
+        docs: {
+            description: "disallow spaces around equal signs in attribute",
+            category: "Stylistic Issues",
+            recommended: false,
+            conflictWithPrettier: true,
+        },
+        schema: {},
+        fixable: "whitespace",
+        messages: {
+            noSpaces: "Unexpected spaces found around equal signs.",
+        },
+        type: "layout",
+    },
+    create(ctx) {
+        const source = ctx.getSourceCode();
+        function getAttrEq(node) {
+            const keyRange = node.key.range;
+            const eqSource = /^[\s=]*/u.exec(source.text.slice(keyRange[1], node.range[1]))[0];
+            const valueStart = keyRange[1] + eqSource.length;
+            return [eqSource, [keyRange[1], valueStart]];
+        }
+        function containsWhitespace(string) {
+            return /\s/u.test(string);
+        }
+        return {
+            "SvelteAttribute, SvelteDirective, SvelteStyleDirective, SvelteSpecialDirective"(node) {
+                const [eqSource, range] = getAttrEq(node);
+                if (!containsWhitespace(eqSource))
+                    return;
+                const loc = {
+                    start: source.getLocFromIndex(range[0]),
+                    end: source.getLocFromIndex(range[1]),
+                };
+                ctx.report({
+                    loc,
+                    messageId: "noSpaces",
+                    *fix(fixer) {
+                        yield fixer.replaceTextRange(range, "=");
+                    },
+                });
+            },
+        };
+    },
+});

package/lib/rules/no-unused-svelte-ignore.js

@@ -18,6 +18,9 @@ exports.default = (0, utils_1.createRule)("no-unused-svelte-ignore", {
         type: "suggestion",
     },
     create(context) {
+        if (!context.parserServices.isSvelte) {
+            return {};
+        }
         const sourceCode = context.getSourceCode();
         const ignoreComments = [];
         for (const item of (0, ignore_comment_1.getSvelteIgnoreItems)(context)) {

package/lib/rules/sort-attributes.d.ts

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

package/lib/rules/sort-attributes.js

@@ -0,0 +1,260 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+const regexp_1 = require("../utils/regexp");
+const DEFAULT_ORDER = [
+    "this",
+    "bind:this",
+    "id",
+    "name",
+    "slot",
+    { match: "/^--/u", sort: "alphabetical" },
+    ["style", "/^style:/u"],
+    "class",
+    { match: "/^class:/u", sort: "alphabetical" },
+    {
+        match: ["!/:/u", "!/^(?:this|id|name|style|class)$/u", "!/^--/u"],
+        sort: "alphabetical",
+    },
+    ["/^bind:/u", "!bind:this", "/^on:/u"],
+    { match: "/^use:/u", sort: "alphabetical" },
+    { match: "/^transition:/u", sort: "alphabetical" },
+    { match: "/^in:/u", sort: "alphabetical" },
+    { match: "/^out:/u", sort: "alphabetical" },
+    { match: "/^animate:/u", sort: "alphabetical" },
+    { match: "/^let:/u", sort: "alphabetical" },
+];
+function parseOption(option) {
+    const order = option?.order ?? DEFAULT_ORDER;
+    const compiled = order.map(compileOption);
+    return {
+        ignore: (key) => {
+            return !compiled.some((c) => c.match(key));
+        },
+        compare: (a, b) => {
+            for (const c of compiled) {
+                const matchA = c.match(a);
+                const matchB = c.match(b);
+                if (matchA && matchB) {
+                    if (c.sort === "alphabetical") {
+                        return a === b ? 0 : a < b ? -1 : 1;
+                    }
+                    return 0;
+                }
+                if (matchA) {
+                    return -1;
+                }
+                if (matchB) {
+                    return 1;
+                }
+            }
+            throw new Error("Illegal state");
+        },
+    };
+}
+function compileOption(option) {
+    const cache = {};
+    const compiled = compileOptionWithoutCache(option);
+    return {
+        match: (str) => {
+            if (cache[str] != null)
+                return cache[str];
+            return (cache[str] = compiled.match(str));
+        },
+        sort: compiled.sort,
+    };
+    function compileOptionWithoutCache(option) {
+        if (typeof option === "string") {
+            const match = compileMatcher([option]);
+            return { match, sort: "ignore" };
+        }
+        if (Array.isArray(option)) {
+            const match = compileMatcher(option);
+            return { match, sort: "ignore" };
+        }
+        const { match } = compileOptionWithoutCache(option.match);
+        return { match, sort: option.sort || "ignore" };
+    }
+}
+function compileMatcher(pattern) {
+    const rules = [];
+    for (const p of pattern) {
+        let negative, patternStr;
+        if (p.startsWith("!")) {
+            negative = true;
+            patternStr = p.substring(1);
+        }
+        else {
+            negative = false;
+            patternStr = p;
+        }
+        const regex = (0, regexp_1.toRegExp)(patternStr);
+        rules.push({ negative, match: (str) => regex.test(str) });
+    }
+    return (str) => {
+        let result = Boolean(rules[0]?.negative);
+        for (const { negative, match } of rules) {
+            if (result === !negative) {
+                continue;
+            }
+            if (match(str)) {
+                result = !negative;
+            }
+        }
+        return result;
+    };
+}
+exports.default = (0, utils_1.createRule)("sort-attributes", {
+    meta: {
+        docs: {
+            description: "enforce order of attributes",
+            category: "Stylistic Issues",
+            recommended: false,
+            conflictWithPrettier: false,
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    order: {
+                        type: "array",
+                        items: {
+                            anyOf: [
+                                { type: "string" },
+                                {
+                                    type: "array",
+                                    items: {
+                                        type: "string",
+                                    },
+                                    uniqueItems: true,
+                                    minItems: 1,
+                                },
+                                {
+                                    type: "object",
+                                    properties: {
+                                        match: {
+                                            anyOf: [
+                                                { type: "string" },
+                                                {
+                                                    type: "array",
+                                                    items: {
+                                                        type: "string",
+                                                    },
+                                                    uniqueItems: true,
+                                                    minItems: 1,
+                                                },
+                                            ],
+                                        },
+                                        sort: {
+                                            enum: ["alphabetical", "ignore"],
+                                        },
+                                    },
+                                    required: ["match", "sort"],
+                                    additionalProperties: false,
+                                },
+                            ],
+                        },
+                        uniqueItems: true,
+                        additionalItems: false,
+                    },
+                    alphabetical: { type: "boolean" },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            shouldBefore: "Attribute '{{currentKey}}' should go before '{{prevKey}}'.",
+        },
+        type: "layout",
+        fixable: "code",
+    },
+    create(context) {
+        const option = parseOption(context.options[0]);
+        const cacheKeyText = new Map();
+        function getKeyText(node) {
+            const k = cacheKeyText.get(node);
+            if (k != null)
+                return k;
+            const result = (0, ast_utils_1.getAttributeKeyText)(node);
+            cacheKeyText.set(node, result);
+            return result;
+        }
+        function report(node, previousNode) {
+            const currentKey = getKeyText(node);
+            const prevKey = getKeyText(previousNode);
+            context.report({
+                node,
+                messageId: "shouldBefore",
+                data: {
+                    currentKey,
+                    prevKey,
+                },
+                fix(fixer) {
+                    const attributes = node.parent.attributes;
+                    const previousNodes = attributes.slice(attributes.indexOf(previousNode), attributes.indexOf(node));
+                    const moveNodes = [node, ...previousNodes];
+                    const sourceCode = context.getSourceCode();
+                    return moveNodes.map((moveNode, index) => {
+                        const text = sourceCode.getText(moveNode);
+                        return fixer.replaceText(previousNodes[index] || node, text);
+                    });
+                },
+            });
+        }
+        function hasSpreadAttribute(node, previousNode) {
+            const attributes = node.parent.attributes;
+            const previousNodes = attributes.slice(attributes.indexOf(previousNode), attributes.indexOf(node));
+            return previousNodes.some((a) => a.type === "SvelteSpreadAttribute");
+        }
+        function verifyForSpreadAttributeExist(node) {
+            const previousNodes = [];
+            const attributes = node.parent.attributes;
+            for (const previousNode of attributes
+                .slice(0, attributes.indexOf(node))
+                .reverse()) {
+                if (previousNode.type === "SvelteSpreadAttribute") {
+                    break;
+                }
+                previousNodes.unshift(previousNode);
+            }
+            const key = getKeyText(node);
+            const invalidPreviousNode = previousNodes.find((previousNode) => {
+                const prevKey = getKeyText(previousNode);
+                if (option.ignore(prevKey)) {
+                    return false;
+                }
+                return option.compare(prevKey, key) > 0;
+            });
+            if (invalidPreviousNode) {
+                report(node, invalidPreviousNode);
+            }
+        }
+        return {
+            SvelteStartTag(node) {
+                const validPreviousNodes = [];
+                for (const attr of node.attributes) {
+                    if (attr.type === "SvelteSpreadAttribute") {
+                        continue;
+                    }
+                    const key = getKeyText(attr);
+                    if (option.ignore(key)) {
+                        continue;
+                    }
+                    const invalidPreviousNode = validPreviousNodes.find((previousNode) => option.compare(getKeyText(previousNode), key) > 0);
+                    if (invalidPreviousNode) {
+                        if (attr.type !== "SvelteAttribute" ||
+                            !hasSpreadAttribute(attr, invalidPreviousNode)) {
+                            report(attr, invalidPreviousNode);
+                        }
+                        else {
+                            verifyForSpreadAttributeExist(attr);
+                        }
+                        continue;
+                    }
+                    validPreviousNodes.push(attr);
+                }
+            },
+        };
+    },
+});

package/lib/types.d.ts

@@ -33,6 +33,7 @@ export interface RuleMetaData {
         [messageId: string]: string;
     };
     fixable?: "code" | "whitespace";
+    hasSuggestions?: boolean;
     schema: JSONSchema4 | JSONSchema4[];
     deprecated?: boolean;
     replacedBy?: string[];
@@ -59,6 +60,7 @@ export interface PartialRuleMetaData {
         [messageId: string]: string;
     };
     fixable?: "code" | "whitespace";
+    hasSuggestions?: boolean;
     schema: JSONSchema4 | JSONSchema4[];
     deprecated?: boolean;
     replacedBy?: string[];

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

@@ -46,3 +46,5 @@ 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 getDirectiveName(node: SvAST.SvelteDirective): string;

package/lib/utils/ast-utils.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-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.getDirectiveName = exports.getAttributeKeyText = exports.getMustacheTokens = exports.getAttributeValueQuoteAndRange = exports.getScope = exports.findVariable = exports.getLangValue = exports.getStaticAttributeValue = exports.findBindDirective = exports.findShorthandAttribute = exports.findAttribute = exports.isHTMLElementLike = exports.needParentheses = exports.getStringIfConstant = exports.equalTokens = void 0;
 const eslintUtils = __importStar(require("eslint-utils"));
 function equalTokens(left, right, sourceCode) {
     const tokensL = sourceCode.getTokens(left);
@@ -260,6 +260,47 @@ function getMustacheTokens(node, sourceCode) {
     };
 }
 exports.getMustacheTokens = getMustacheTokens;
+function getAttributeKeyText(node) {
+    switch (node.type) {
+        case "SvelteAttribute":
+        case "SvelteShorthandAttribute":
+            return node.key.name;
+        case "SvelteStyleDirective":
+            return `style:${node.key.name.name}`;
+        case "SvelteSpecialDirective":
+            return node.kind;
+        case "SvelteDirective": {
+            const dir = getDirectiveName(node);
+            return `${dir}:${node.key.name.name}${node.key.modifiers.length ? `|${node.key.modifiers.join("|")}` : ""}`;
+        }
+        default:
+            throw new Error(`Unknown node type: ${node.type}`);
+    }
+}
+exports.getAttributeKeyText = getAttributeKeyText;
+function getDirectiveName(node) {
+    switch (node.kind) {
+        case "Action":
+            return "use";
+        case "Animation":
+            return "animate";
+        case "Binding":
+            return "bind";
+        case "Class":
+            return "class";
+        case "EventHandler":
+            return "on";
+        case "Let":
+            return "let";
+        case "Transition":
+            return node.intro && node.outro ? "transition" : node.intro ? "in" : "out";
+        case "Ref":
+            return "ref";
+        default:
+            throw new Error("Unknown directive kind");
+    }
+}
+exports.getDirectiveName = getDirectiveName;
 function getAttributeValueRangeTokens(attr, sourceCode) {
     if (attr.type === "SvelteAttribute" || attr.type === "SvelteStyleDirective") {
         if (!attr.value.length) {

package/lib/utils/regexp.d.ts

@@ -1,2 +1,4 @@
-export declare function toRegExp(string: string): RegExp;
+export declare function toRegExp(string: string): {
+    test(s: string): boolean;
+};
 export declare function isRegExp(string: string): boolean;

package/lib/utils/regexp.js

@@ -1,20 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRegExp = exports.toRegExp = void 0;
-const RE_REGEXP_CHAR = /[$()*+.?[\\\]^{|}]/gu;
-const RE_HAS_REGEXP_CHAR = new RegExp(RE_REGEXP_CHAR.source);
 const RE_REGEXP_STR = /^\/(.+)\/([A-Za-z]*)$/u;
-function escape(string) {
-    return string && RE_HAS_REGEXP_CHAR.test(string)
-        ? string.replace(RE_REGEXP_CHAR, "\\$&")
-        : string;
-}
 function toRegExp(string) {
     const parts = RE_REGEXP_STR.exec(string);
     if (parts) {
         return new RegExp(parts[1], parts[2]);
     }
-    return new RegExp(`^${escape(string)}$`);
+    return { test: (s) => s === string };
 }
 exports.toRegExp = toRegExp;
 function isRegExp(string) {

package/lib/utils/rules.js

@@ -7,6 +7,7 @@ exports.rules = void 0;
 const button_has_type_1 = __importDefault(require("../rules/button-has-type"));
 const comment_directive_1 = __importDefault(require("../rules/comment-directive"));
 const first_attribute_linebreak_1 = __importDefault(require("../rules/first-attribute-linebreak"));
+const html_closing_bracket_spacing_1 = __importDefault(require("../rules/html-closing-bracket-spacing"));
 const html_quotes_1 = __importDefault(require("../rules/html-quotes"));
 const indent_1 = __importDefault(require("../rules/indent"));
 const max_attributes_per_line_1 = __importDefault(require("../rules/max-attributes-per-line"));
@@ -16,10 +17,13 @@ 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_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"));
 const no_object_in_text_mustaches_1 = __importDefault(require("../rules/no-object-in-text-mustaches"));
+const no_reactive_literals_1 = __importDefault(require("../rules/no-reactive-literals"));
 const no_shorthand_style_property_overrides_1 = __importDefault(require("../rules/no-shorthand-style-property-overrides"));
+const no_spaces_around_equal_signs_in_attribute_1 = __importDefault(require("../rules/no-spaces-around-equal-signs-in-attribute"));
 const no_target_blank_1 = __importDefault(require("../rules/no-target-blank"));
 const no_unknown_style_directive_property_1 = __importDefault(require("../rules/no-unknown-style-directive-property"));
 const no_unused_svelte_ignore_1 = __importDefault(require("../rules/no-unused-svelte-ignore"));
@@ -29,6 +33,7 @@ const prefer_style_directive_1 = __importDefault(require("../rules/prefer-style-
 const require_optimized_style_attribute_1 = __importDefault(require("../rules/require-optimized-style-attribute"));
 const shorthand_attribute_1 = __importDefault(require("../rules/shorthand-attribute"));
 const shorthand_directive_1 = __importDefault(require("../rules/shorthand-directive"));
+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"));
@@ -36,6 +41,7 @@ exports.rules = [
     button_has_type_1.default,
     comment_directive_1.default,
     first_attribute_linebreak_1.default,
+    html_closing_bracket_spacing_1.default,
     html_quotes_1.default,
     indent_1.default,
     max_attributes_per_line_1.default,
@@ -45,10 +51,13 @@ exports.rules = [
     no_dupe_else_if_blocks_1.default,
     no_dupe_style_properties_1.default,
     no_dynamic_slot_name_1.default,
+    no_extra_reactive_curlies_1.default,
     no_inner_declarations_1.default,
     no_not_function_handler_1.default,
     no_object_in_text_mustaches_1.default,
+    no_reactive_literals_1.default,
     no_shorthand_style_property_overrides_1.default,
+    no_spaces_around_equal_signs_in_attribute_1.default,
     no_target_blank_1.default,
     no_unknown_style_directive_property_1.default,
     no_unused_svelte_ignore_1.default,
@@ -58,6 +67,7 @@ exports.rules = [
     require_optimized_style_attribute_1.default,
     shorthand_attribute_1.default,
     shorthand_directive_1.default,
+    sort_attributes_1.default,
     spaced_html_comment_1.default,
     system_1.default,
     valid_compile_1.default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "2.2.0",
+  "version": "2.4.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",
@@ -43,7 +43,7 @@
     "prepublishOnly": "yarn clean && yarn build",
     "pretest:base": "cross-env DEBUG=eslint-plugin-svelte*",
     "preversion": "yarn test && git add .",
-    "svelte-kit": "node --experimental-loader ./svelte-kit-import-hook.mjs node_modules/vite/bin/vite.js --config vite.config.mjs",
+    "svelte-kit": "node --experimental-loader ./svelte-kit-import-hook.mjs node_modules/vite/bin/vite.js",
     "test": "yarn mocha \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
     "ts": "node -r esbuild-register",
     "update": "yarn ts ./tools/update.ts && yarn format-for-gen-file",
@@ -66,7 +66,7 @@
     "postcss-load-config": "^3.1.4",
     "postcss-safe-parser": "^6.0.0",
     "sourcemap-codec": "^1.4.8",
-    "svelte-eslint-parser": "^0.16.0"
+    "svelte-eslint-parser": "^0.17.0"
   },
   "devDependencies": {
     "@babel/core": "^7.16.0",
@@ -74,19 +74,25 @@
     "@babel/plugin-proposal-function-bind": "^7.16.7",
     "@babel/types": "^7.16.0",
     "@fontsource/fira-mono": "^4.5.0",
-    "@ota-meshi/eslint-plugin": "^0.11.0",
+    "@ota-meshi/eslint-plugin": "^0.11.3",
     "@sindresorhus/slugify": "^2.1.0",
     "@sveltejs/adapter-static": "^1.0.0-next.26",
     "@sveltejs/kit": "^1.0.0-next.360",
     "@types/babel__core": "^7.1.19",
+    "@types/cross-spawn": "^6.0.2",
+    "@types/escape-html": "^1.0.2",
     "@types/eslint": "^8.0.0",
     "@types/eslint-scope": "^3.7.0",
     "@types/eslint-visitor-keys": "^1.0.0",
-    "@types/estree": "^0.0.52",
+    "@types/estree": "^1.0.0",
     "@types/less": "^3.0.3",
+    "@types/markdown-it": "^12.2.3",
+    "@types/markdown-it-container": "^2.0.5",
+    "@types/markdown-it-emoji": "^2.0.2",
     "@types/mocha": "^9.0.0",
     "@types/node": "^16.0.0",
     "@types/postcss-safe-parser": "^5.0.1",
+    "@types/prismjs": "^1.26.0",
     "@types/stylus": "^0.48.38",
     "@typescript-eslint/eslint-plugin": "^5.4.0",
     "@typescript-eslint/parser": "^5.4.1-0",
@@ -99,16 +105,17 @@
     "eslint": "^8.0.0",
     "eslint-config-prettier": "^8.3.0",
     "eslint-plugin-eslint-comments": "^3.2.0",
-    "eslint-plugin-eslint-plugin": "^4.0.0",
-    "eslint-plugin-json-schema-validator": "^3.0.0",
+    "eslint-plugin-eslint-plugin": "^5.0.0",
+    "eslint-plugin-json-schema-validator": "^4.0.0",
     "eslint-plugin-jsonc": "^2.0.0",
-    "eslint-plugin-markdown": "^2.1.0",
+    "eslint-plugin-markdown": "^3.0.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-node-dependencies": "^0.9.0",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-regexp": "^1.0.0",
     "eslint-plugin-svelte": "^2.0.0",
     "eslint-plugin-yml": "^1.0.0",
+    "eslint-scope": "^7.1.1",
     "estree-walker": "^3.0.0",
     "less": "^4.1.2",
     "locate-character": "^2.0.5",
@@ -119,7 +126,6 @@
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "pako": "^2.0.3",
-    "pirates": "^4.0.1",
     "postcss-nested": "^5.0.6",
     "prettier": "^2.2.1",
     "prettier-plugin-pkg": "^0.16.0",
@@ -134,8 +140,8 @@
     "svelte": "^3.46.1",
     "svelte-adapter-ghpages": "0.0.2",
     "typescript": "^4.5.2",
-    "vite": "^2.9.13",
-    "vite-plugin-svelte-md": "^0.1.3"
+    "vite": "^3.0.0-0",
+    "vite-plugin-svelte-md": "^0.1.5"
   },
   "publishConfig": {
     "access": "public"