chore(no-navigation-without-resolve): reworked the checking function to be more universal

Author: marekdedic

packages/eslint-plugin-svelte/src/rules/no-navigation-without-resolve.ts

@@ -187,12 +187,11 @@ function checkGotoCall(
 	call: TSESTree.CallExpression,
 	resolveReferences: Set<TSESTree.Identifier>
 ): void {
-	if (call.arguments.length < 1) {
-		return;
-	}
-	const url = call.arguments[0];
-	if (!isResolveCall(new FindVariableContext(context), url, resolveReferences)) {
-		context.report({ loc: url.loc, messageId: 'gotoWithoutResolve' });
+	if (
+		call.arguments.length > 0 &&
+		!isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, {})
+	) {
+		context.report({ loc: call.arguments[0].loc, messageId: 'gotoWithoutResolve' });
 	}
 }
 
@@ -202,15 +201,13 @@ function checkShallowNavigationCall(
 	resolveReferences: Set<TSESTree.Identifier>,
 	messageId: string
 ): void {
-	if (call.arguments.length < 1) {
-		return;
-	}
-	const url = call.arguments[0];
 	if (
-		!expressionIsEmpty(url) &&
-		!isResolveCall(new FindVariableContext(context), url, resolveReferences)
+		call.arguments.length > 0 &&
+		!isValueAllowed(new FindVariableContext(context), call.arguments[0], resolveReferences, {
+			allowEmpty: true
+		})
 	) {
-		context.report({ loc: url.loc, messageId });
+		context.report({ loc: call.arguments[0].loc, messageId });
 	}
 }
 
@@ -226,18 +223,53 @@ function checkLinkAttribute(
 		attribute.parent.parent.name.type === 'SvelteName' &&
 		attribute.parent.parent.name.name === 'a' &&
 		attribute.key.name === 'href' &&
-		!expressionIsNullish(new FindVariableContext(context), value) &&
-		!expressionIsAbsolute(new FindVariableContext(context), value) &&
-		!expressionIsFragment(new FindVariableContext(context), value) &&
-		!isResolveCall(new FindVariableContext(context), value, resolveReferences)
+		!isValueAllowed(new FindVariableContext(context), value, resolveReferences, {
+			allowAbsolute: true,
+			allowFragment: true,
+			allowNullish: true
+		})
 	) {
 		context.report({ loc: attribute.loc, messageId: 'linkWithoutResolve' });
 	}
 }
 
+function isValueAllowed(
+	ctx: FindVariableContext,
+	value: TSESTree.CallExpressionArgument | TSESTree.Expression | AST.SvelteLiteral,
+	resolveReferences: Set<TSESTree.Identifier>,
+	config: {
+		allowAbsolute?: boolean;
+		allowEmpty?: boolean;
+		allowFragment?: boolean;
+		allowNullish?: boolean;
+	}
+): boolean {
+	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);
+		}
+	}
+	if (
+		(config.allowEmpty && expressionIsEmpty(value)) ||
+		(config.allowAbsolute && expressionIsAbsolute(ctx, value)) ||
+		(config.allowFragment && expressionIsFragment(ctx, value)) ||
+		(config.allowNullish && expressionIsNullish(value)) ||
+		expressionIsResolveCall(ctx, value, resolveReferences)
+	) {
+		return true;
+	}
+	return false;
+}
+
 // Helper functions
 
-function isResolveCall(
+function expressionIsResolveCall(
 	ctx: FindVariableContext,
 	node: TSESTree.CallExpressionArgument | AST.SvelteLiteral,
 	resolveReferences: Set<TSESTree.Identifier>
@@ -263,10 +295,12 @@ function isResolveCall(
 	) {
 		return false;
 	}
-	return isResolveCall(ctx, variable.identifiers[0].parent.init, resolveReferences);
+	return expressionIsResolveCall(ctx, variable.identifiers[0].parent.init, resolveReferences);
 }
 
-function expressionIsEmpty(url: TSESTree.CallExpressionArgument): boolean {
+function expressionIsEmpty(
+	url: TSESTree.CallExpressionArgument | TSESTree.Expression | AST.SvelteLiteral
+): boolean {
 	return (
 		(url.type === 'Literal' && url.value === '') ||
 		(url.type === 'TemplateLiteral' &&
@@ -277,44 +311,25 @@ function expressionIsEmpty(url: TSESTree.CallExpressionArgument): boolean {
 }
 
 function expressionIsNullish(
-	ctx: FindVariableContext,
-	url: AST.SvelteLiteral | TSESTree.Expression
+	url: TSESTree.CallExpressionArgument | TSESTree.Expression | AST.SvelteLiteral
 ): boolean {
 	switch (url.type) {
 		case 'Identifier':
-			return identifierIsNullish(ctx, url);
+			return url.name === 'undefined';
 		case 'Literal':
 			return url.value === null; // Undefined is an Identifier in ESTree, null is a Literal
 		default:
 			return false;
 	}
 }
 
-function identifierIsNullish(ctx: FindVariableContext, url: TSESTree.Identifier): boolean {
-	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: FindVariableContext,
-	url: AST.SvelteLiteral | TSESTree.Expression
+	url: TSESTree.CallExpressionArgument | TSESTree.Expression | AST.SvelteLiteral
 ): boolean {
 	switch (url.type) {
 		case 'BinaryExpression':
 			return binaryExpressionIsAbsolute(ctx, url);
-		case 'Identifier':
-			return identifierIsAbsolute(ctx, url);
 		case 'Literal':
 			return typeof url.value === 'string' && urlValueIsAbsolute(url.value);
 		case 'SvelteLiteral':
@@ -336,19 +351,6 @@ function binaryExpressionIsAbsolute(
 	);
 }
 
-function identifierIsAbsolute(ctx: FindVariableContext, url: TSESTree.Identifier): boolean {
-	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 expressionIsAbsolute(ctx, variable.identifiers[0].parent.init);
-}
-
 function templateLiteralIsAbsolute(
 	ctx: FindVariableContext,
 	url: TSESTree.TemplateLiteral
@@ -365,7 +367,7 @@ function urlValueIsAbsolute(url: string): boolean {
 
 function expressionIsFragment(
 	ctx: FindVariableContext,
-	url: AST.SvelteLiteral | TSESTree.Expression
+	url: TSESTree.CallExpressionArgument | TSESTree.Expression | AST.SvelteLiteral
 ): boolean {
 	switch (url.type) {
 		case 'BinaryExpression':