eslint-plugin-svelte 3.4.1 → 3.5.0

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

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

package/lib/rule-types.d.ts

@@ -547,6 +547,7 @@ type SvelteNoUnusedProps = [] | [
         checkImportedTypes?: boolean;
         ignoreTypePatterns?: string[];
         ignorePropertyPatterns?: string[];
+        allowUnusedNestedProperties?: boolean;
     }
 ];
 type SvelteNoUselessMustaches = [] | [

package/lib/rules/no-unnecessary-state-wrap.js

@@ -50,7 +50,11 @@ export default createRule('no-unnecessary-state-wrap', {
         const options = context.options[0] ?? {};
         const additionalReactiveClasses = options.additionalReactiveClasses ?? [];
         const allowReassign = options.allowReassign ?? false;
-        const referenceTracker = new ReferenceTracker(context.sourceCode.scopeManager.globalScope);
+        const { globalScope } = context.sourceCode.scopeManager;
+        if (globalScope == null) {
+            return {};
+        }
+        const referenceTracker = new ReferenceTracker(globalScope);
         const traceMap = {};
         for (const reactiveClass of REACTIVE_CLASSES) {
             traceMap[reactiveClass] = {
@@ -72,8 +76,10 @@ export default createRule('no-unnecessary-state-wrap', {
             };
         });
         function isReassigned(identifier) {
-            const variable = context.sourceCode.scopeManager.getDeclaredVariables(identifier.parent)[0];
-            return variable.references.some((ref) => {
+            const references = context.sourceCode.scopeManager
+                .getDeclaredVariables(identifier.parent)
+                .flatMap((v) => v.references);
+            return references.some((ref) => {
                 return ref.isWrite() && ref.identifier !== identifier;
             });
         }

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

@@ -31,6 +31,10 @@ export default createRule('no-unused-props', {
                             type: 'string'
                         },
                         default: []
+                    },
+                    allowUnusedNestedProperties: {
+                        type: 'boolean',
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -159,8 +163,15 @@ export default createRule('no-unused-props', {
         function getUsedPropertyNamesFromPattern(pattern) {
             const usedProps = new Set();
             for (const prop of pattern.properties) {
-                if (prop.type === 'Property' && prop.key.type === 'Identifier') {
-                    usedProps.add(prop.key.name);
+                if (prop.type === 'Property') {
+                    if (prop.key.type === 'Identifier') {
+                        usedProps.add({ originalName: prop.key.name, aliasName: prop.key.name });
+                    }
+                    else if (prop.key.type === 'Literal' &&
+                        typeof prop.key.value === 'string' &&
+                        prop.value.type === 'Identifier') {
+                        usedProps.add({ originalName: prop.key.value, aliasName: prop.value.name });
+                    }
                 }
                 else if (prop.type === 'RestElement') {
                     // If there's a rest element, all properties are potentially used
@@ -239,7 +250,9 @@ export default createRule('no-unused-props', {
                 if (isUsedThisInPath && !isUsedInPath) {
                     continue;
                 }
-                const isUsedInProps = declaredPropertyNames.has(propName);
+                const isUsedInProps = Array.from(declaredPropertyNames).some((p) => {
+                    return p.originalName === propName;
+                });
                 if (!isUsedInPath && !isUsedInProps) {
                     reportedPropertyPaths.add(currentPathStr);
                     context.report({
@@ -284,10 +297,10 @@ export default createRule('no-unused-props', {
          * Returns true if the destructuring pattern includes a rest element,
          * which means all remaining properties are potentially used.
          */
-        function hasRestElement(usedProps) {
-            return usedProps.size === 0;
+        function hasRestElement(declaredPropertyNames) {
+            return declaredPropertyNames.size === 0;
         }
-        function normalizeUsedPaths(paths) {
+        function normalizeUsedPaths(paths, allowUnusedNestedProperties) {
             const normalized = [];
             for (const path of paths.sort((a, b) => a.length - b.length)) {
                 if (path.length === 0)
@@ -297,7 +310,12 @@ export default createRule('no-unused-props', {
                 }
                 normalized.push(path);
             }
-            return normalized;
+            return normalized.map((path) => {
+                // If we allow unused nested properties, only return first level properties
+                if (allowUnusedNestedProperties)
+                    return [path[0]];
+                return path;
+            });
         }
         return {
             'VariableDeclaration > VariableDeclarator': (node) => {
@@ -339,7 +357,7 @@ export default createRule('no-unused-props', {
                 }
                 checkUnusedProperties({
                     propsType,
-                    usedPropertyPaths: normalizeUsedPaths(usedPropertyPathsArray).map((pathArray) => {
+                    usedPropertyPaths: normalizeUsedPaths(usedPropertyPathsArray, options.allowUnusedNestedProperties).map((pathArray) => {
                         return pathArray.join('.');
                     }),
                     declaredPropertyNames,

package/package.json

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