eslint-plugin-svelte 3.8.1 → 3.8.2

package/lib/main.d.ts

@@ -14,7 +14,7 @@ export declare const configs: {
 export declare const rules: Record<string, Rule.RuleModule>;
 export declare const meta: {
     name: "eslint-plugin-svelte";
-    version: "3.8.1";
+    version: "3.8.2";
 };
 export declare const processors: {
     '.svelte': typeof processor;

package/lib/meta.d.ts

@@ -1,2 +1,2 @@
 export declare const name: "eslint-plugin-svelte";
-export declare const version: "3.8.1";
+export declare const version: "3.8.2";

package/lib/meta.js

@@ -2,4 +2,4 @@
 // This file has been automatically generated,
 // in order to update its content execute "pnpm run update"
 export const name = 'eslint-plugin-svelte';
-export const version = '3.8.1';
+export const version = '3.8.2';

package/lib/rules/consistent-selector-style.js

@@ -1,6 +1,7 @@
 import { findClassesInAttribute } from '../utils/ast-utils.js';
 import { extractExpressionPrefixLiteral, extractExpressionSuffixLiteral } from '../utils/expression-affixes.js';
 import { createRule } from '../utils/index.js';
+import { ElementOccurenceCount, elementOccurrenceCount } from '../utils/element-occurences.js';
 export default createRule('consistent-selector-style', {
     meta: {
         docs: {
@@ -108,7 +109,7 @@ export default createRule('consistent-selector-style', {
                 if (styleValue === 'class') {
                     return;
                 }
-                if (styleValue === 'id' && canUseIdSelector(selection)) {
+                if (styleValue === 'id' && canUseIdSelector(selection.map(([elem]) => elem))) {
                     context.report({
                         messageId: 'classShouldBeId',
                         loc: styleSelectorNodeLoc(node)
@@ -243,10 +244,10 @@ function addToArrayMap(map, key, value) {
  * Finds all nodes in selections that could be matched by key
  */
 function matchSelection(selections, key) {
-    const selection = selections.exact.get(key) ?? [];
+    const selection = (selections.exact.get(key) ?? []).map((elem) => [elem, true]);
     selections.affixes.forEach((nodes, [prefix, suffix]) => {
         if ((prefix === null || key.startsWith(prefix)) && (suffix === null || key.endsWith(suffix))) {
-            selection.push(...nodes);
+            selection.push(...nodes.map((elem) => [elem, false]));
         }
     });
     return selection;
@@ -255,22 +256,28 @@ function matchSelection(selections, key) {
  * Checks whether a given selection could be obtained using an ID selector
  */
 function canUseIdSelector(selection) {
-    return selection.length <= 1;
+    return (selection.length === 0 ||
+        (selection.length === 1 &&
+            elementOccurrenceCount(selection[0]) !== ElementOccurenceCount.ZeroToInf));
 }
 /**
  * Checks whether a given selection could be obtained using a type selector
  */
 function canUseTypeSelector(selection, typeSelections) {
-    const types = new Set(selection.map((node) => node.name.name));
+    const types = new Set(selection.map(([node]) => node.name.name));
     if (types.size > 1) {
         return false;
     }
     if (types.size < 1) {
         return true;
     }
+    if (selection.some(([elem, exact]) => !exact && elementOccurrenceCount(elem) === ElementOccurenceCount.ZeroToInf)) {
+        return false;
+    }
     const type = [...types][0];
     const typeSelection = typeSelections.get(type);
-    return typeSelection !== undefined && arrayEquals(typeSelection, selection);
+    return (typeSelection !== undefined &&
+        arrayEquals(typeSelection, selection.map(([elem]) => elem)));
 }
 /**
  * Compares two arrays for item equality

package/lib/utils/element-occurences.d.ts

@@ -0,0 +1,7 @@
+import type { AST } from 'svelte-eslint-parser';
+export declare enum ElementOccurenceCount {
+    ZeroOrOne = 0,
+    One = 1,
+    ZeroToInf = 2
+}
+export declare function elementOccurrenceCount(element: AST.SvelteHTMLNode): ElementOccurenceCount;

package/lib/utils/element-occurences.js

@@ -0,0 +1,43 @@
+export var ElementOccurenceCount;
+(function (ElementOccurenceCount) {
+    ElementOccurenceCount[ElementOccurenceCount["ZeroOrOne"] = 0] = "ZeroOrOne";
+    ElementOccurenceCount[ElementOccurenceCount["One"] = 1] = "One";
+    ElementOccurenceCount[ElementOccurenceCount["ZeroToInf"] = 2] = "ZeroToInf";
+})(ElementOccurenceCount || (ElementOccurenceCount = {}));
+function multiplyCounts(left, right) {
+    if (left === ElementOccurenceCount.One) {
+        return right;
+    }
+    if (right === ElementOccurenceCount.One) {
+        return left;
+    }
+    if (left === right) {
+        return left;
+    }
+    return ElementOccurenceCount.ZeroToInf;
+}
+function childElementOccurenceCount(parent) {
+    if (parent === null) {
+        return ElementOccurenceCount.One;
+    }
+    if ([
+        'SvelteIfBlock',
+        'SvelteElseBlock',
+        'SvelteAwaitBlock',
+        'SvelteAwaitPendingBlock',
+        'SvelteAwaitThenBlock',
+        'SvelteAwaitCatchBlock'
+    ].includes(parent.type)) {
+        return ElementOccurenceCount.ZeroOrOne;
+    }
+    if (['SvelteEachBlock', 'SvelteSnippetBlock'].includes(parent.type) ||
+        (parent.type === 'SvelteElement' && parent.kind === 'component')) {
+        return ElementOccurenceCount.ZeroToInf;
+    }
+    return ElementOccurenceCount.One;
+}
+export function elementOccurrenceCount(element) {
+    const parentCount = element.parent !== null ? elementOccurrenceCount(element.parent) : ElementOccurenceCount.One;
+    const parentChildCount = childElementOccurenceCount(element.parent);
+    return multiplyCounts(parentCount, parentChildCount);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "3.8.1",
+  "version": "3.8.2",
   "description": "ESLint plugin for Svelte using AST",
   "repository": "git+https://github.com/sveltejs/eslint-plugin-svelte.git",
   "homepage": "https://sveltejs.github.io/eslint-plugin-svelte",