eslint-plugin-svelte 2.19.2 → 2.20.1

package/README.md

@@ -330,6 +330,7 @@ These rules relate to better ways of doing things to help you avoid problems:
 
 | Rule ID | Description |    |
 |:--------|:------------|:---|
+| [svelte/block-lang](https://ota-meshi.github.io/eslint-plugin-svelte/rules/block-lang/) | disallows the use of languages other than those specified in the configuration for the lang attribute of `<script>` and `<style>` blocks. |  |
 | [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-functions](https://ota-meshi.github.io/eslint-plugin-svelte/rules/no-reactive-functions/) | it's not necessary to define functions in reactive statements | :bulb: |

package/lib/rules/block-lang.d.ts

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

package/lib/rules/block-lang.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const ast_utils_1 = require("../utils/ast-utils");
+exports.default = (0, utils_1.createRule)("block-lang", {
+    meta: {
+        docs: {
+            description: "disallows the use of languages other than those specified in the configuration for the lang attribute of `<script>` and `<style>` blocks.",
+            category: "Best Practices",
+            recommended: false,
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    enforceScriptPresent: {
+                        type: "boolean",
+                    },
+                    enforceStylePresent: {
+                        type: "boolean",
+                    },
+                    script: {
+                        oneOf: [
+                            {
+                                type: ["string", "null"],
+                            },
+                            {
+                                type: "array",
+                                items: {
+                                    type: ["string", "null"],
+                                },
+                                minItems: 1,
+                            },
+                        ],
+                    },
+                    style: {
+                        oneOf: [
+                            {
+                                type: ["string", "null"],
+                            },
+                            {
+                                type: "array",
+                                items: {
+                                    type: ["string", "null"],
+                                },
+                                minItems: 1,
+                            },
+                        ],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {},
+        type: "suggestion",
+    },
+    create(context) {
+        if (!context.parserServices.isSvelte) {
+            return {};
+        }
+        const enforceScriptPresent = context.options[0]?.enforceScriptPresent ?? false;
+        const enforceStylePresent = context.options[0]?.enforceStylePresent ?? false;
+        const scriptOption = context.options[0]?.script ?? null;
+        const allowedScriptLangs = Array.isArray(scriptOption)
+            ? scriptOption
+            : [scriptOption];
+        let scriptLang = null;
+        let scriptNode = undefined;
+        const styleOption = context.options[0]?.style ?? null;
+        const allowedStyleLangs = Array.isArray(styleOption)
+            ? styleOption
+            : [styleOption];
+        let styleLang = null;
+        let styleNode = undefined;
+        return {
+            SvelteScriptElement(node) {
+                scriptNode = node;
+                scriptLang = (0, ast_utils_1.getLangValue)(node)?.toLowerCase() ?? null;
+            },
+            SvelteStyleElement(node) {
+                styleNode = node;
+                styleLang = (0, ast_utils_1.getLangValue)(node)?.toLowerCase() ?? null;
+            },
+            "Program:exit"() {
+                if (!allowedScriptLangs.includes(scriptLang)) {
+                    if (scriptNode !== undefined) {
+                        context.report({
+                            node: scriptNode,
+                            message: `The lang attribute of the <script> block should be ${prettyPrintLangs(allowedScriptLangs)}.`,
+                        });
+                    }
+                }
+                if (scriptNode === undefined && enforceScriptPresent) {
+                    context.report({
+                        loc: { line: 1, column: 1 },
+                        message: `The <script> block should be present and its lang attribute should be ${prettyPrintLangs(allowedScriptLangs)}.`,
+                    });
+                }
+                if (!allowedStyleLangs.includes(styleLang)) {
+                    if (styleNode !== undefined) {
+                        context.report({
+                            node: styleNode,
+                            message: `The lang attribute of the <style> block should be ${prettyPrintLangs(allowedStyleLangs)}.`,
+                        });
+                    }
+                }
+                if (styleNode === undefined && enforceStylePresent) {
+                    context.report({
+                        loc: { line: 1, column: 1 },
+                        message: `The <style> block should be present and its lang attribute should be ${prettyPrintLangs(allowedStyleLangs)}.`,
+                    });
+                }
+            },
+        };
+    },
+});
+function prettyPrintLangs(langs) {
+    const hasNull = langs.includes(null);
+    const nonNullLangs = langs
+        .filter((lang) => lang !== null)
+        .map((lang) => `"${lang}"`);
+    if (nonNullLangs.length === 0) {
+        return "omitted";
+    }
+    const hasNullText = hasNull ? "either omitted or " : "";
+    const nonNullText = nonNullLangs.length === 1
+        ? nonNullLangs[0]
+        : `one of ${nonNullLangs.join(", ")}`;
+    return hasNullText + nonNullText;
+}

package/lib/utils/rules.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rules = void 0;
 const no_unnecessary_condition_1 = __importDefault(require("../rules/@typescript-eslint/no-unnecessary-condition"));
+const block_lang_1 = __importDefault(require("../rules/block-lang"));
 const button_has_type_1 = __importDefault(require("../rules/button-has-type"));
 const comment_directive_1 = __importDefault(require("../rules/comment-directive"));
 const derived_has_same_inputs_outputs_1 = __importDefault(require("../rules/derived-has-same-inputs-outputs"));
@@ -58,6 +59,7 @@ const valid_compile_1 = __importDefault(require("../rules/valid-compile"));
 const valid_prop_names_in_kit_pages_1 = __importDefault(require("../rules/valid-prop-names-in-kit-pages"));
 exports.rules = [
     no_unnecessary_condition_1.default,
+    block_lang_1.default,
     button_has_type_1.default,
     comment_directive_1.default,
     derived_has_same_inputs_outputs_1.default,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "2.19.2",
+  "version": "2.20.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",