eslint-plugin-svelte 3.3.1 → 3.3.3

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.3.1";
+    version: "3.3.3";
 };
 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.3.1";
+export declare const version = "3.3.3";

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.3.1';
+export const version = '3.3.3';

package/lib/rules/no-unused-props.js

@@ -133,7 +133,10 @@ export default createRule('no-unused-props', {
                 return [];
             const paths = [];
             for (const reference of variable.references) {
-                if ('identifier' in reference && reference.identifier.type === 'Identifier') {
+                if ('identifier' in reference &&
+                    reference.identifier.type === 'Identifier' &&
+                    (reference.identifier.range[0] !== node.range[0] ||
+                        reference.identifier.range[1] !== node.range[1])) {
                     const referencePath = getPropertyPath(reference.identifier);
                     paths.push(referencePath);
                 }
@@ -222,10 +225,14 @@ export default createRule('no-unused-props', {
                 if (reportedProps.has(currentPathStr))
                     continue;
                 const propType = typeChecker.getTypeOfSymbol(prop);
-                const isUsedInPath = usedPaths.some((path) => {
-                    const usedPath = path.join('.');
-                    return usedPath === currentPathStr || usedPath.startsWith(`${currentPathStr}.`);
+                const joinedUsedPaths = usedPaths.map((path) => path.join('.'));
+                const isUsedThisInPath = joinedUsedPaths.includes(currentPathStr);
+                const isUsedInPath = joinedUsedPaths.some((path) => {
+                    return path.startsWith(`${currentPathStr}.`);
                 });
+                if (isUsedThisInPath && !isUsedInPath) {
+                    continue;
+                }
                 const isUsedInProps = usedProps.has(propName);
                 if (!isUsedInPath && !isUsedInProps) {
                     reportedProps.add(currentPathStr);
@@ -237,9 +244,10 @@ export default createRule('no-unused-props', {
                             parent: parentPath.join('.')
                         }
                     });
+                    continue;
                 }
-                const isUsedNested = usedPaths.some((path) => {
-                    return path.join('.').startsWith(`${currentPathStr}.`);
+                const isUsedNested = joinedUsedPaths.some((path) => {
+                    return path.startsWith(`${currentPathStr}.`);
                 });
                 if (isUsedNested || isUsedInProps) {
                     checkUnusedProperties(propType, usedPaths, usedProps, reportNode, currentPath, checkedTypes, reportedProps);
@@ -265,6 +273,18 @@ export default createRule('no-unused-props', {
         function hasRestElement(usedProps) {
             return usedProps.size === 0;
         }
+        function normalizeUsedPaths(paths) {
+            const normalized = [];
+            for (const path of paths.sort((a, b) => a.length - b.length)) {
+                if (path.length === 0)
+                    continue;
+                if (normalized.some((p) => p.every((part, idx) => part === path[idx]))) {
+                    continue;
+                }
+                normalized.push(path);
+            }
+            return normalized;
+        }
         return {
             'VariableDeclaration > VariableDeclarator': (node) => {
                 // Only check $props declarations
@@ -283,10 +303,18 @@ export default createRule('no-unused-props', {
                     usedProps = getUsedPropertiesFromPattern(node.id);
                     if (usedProps.size === 0)
                         return;
-                    const identifiers = node.id.properties
-                        .filter((p) => p.type === 'Property')
-                        .map((p) => p.value)
-                        .filter((v) => v.type === 'Identifier');
+                    const identifiers = [];
+                    for (const p of node.id.properties) {
+                        if (p.type !== 'Property') {
+                            continue;
+                        }
+                        if (p.value.type === 'Identifier') {
+                            identifiers.push(p.value);
+                        }
+                        else if (p.value.type === 'AssignmentPattern' && p.value.left.type === 'Identifier') {
+                            identifiers.push(p.value.left);
+                        }
+                    }
                     for (const identifier of identifiers) {
                         const paths = getUsedNestedPropertyNames(identifier);
                         usedPaths.push(...paths.map((path) => [identifier.name, ...path]));
@@ -295,7 +323,7 @@ export default createRule('no-unused-props', {
                 else if (node.id.type === 'Identifier') {
                     usedPaths = getUsedNestedPropertyNames(node.id);
                 }
-                checkUnusedProperties(propType, usedPaths, usedProps, node.id, [], new Set(), new Set());
+                checkUnusedProperties(propType, normalizeUsedPaths(usedPaths), usedProps, node.id, [], new Set(), new Set());
             }
         };
     }

package/package.json

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