eslint-plugin-svelte 3.12.4 → 3.13.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.12.4";
+    version: "3.13.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.12.4";
+export declare const version: "3.13.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.12.4';
+export const version = '3.13.0';

package/lib/rules/no-navigation-without-resolve.js

@@ -30,10 +30,10 @@ export default createRule('no-navigation-without-resolve', {
             }
         ],
         messages: {
-            gotoWithoutResolve: "Found a goto() call with a url that isn't resolved.",
-            linkWithoutResolve: "Found a link with a url that isn't resolved.",
-            pushStateWithoutResolve: "Found a pushState() call with a url that isn't resolved.",
-            replaceStateWithoutResolve: "Found a replaceState() call with a url that isn't resolved."
+            gotoWithoutResolve: 'Unexpected goto() call without resolve().',
+            linkWithoutResolve: 'Unexpected href link without resolve().',
+            pushStateWithoutResolve: 'Unexpected pushState() call without resolve().',
+            replaceStateWithoutResolve: 'Unexpected replaceState() call without resolve().'
         },
         type: 'suggestion',
         conditions: [
@@ -44,29 +44,49 @@ export default createRule('no-navigation-without-resolve', {
     },
     create(context) {
         let resolveReferences = new Set();
+        const ignoreGoto = context.options[0]?.ignoreGoto ?? false;
+        const ignorePushState = context.options[0]?.ignorePushState ?? false;
+        const ignoreReplaceState = context.options[0]?.ignoreReplaceState ?? false;
+        const ignoreLinks = context.options[0]?.ignoreLinks ?? false;
         return {
             Program() {
                 const referenceTracker = new ReferenceTracker(context.sourceCode.scopeManager.globalScope);
                 resolveReferences = extractResolveReferences(referenceTracker, context);
                 const { goto: gotoCalls, pushState: pushStateCalls, replaceState: replaceStateCalls } = extractFunctionCallReferences(referenceTracker);
-                if (context.options[0]?.ignoreGoto !== true) {
+                if (!ignoreGoto) {
                     for (const gotoCall of gotoCalls) {
                         checkGotoCall(context, gotoCall, resolveReferences);
                     }
                 }
-                if (context.options[0]?.ignorePushState !== true) {
+                if (!ignorePushState) {
                     for (const pushStateCall of pushStateCalls) {
                         checkShallowNavigationCall(context, pushStateCall, resolveReferences, 'pushStateWithoutResolve');
                     }
                 }
-                if (context.options[0]?.ignoreReplaceState !== true) {
+                if (!ignoreReplaceState) {
                     for (const replaceStateCall of replaceStateCalls) {
                         checkShallowNavigationCall(context, replaceStateCall, resolveReferences, 'replaceStateWithoutResolve');
                     }
                 }
             },
+            SvelteShorthandAttribute(node) {
+                if (ignoreLinks ||
+                    node.parent.parent.type !== 'SvelteElement' ||
+                    node.parent.parent.kind !== 'html' ||
+                    node.parent.parent.name.type !== 'SvelteName' ||
+                    node.parent.parent.name.name !== 'a' ||
+                    node.key.name !== 'href' ||
+                    node.value.type !== 'Identifier') {
+                    return;
+                }
+                if (!expressionIsAbsolute(new FindVariableContext(context), node.value) &&
+                    !expressionIsFragment(new FindVariableContext(context), node.value) &&
+                    !isResolveCall(new FindVariableContext(context), node.value, resolveReferences)) {
+                    context.report({ loc: node.loc, messageId: 'linkWithoutResolve' });
+                }
+            },
             SvelteAttribute(node) {
-                if (context.options[0]?.ignoreLinks === true ||
+                if (ignoreLinks ||
                     node.parent.parent.type !== 'SvelteElement' ||
                     node.parent.parent.kind !== 'html' ||
                     node.parent.parent.name.type !== 'SvelteName' ||
@@ -75,9 +95,11 @@ export default createRule('no-navigation-without-resolve', {
                     return;
                 }
                 if ((node.value[0].type === 'SvelteLiteral' &&
+                    !expressionIsNullish(new FindVariableContext(context), node.value[0]) &&
                     !expressionIsAbsolute(new FindVariableContext(context), node.value[0]) &&
                     !expressionIsFragment(new FindVariableContext(context), node.value[0])) ||
                     (node.value[0].type === 'SvelteMustacheTag' &&
+                        !expressionIsNullish(new FindVariableContext(context), node.value[0].expression) &&
                         !expressionIsAbsolute(new FindVariableContext(context), node.value[0].expression) &&
                         !expressionIsFragment(new FindVariableContext(context), node.value[0].expression) &&
                         !isResolveCall(new FindVariableContext(context), node.value[0].expression, resolveReferences))) {
@@ -93,6 +115,9 @@ function extractResolveReferences(referenceTracker, context) {
     for (const { node } of referenceTracker.iterateEsmReferences({
         '$app/paths': {
             [ReferenceTracker.ESM]: true,
+            asset: {
+                [ReferenceTracker.READ]: true
+            },
             resolve: {
                 [ReferenceTracker.READ]: true
             }
@@ -192,6 +217,29 @@ function expressionIsEmpty(url) {
             url.quasis.length === 1 &&
             url.quasis[0].value.raw === ''));
 }
+function expressionIsNullish(ctx, url) {
+    switch (url.type) {
+        case 'Identifier':
+            return identifierIsNullish(ctx, url);
+        case 'Literal':
+            return url.value === null; // Undefined is an Identifier in ESTree, null is a Literal
+        default:
+            return false;
+    }
+}
+function identifierIsNullish(ctx, url) {
+    if (url.name === 'undefined') {
+        return true;
+    }
+    const variable = ctx.findVariable(url);
+    if (variable === null ||
+        variable.identifiers.length === 0 ||
+        variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
+        variable.identifiers[0].parent.init === null) {
+        return false;
+    }
+    return expressionIsNullish(ctx, variable.identifiers[0].parent.init);
+}
 function expressionIsAbsolute(ctx, url) {
     switch (url.type) {
         case 'BinaryExpression':

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

@@ -109,6 +109,7 @@ export default createRule('no-unused-props', {
          */
         function getPropertyPath(node) {
             const paths = [];
+            let isSpread = false;
             let currentNode = node;
             let parentNode = currentNode.parent ?? null;
             while (parentNode) {
@@ -120,14 +121,17 @@ export default createRule('no-unused-props', {
                     else if (property.type === 'Literal' && typeof property.value === 'string') {
                         paths.push(property.value);
                     }
-                    else {
-                        break;
+                }
+                else {
+                    if (parentNode.type === 'SpreadElement' || parentNode.type === 'SvelteSpreadAttribute') {
+                        isSpread = true;
                     }
+                    break;
                 }
                 currentNode = parentNode;
                 parentNode = currentNode.parent ?? null;
             }
-            return paths;
+            return { paths, isSpread };
         }
         /**
          * Finds all property access paths for a given variable.
@@ -135,18 +139,24 @@ export default createRule('no-unused-props', {
         function getUsedNestedPropertyPathsArray(node) {
             const variable = findVariable(context, node);
             if (!variable)
-                return [];
+                return { paths: [], spreadPaths: [] };
             const pathsArray = [];
+            const spreadPathsArray = [];
             for (const reference of variable.references) {
                 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);
-                    pathsArray.push(referencePath);
+                    const { paths, isSpread } = getPropertyPath(reference.identifier);
+                    if (isSpread) {
+                        spreadPathsArray.push(paths);
+                    }
+                    else {
+                        pathsArray.push(paths);
+                    }
                 }
             }
-            return pathsArray;
+            return { paths: pathsArray, spreadPaths: spreadPathsArray };
         }
         /**
          * Checks if a property is from TypeScript's built-in type definitions.
@@ -204,7 +214,7 @@ export default createRule('no-unused-props', {
         /**
          * Recursively checks for unused properties in a type.
          */
-        function checkUnusedProperties({ propsType, usedPropertyPaths, declaredPropertyNames, reportNode, parentPath, checkedPropsTypes, reportedPropertyPaths }) {
+        function checkUnusedProperties({ propsType, usedPropertyPaths, usedSpreadPropertyPaths, declaredPropertyNames, reportNode, parentPath, checkedPropsTypes, reportedPropertyPaths }) {
             // Skip checking if the type itself is a class
             if (isClassType(propsType))
                 return;
@@ -224,6 +234,7 @@ export default createRule('no-unused-props', {
                     checkUnusedProperties({
                         propsType: propsBaseType,
                         usedPropertyPaths,
+                        usedSpreadPropertyPaths,
                         declaredPropertyNames,
                         reportNode,
                         parentPath,
@@ -241,11 +252,14 @@ export default createRule('no-unused-props', {
                 if (shouldIgnoreProperty(propName))
                     continue;
                 const currentPath = [...parentPath, propName];
-                const currentPathStr = [...parentPath, propName].join('.');
+                const currentPathStr = currentPath.join('.');
                 if (reportedPropertyPaths.has(currentPathStr))
                     continue;
                 const propType = typeChecker.getTypeOfSymbol(prop);
-                const isUsedThisInPath = usedPropertyPaths.includes(currentPathStr);
+                const isUsedThisInPath = usedPropertyPaths.includes(currentPathStr) ||
+                    usedSpreadPropertyPaths.some((path) => {
+                        return path === '' || path === currentPathStr || path.startsWith(`${currentPathStr}.`);
+                    });
                 const isUsedInPath = usedPropertyPaths.some((path) => {
                     return path.startsWith(`${currentPathStr}.`);
                 });
@@ -274,6 +288,7 @@ export default createRule('no-unused-props', {
                     checkUnusedProperties({
                         propsType: propType,
                         usedPropertyPaths,
+                        usedSpreadPropertyPaths,
                         declaredPropertyNames,
                         reportNode,
                         parentPath: currentPath,
@@ -306,8 +321,6 @@ export default createRule('no-unused-props', {
         function normalizeUsedPaths(paths, allowUnusedNestedProperties) {
             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;
                 }
@@ -332,7 +345,8 @@ export default createRule('no-unused-props', {
                 if (!tsNode || !tsNode.type)
                     return;
                 const propsType = typeChecker.getTypeFromTypeNode(tsNode.type);
-                let usedPropertyPathsArray = [];
+                const usedPropertyPathsArray = [];
+                const usedSpreadPropertyPathsArray = [];
                 let declaredPropertyNames = new Set();
                 if (node.id.type === 'ObjectPattern') {
                     declaredPropertyNames = getUsedPropertyNamesFromPattern(node.id);
@@ -351,18 +365,25 @@ export default createRule('no-unused-props', {
                         }
                     }
                     for (const identifier of identifiers) {
-                        const paths = getUsedNestedPropertyPathsArray(identifier);
+                        const { paths, spreadPaths } = getUsedNestedPropertyPathsArray(identifier);
                         usedPropertyPathsArray.push(...paths.map((path) => [identifier.name, ...path]));
+                        usedSpreadPropertyPathsArray.push(...spreadPaths.map((path) => [identifier.name, ...path]));
                     }
                 }
                 else if (node.id.type === 'Identifier') {
-                    usedPropertyPathsArray = getUsedNestedPropertyPathsArray(node.id);
+                    const { paths, spreadPaths } = getUsedNestedPropertyPathsArray(node.id);
+                    usedPropertyPathsArray.push(...paths);
+                    usedSpreadPropertyPathsArray.push(...spreadPaths);
+                }
+                function runNormalizeUsedPaths(paths) {
+                    return normalizeUsedPaths(paths, options.allowUnusedNestedProperties).map((pathArray) => {
+                        return pathArray.join('.');
+                    });
                 }
                 checkUnusedProperties({
                     propsType,
-                    usedPropertyPaths: normalizeUsedPaths(usedPropertyPathsArray, options.allowUnusedNestedProperties).map((pathArray) => {
-                        return pathArray.join('.');
-                    }),
+                    usedPropertyPaths: runNormalizeUsedPaths(usedPropertyPathsArray),
+                    usedSpreadPropertyPaths: runNormalizeUsedPaths(usedSpreadPropertyPathsArray),
                     declaredPropertyNames,
                     reportNode: node.id,
                     parentPath: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "3.12.4",
+  "version": "3.13.0",
   "description": "ESLint plugin for Svelte using AST",
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
     "postcss-load-config": "^3.1.4",
     "postcss-safe-parser": "^7.0.0",
     "semver": "^7.6.3",
-    "svelte-eslint-parser": "^1.3.0"
+    "svelte-eslint-parser": "^1.4.0"
   },
   "devDependencies": {
     "@babel/core": "^7.28.3",
@@ -79,7 +79,7 @@
     "sass": "^1.92.0",
     "source-map-js": "^1.2.1",
     "stylus": "^0.64.0",
-    "svelte": "^5.38.6",
+    "svelte": "^5.41.0",
     "svelte-i18n": "^4.0.1",
     "tsx": "^4.20.5",
     "type-coverage": "^2.29.7",
@@ -108,7 +108,7 @@
     "debug": "pnpm run mocha \"tests/src/**/*.ts\" --reporter dot --timeout 60000",
     "lint": "run-p lint:*",
     "lint-fix": "pnpm run lint:es --fix",
-    "lint:es": "eslint --cache .",
+    "lint:es": "eslint --concurrency auto --cache .",
     "mocha": "pnpm run ts ./node_modules/mocha/bin/mocha.js",
     "new": "pnpm run ts ./tools/new-rule.ts",
     "prebuild": "pnpm run clean",