eslint-plugin-svelte 3.17.0 → 3.17.1

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.17.0";
+    version: "3.17.1";
 };
 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.17.0";
+export declare const version: "3.17.1";

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

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

@@ -2,6 +2,7 @@ import { createRule } from '../utils/index.js';
 import { ReferenceTracker } from '@eslint-community/eslint-utils';
 import { FindVariableContext } from '../utils/ast-utils.js';
 import { findVariable } from '../utils/ast-utils.js';
+import { getTypeScriptTools } from '../utils/ts-utils/index.js';
 export default createRule('no-navigation-without-resolve', {
     meta: {
         docs: {
@@ -43,6 +44,7 @@ export default createRule('no-navigation-without-resolve', {
         ]
     },
     create(context) {
+        const tsTools = getTypeScriptTools(context);
         let resolveReferences = new Set();
         const ignoreGoto = context.options[0]?.ignoreGoto ?? false;
         const ignorePushState = context.options[0]?.ignorePushState ?? false;
@@ -55,27 +57,27 @@ export default createRule('no-navigation-without-resolve', {
                 const { goto: gotoCalls, pushState: pushStateCalls, replaceState: replaceStateCalls } = extractFunctionCallReferences(referenceTracker);
                 if (!ignoreGoto) {
                     for (const gotoCall of gotoCalls) {
-                        checkGotoCall(context, gotoCall, resolveReferences);
+                        checkGotoCall(context, gotoCall, resolveReferences, tsTools);
                     }
                 }
                 if (!ignorePushState) {
                     for (const pushStateCall of pushStateCalls) {
-                        checkShallowNavigationCall(context, pushStateCall, resolveReferences, 'pushStateWithoutResolve');
+                        checkShallowNavigationCall(context, pushStateCall, resolveReferences, tsTools, 'pushStateWithoutResolve');
                     }
                 }
                 if (!ignoreReplaceState) {
                     for (const replaceStateCall of replaceStateCalls) {
-                        checkShallowNavigationCall(context, replaceStateCall, resolveReferences, 'replaceStateWithoutResolve');
+                        checkShallowNavigationCall(context, replaceStateCall, resolveReferences, tsTools, 'replaceStateWithoutResolve');
                     }
                 }
             },
             ...(!ignoreLinks && {
                 SvelteShorthandAttribute(node) {
-                    checkLinkAttribute(context, node, node.value, resolveReferences);
+                    checkLinkAttribute(context, node, node.value, resolveReferences, tsTools);
                 },
                 SvelteAttribute(node) {
                     if (node.value.length > 0) {
-                        checkLinkAttribute(context, node, node.value[0].type === 'SvelteMustacheTag' ? node.value[0].expression : node.value[0], resolveReferences);
+                        checkLinkAttribute(context, node, node.value[0].type === 'SvelteMustacheTag' ? node.value[0].expression : node.value[0], resolveReferences, tsTools);
                     }
                 }
             })
@@ -143,28 +145,28 @@ function extractFunctionCallReferences(referenceTracker) {
     };
 }
 // Actual function checking
-function checkGotoCall(context, call, resolveReferences) {
+function checkGotoCall(context, call, resolveReferences, tsTools) {
     if (call.arguments.length > 0 &&
-        !isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, {})) {
+        !isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, tsTools, {})) {
         context.report({ loc: call.arguments[0].loc, messageId: 'gotoWithoutResolve' });
     }
 }
-function checkShallowNavigationCall(context, call, resolveReferences, messageId) {
+function checkShallowNavigationCall(context, call, resolveReferences, tsTools, messageId) {
     if (call.arguments.length > 0 &&
-        !isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, {
+        !isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, tsTools, {
             allowEmpty: true
         })) {
         context.report({ loc: call.arguments[0].loc, messageId });
     }
 }
-function checkLinkAttribute(context, attribute, value, resolveReferences) {
+function checkLinkAttribute(context, attribute, value, resolveReferences, tsTools) {
     if (attribute.parent.parent.type === 'SvelteElement' &&
         attribute.parent.parent.kind === 'html' &&
         attribute.parent.parent.name.type === 'SvelteName' &&
         attribute.parent.parent.name.name === 'a' &&
         attribute.key.name === 'href' &&
         !hasRelExternal(new FindVariableContext(context), attribute.parent) &&
-        !isValueAllowed(new FindVariableContext(context), value, resolveReferences, {
+        !isValueAllowed(new FindVariableContext(context), value, resolveReferences, tsTools, {
             allowAbsolute: true,
             allowFragment: true,
             allowNullish: true
@@ -201,30 +203,60 @@ function hasRelExternal(ctx, element) {
     }
     return false;
 }
-function isValueAllowed(ctx, value, resolveReferences, config) {
+function isValueAllowed(ctx, value, resolveReferences, tsTools, config) {
     if (value.type === 'Identifier') {
         const variable = ctx.findVariable(value);
         if (variable !== null &&
             variable.identifiers.length > 0 &&
-            variable.identifiers[0].parent.type === 'VariableDeclarator' &&
-            variable.identifiers[0].parent.init !== null) {
-            return isValueAllowed(ctx, variable.identifiers[0].parent.init, resolveReferences, config);
+            variable.identifiers[0].parent.type === 'VariableDeclarator') {
+            if (expressionIsResolvedPathname(variable.identifiers[0], tsTools)) {
+                return true;
+            }
+            if (variable.identifiers[0].parent.init !== null) {
+                return isValueAllowed(ctx, variable.identifiers[0].parent.init, resolveReferences, tsTools, config);
+            }
         }
     }
     if (value.type === 'ConditionalExpression') {
-        return (isValueAllowed(ctx, value.consequent, resolveReferences, config) &&
-            isValueAllowed(ctx, value.alternate, resolveReferences, config));
+        return (isValueAllowed(ctx, value.consequent, resolveReferences, tsTools, config) &&
+            isValueAllowed(ctx, value.alternate, resolveReferences, tsTools, config));
     }
     if ((config.allowAbsolute && expressionIsAbsoluteUrl(ctx, value)) ||
         (config.allowEmpty && expressionIsEmpty(value)) ||
         (config.allowFragment && expressionStartsWith(ctx, value, '#')) ||
         (config.allowNullish && expressionIsNullish(value)) ||
+        expressionIsResolvedPathname(value, tsTools) ||
         expressionIsResolveCall(ctx, value, resolveReferences)) {
         return true;
     }
     return false;
 }
 // Helper functions
+function expressionIsResolvedPathname(value, tsTools) {
+    if (tsTools === null) {
+        return false;
+    }
+    const checker = tsTools.service.program.getTypeChecker();
+    const tsNode = tsTools.service.esTreeNodeToTSNodeMap.get(value);
+    if (tsNode === undefined) {
+        return false;
+    }
+    const nodeType = checker.getTypeAtLocation(tsNode);
+    const appTypesModule = checker.getAmbientModules().find((m) => m.name === '"$app/types"');
+    if (!appTypesModule) {
+        return false;
+    }
+    const resolvedPathnameSymbol = checker
+        .getExportsOfModule(appTypesModule)
+        .find((e) => e.name === 'ResolvedPathname');
+    if (!resolvedPathnameSymbol) {
+        return false;
+    }
+    const resolvedPathnameType = checker.getDeclaredTypeOfSymbol(resolvedPathnameSymbol);
+    // getTypeAtLocation returns the resolved (structural) type without alias information, so we cannot compare aliasSymbols directly. Instead we check structural equivalence by testing assignability in both directions: this correctly rejects strict subtypes like Pathname (Pathname ⊂ ResolvedPathname, so only one direction holds).
+    return (checker.isTypeAssignableTo(nodeType, resolvedPathnameType) &&
+        checker.isTypeAssignableTo(resolvedPathnameType, nodeType));
+}
 function expressionIsResolveCall(ctx, node, resolveReferences) {
     if (node.type === 'CallExpression' &&
         ((node.callee.type === 'Identifier' && resolveReferences.has(node.callee)) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-svelte",
-  "version": "3.17.0",
+  "version": "3.17.1",
   "description": "ESLint plugin for Svelte using AST",
   "repository": {
     "type": "git",
@@ -66,7 +66,7 @@
     "@typescript-eslint/types": "^8.48.1",
     "acorn": "^8.15.0",
     "assert": "^2.1.0",
-    "esbuild": "^0.27.0",
+    "esbuild": "^0.28.0",
     "eslint-scope": "^9.0.0",
     "eslint-typegen": "^2.3.0",
     "eslint-visitor-keys": "^5.0.0",