eslint-plugin-svelte 2.1.1 → 2.3.1

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
 
@@ -83,6 +83,7 @@ This plugin provides configs:
 
 - `plugin:svelte/base` ... Configuration to enable correct Svelte parsing.
 - `plugin:svelte/recommended` ... Above, plus rules to prevent errors or unintended behavior.
+- `plugin:svelte/prettier` ... Turn off rules that may conflict with [Prettier](https://prettier.io/) ([prettier-plugin-svelte](https://github.com/sveltejs/prettier-plugin-svelte)).
 
 See [the rule list](https://ota-meshi.github.io/eslint-plugin-svelte/rules/) to get the `rules` that this plugin provides.
 
@@ -291,10 +292,12 @@ 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-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: |
@@ -333,7 +336,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
 
@@ -360,7 +365,7 @@ If you want to test only one rule, run the following command (for `indent` rule)
 yarn test -g indent
 ```
 
-Take https://stackoverflow.com/questions/10832031/how-to-run-a-single-test-with-mocha as reference for details.
+Take <https://stackoverflow.com/questions/10832031/how-to-run-a-single-test-with-mocha> as reference for details.
 
 If you want to test only `my-test-input.svelte`, add `my-test-config.json` and save `{"only": true}`.  
 (Note that `{"only": true}` must be removed before making a pull request.)

package/lib/configs/prettier.d.ts

@@ -0,0 +1,15 @@
+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;
+    };
+};
+export = _default;

package/lib/configs/prettier.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const path_1 = __importDefault(require("path"));
+const base = require.resolve("./base");
+const baseExtend = path_1.default.extname(`${base}`) === ".ts" ? "plugin:svelte/base" : base;
+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

@@ -33,6 +33,20 @@ declare const _default: {
                 "svelte/valid-compile": string;
             };
         };
+        prettier: {
+            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;
+            };
+        };
     };
     rules: {
         [key: string]: RuleModule;

package/lib/index.js

@@ -28,10 +28,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 const rules_1 = require("./utils/rules");
 const base_1 = __importDefault(require("./configs/base"));
 const recommended_1 = __importDefault(require("./configs/recommended"));
+const prettier_1 = __importDefault(require("./configs/prettier"));
 const processor = __importStar(require("./processor"));
 const configs = {
     base: base_1.default,
     recommended: recommended_1.default,
+    prettier: prettier_1.default,
 };
 const rules = rules_1.rules.reduce((obj, r) => {
     obj[r.meta.docs.ruleName] = r;

package/lib/rules/button-has-type.js

@@ -35,8 +35,12 @@ exports.default = (0, utils_1.createRule)("button-has-type", {
         type: "suggestion",
     },
     create(context) {
-        var _a;
-        const configuration = Object.assign({ button: true, submit: true, reset: true }, ((_a = context.options[0]) !== null && _a !== void 0 ? _a : {}));
+        const configuration = {
+            button: true,
+            submit: true,
+            reset: true,
+            ...(context.options[0] ?? {}),
+        };
         function isButtonType(type) {
             return type === "button" || type === "submit" || type === "reset";
         }

package/lib/rules/first-attribute-linebreak.js

@@ -7,6 +7,7 @@ exports.default = (0, utils_1.createRule)("first-attribute-linebreak", {
             description: "enforce the location of first attribute",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: true,
         },
         fixable: "whitespace",
         schema: [
@@ -26,9 +27,8 @@ exports.default = (0, utils_1.createRule)("first-attribute-linebreak", {
         type: "layout",
     },
     create(context) {
-        var _a, _b;
-        const multiline = ((_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.multiline) || "below";
-        const singleline = ((_b = context.options[0]) === null || _b === void 0 ? void 0 : _b.singleline) || "beside";
+        const multiline = context.options[0]?.multiline || "below";
+        const singleline = context.options[0]?.singleline || "beside";
         const sourceCode = context.getSourceCode();
         function report(firstAttribute, location) {
             context.report({

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/html-quotes.js

@@ -18,6 +18,7 @@ exports.default = (0, utils_1.createRule)("html-quotes", {
             description: "enforce quotes style of HTML attributes",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: true,
         },
         fixable: "code",
         schema: [
@@ -45,13 +46,12 @@ exports.default = (0, utils_1.createRule)("html-quotes", {
         type: "layout",
     },
     create(context) {
-        var _a, _b, _c, _d, _e, _f;
         const sourceCode = context.getSourceCode();
-        const preferQuote = (_b = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.prefer) !== null && _b !== void 0 ? _b : "double";
-        const dynamicQuote = ((_d = (_c = context.options[0]) === null || _c === void 0 ? void 0 : _c.dynamic) === null || _d === void 0 ? void 0 : _d.quoted)
+        const preferQuote = context.options[0]?.prefer ?? "double";
+        const dynamicQuote = context.options[0]?.dynamic?.quoted
             ? preferQuote
             : "unquoted";
-        const avoidInvalidUnquotedInHTML = Boolean((_f = (_e = context.options[0]) === null || _e === void 0 ? void 0 : _e.dynamic) === null || _f === void 0 ? void 0 : _f.avoidInvalidUnquotedInHTML);
+        const avoidInvalidUnquotedInHTML = Boolean(context.options[0]?.dynamic?.avoidInvalidUnquotedInHTML);
         function canBeUnquotedInHTML(text) {
             return !/[\s"'<=>`]/u.test(text);
         }

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

@@ -9,6 +9,7 @@ export declare type MaybeNode = {
 };
 export declare type IndentOptions = {
     indentChar: " " | "\t";
+    indentScript: boolean;
     indentSize: number;
     switchCase: number;
     alignAttributesVertically: boolean;

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

@@ -729,7 +729,10 @@ function defineVisitor(context) {
         },
     };
     const v = visitor;
-    return Object.assign(Object.assign({}, v), commonVisitor);
+    return {
+        ...v,
+        ...commonVisitor,
+    };
 }
 exports.defineVisitor = defineVisitor;
 function getParent(node) {

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

@@ -31,7 +31,15 @@ const ast_1 = require("./ast");
 const eslint_utils_1 = require("eslint-utils");
 const offset_context_1 = require("./offset-context");
 function parseOptions(options, defaultOptions) {
-    const ret = Object.assign({ indentChar: " ", indentSize: 2, switchCase: 1, alignAttributesVertically: false, ignoredNodes: [] }, defaultOptions);
+    const ret = {
+        indentChar: " ",
+        indentScript: true,
+        indentSize: 2,
+        switchCase: 1,
+        alignAttributesVertically: false,
+        ignoredNodes: [],
+        ...defaultOptions,
+    };
     if (Number.isSafeInteger(options.indent)) {
         ret.indentSize = Number(options.indent);
     }
@@ -39,6 +47,9 @@ function parseOptions(options, defaultOptions) {
         ret.indentChar = "\t";
         ret.indentSize = 1;
     }
+    if (typeof options.indentScript === "boolean") {
+        ret.indentScript = options.indentScript;
+    }
     if (options.switchCase != null && Number.isSafeInteger(options.switchCase)) {
         ret.switchCase = options.switchCase;
     }
@@ -152,7 +163,11 @@ function defineVisitor(context, defaultOptions) {
         options,
         offsets,
     };
-    const nodesVisitor = Object.assign(Object.assign(Object.assign({}, ES.defineVisitor(indentContext)), SV.defineVisitor(indentContext)), TS.defineVisitor(indentContext));
+    const nodesVisitor = {
+        ...ES.defineVisitor(indentContext),
+        ...SV.defineVisitor(indentContext),
+        ...TS.defineVisitor(indentContext),
+    };
     const knownNodes = new Set(Object.keys(nodesVisitor));
     function compositingIgnoresVisitor(visitor) {
         for (const ignoreSelector of options.ignoredNodes) {
@@ -171,7 +186,9 @@ function defineVisitor(context, defaultOptions) {
         }
         return visitor;
     }
-    return compositingIgnoresVisitor(Object.assign(Object.assign({}, nodesVisitor), { "*:exit"(node) {
+    return compositingIgnoresVisitor({
+        ...nodesVisitor,
+        "*:exit"(node) {
             if (!knownNodes.has(node.type)) {
                 offsets.ignore(node);
             }
@@ -218,6 +235,7 @@ function defineVisitor(context, defaultOptions) {
                     };
                 }
             }
-        } }));
+        },
+    });
 }
 exports.defineVisitor = defineVisitor;

package/lib/rules/indent-helpers/offset-context.js

@@ -126,9 +126,8 @@ class OffsetContext {
         }
     }
     ignore(node) {
-        var _a;
         const range = node.range;
-        const n = (_a = this.ignoreRanges.get(range[0])) !== null && _a !== void 0 ? _a : 0;
+        const n = this.ignoreRanges.get(range[0]) ?? 0;
         this.ignoreRanges.set(range[0], Math.max(n, range[1]));
     }
     getOffsetCalculator() {
@@ -183,13 +182,12 @@ class OffsetCalculator {
         return null;
     }
     saveExpectedIndent(tokens, expectedIndent) {
-        var _a;
         for (const token of tokens) {
             const offsetInfo = this.offsets.get(token.range[0]);
             if (offsetInfo == null) {
                 continue;
             }
-            offsetInfo.expectedIndent = (_a = offsetInfo.expectedIndent) !== null && _a !== void 0 ? _a : expectedIndent;
+            offsetInfo.expectedIndent = offsetInfo.expectedIndent ?? expectedIndent;
         }
     }
 }

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

@@ -10,7 +10,7 @@ function defineVisitor(context) {
     const { sourceCode, offsets, options } = context;
     const visitor = {
         SvelteScriptElement(node) {
-            offsets.setOffsetElementList(node.body, node.startTag, node.endTag, 1);
+            offsets.setOffsetElementList(node.body, node.startTag, node.endTag, options.indentScript ? 1 : 0);
         },
         SvelteStyleElement(node) {
             node.children.forEach((n) => offsets.ignore(n));

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

@@ -542,7 +542,7 @@ function defineVisitor(context) {
             }
             if (decorators[0] === node) {
                 if (parent.range[0] === node.range[0]) {
-                    const startParentToken = sourceCode.getTokenAfter(decorators[(decorators === null || decorators === void 0 ? void 0 : decorators.length) - 1]);
+                    const startParentToken = sourceCode.getTokenAfter(decorators[decorators?.length - 1]);
                     offsets.setOffsetToken(startParentToken, 0, atToken);
                 }
                 else {
@@ -730,6 +730,11 @@ function defineVisitor(context) {
         },
     };
     const v = visitor;
-    return Object.assign(Object.assign(Object.assign(Object.assign({}, v), commonsVisitor), extendsESVisitor), deprecatedVisitor);
+    return {
+        ...v,
+        ...commonsVisitor,
+        ...extendsESVisitor,
+        ...deprecatedVisitor,
+    };
 }
 exports.defineVisitor = defineVisitor;

package/lib/rules/indent.js

@@ -8,6 +8,7 @@ exports.default = (0, utils_1.createRule)("indent", {
             description: "enforce consistent indentation",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: true,
         },
         fixable: "whitespace",
         schema: [
@@ -17,6 +18,7 @@ exports.default = (0, utils_1.createRule)("indent", {
                     indent: {
                         anyOf: [{ type: "integer", minimum: 1 }, { enum: ["tab"] }],
                     },
+                    indentScript: { type: "boolean" },
                     switchCase: { type: "integer", minimum: 0 },
                     alignAttributesVertically: { type: "boolean" },
                     ignoredNodes: {

package/lib/rules/max-attributes-per-line.js

@@ -5,10 +5,9 @@ function isSingleLine(node) {
     return node.loc.start.line === node.loc.end.line;
 }
 function groupAttributesByLine(attributes) {
-    var _a, _b;
     const group = [];
     for (const attr of attributes) {
-        if (((_b = (_a = group[0]) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.loc.end.line) === attr.loc.start.line) {
+        if (group[0]?.[0]?.loc.end.line === attr.loc.start.line) {
             group[0].push(attr);
         }
         else {
@@ -23,6 +22,7 @@ exports.default = (0, utils_1.createRule)("max-attributes-per-line", {
             description: "enforce the maximum number of attributes per line",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: true,
         },
         fixable: "whitespace",
         schema: [
@@ -47,9 +47,8 @@ exports.default = (0, utils_1.createRule)("max-attributes-per-line", {
         type: "layout",
     },
     create(context) {
-        var _a, _b, _c, _d;
-        const multilineMaximum = (_b = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.multiline) !== null && _b !== void 0 ? _b : 1;
-        const singlelineMaximum = (_d = (_c = context.options[0]) === null || _c === void 0 ? void 0 : _c.singleline) !== null && _d !== void 0 ? _d : 1;
+        const multilineMaximum = context.options[0]?.multiline ?? 1;
+        const singlelineMaximum = context.options[0]?.singleline ?? 1;
         const sourceCode = context.getSourceCode();
         function report(attribute) {
             if (!attribute) {

package/lib/rules/mustache-spacing.js

@@ -5,14 +5,13 @@ const utils_1 = require("../utils");
 const ast_utils_1 = require("../utils/ast-utils");
 const VALUE_SCHEMA = { enum: ["never", "always"] };
 function parseOptions(options) {
-    var _a, _b;
     return {
-        textExpressions: (options === null || options === void 0 ? void 0 : options.textExpressions) || "never",
-        attributesAndProps: (options === null || options === void 0 ? void 0 : options.attributesAndProps) || "never",
-        directiveExpressions: (options === null || options === void 0 ? void 0 : options.directiveExpressions) || "never",
+        textExpressions: options?.textExpressions || "never",
+        attributesAndProps: options?.attributesAndProps || "never",
+        directiveExpressions: options?.directiveExpressions || "never",
         tags: {
-            openingBrace: ((_a = options === null || options === void 0 ? void 0 : options.tags) === null || _a === void 0 ? void 0 : _a.openingBrace) || "never",
-            closingBrace: ((_b = options === null || options === void 0 ? void 0 : options.tags) === null || _b === void 0 ? void 0 : _b.closingBrace) || "never",
+            openingBrace: options?.tags?.openingBrace || "never",
+            closingBrace: options?.tags?.closingBrace || "never",
         },
     };
 }
@@ -22,6 +21,7 @@ exports.default = (0, utils_1.createRule)("mustache-spacing", {
             description: "enforce unified spacing in mustache",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: true,
         },
         fixable: "code",
         schema: [

package/lib/rules/no-inner-declarations.js

@@ -22,8 +22,7 @@ exports.default = (0, utils_1.createRule)("no-inner-declarations", {
                 return (0, eslint_core_1.buildProxyListener)(coreListener, (node) => {
                     return (0, eslint_core_1.getProxyNode)(node, {
                         get parent() {
-                            var _a;
-                            if (((_a = node.parent) === null || _a === void 0 ? void 0 : _a.type) === "SvelteScriptElement") {
+                            if (node.parent?.type === "SvelteScriptElement") {
                                 return node.parent.parent;
                             }
                             return node.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-unknown-style-directive-property.js

@@ -34,11 +34,10 @@ exports.default = (0, utils_1.createRule)("no-unknown-style-directive-property",
         type: "problem",
     },
     create(context) {
-        var _a, _b, _c, _d;
         const ignoreProperties = [
-            ...((_b = (_a = context.options[0]) === null || _a === void 0 ? void 0 : _a.ignoreProperties) !== null && _b !== void 0 ? _b : []),
+            ...(context.options[0]?.ignoreProperties ?? []),
         ].map(regexp_1.toRegExp);
-        const ignorePrefixed = (_d = (_c = context.options[0]) === null || _c === void 0 ? void 0 : _c.ignorePrefixed) !== null && _d !== void 0 ? _d : true;
+        const ignorePrefixed = context.options[0]?.ignorePrefixed ?? true;
         const knownProperties = new Set(known_css_properties_1.all);
         function validName(name) {
             return (name.startsWith("--") ||

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/prefer-class-directive.js

@@ -8,6 +8,7 @@ exports.default = (0, utils_1.createRule)("prefer-class-directive", {
             description: "require class directives instead of ternary expressions",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: false,
         },
         fixable: "code",
         schema: [],
@@ -39,7 +40,10 @@ exports.default = (0, utils_1.createRule)("prefer-class-directive", {
                         return false;
                     }
                     for (const [expr, str] of sub) {
-                        result.set(Object.assign(Object.assign({}, key), { chains: expr }), str);
+                        result.set({
+                            ...key,
+                            chains: expr,
+                        }, str);
                     }
                 }
                 else {

package/lib/rules/prefer-style-directive.js

@@ -12,6 +12,7 @@ exports.default = (0, utils_1.createRule)("prefer-style-directive", {
             description: "require style directives instead of style attribute",
             category: "Stylistic Issues",
             recommended: false,
+            conflictWithPrettier: false,
         },
         fixable: "code",
         schema: [],

package/lib/rules/require-optimized-style-attribute.js

@@ -30,8 +30,7 @@ exports.default = (0, utils_1.createRule)("require-optimized-style-attribute", {
                 });
             },
             SvelteAttribute(node) {
-                var _a;
-                if (node.key.name !== "style" || !((_a = node.value) === null || _a === void 0 ? void 0 : _a.length)) {
+                if (node.key.name !== "style" || !node.value?.length) {
                     return;
                 }
                 const root = (0, css_utils_1.parseStyleAttributeValue)(node, context);