chore: extracted expression affix funtions from no-navigation-without-base

Author: marekdedic

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

@@ -3,6 +3,7 @@ import { createRule } from '../utils/index.js';
 import { ReferenceTracker } from '@eslint-community/eslint-utils';
 import { getSourceCode } from '../utils/compat.js';
 import { findVariable } from '../utils/ast-utils.js';
+import { extractExpressionPrefixVariable } from '../utils/expression-affixes.js';
 import type { RuleContext } from '../types.js';
 import type { SvelteLiteral } from 'svelte-eslint-parser/lib/ast';
 
@@ -224,87 +225,8 @@ function expressionStartsWithBase(
 	url: TSESTree.Expression,
 	basePathNames: Set<TSESTree.Identifier>
 ): boolean {
-	switch (url.type) {
-		case 'BinaryExpression':
-			return binaryExpressionStartsWithBase(context, url, basePathNames);
-		case 'Identifier':
-			return variableStartsWithBase(context, url, basePathNames);
-		case 'MemberExpression':
-			return memberExpressionStartsWithBase(url, basePathNames);
-		case 'TemplateLiteral':
-			return templateLiteralStartsWithBase(context, url, basePathNames);
-		default:
-			return false;
-	}
-}
-
-function binaryExpressionStartsWithBase(
-	context: RuleContext,
-	url: TSESTree.BinaryExpression,
-	basePathNames: Set<TSESTree.Identifier>
-): boolean {
-	return (
-		url.left.type !== 'PrivateIdentifier' &&
-		expressionStartsWithBase(context, url.left, basePathNames)
-	);
-}
-
-function memberExpressionStartsWithBase(
-	url: TSESTree.MemberExpression,
-	basePathNames: Set<TSESTree.Identifier>
-): boolean {
-	return url.property.type === 'Identifier' && basePathNames.has(url.property);
-}
-
-function variableStartsWithBase(
-	context: RuleContext,
-	url: TSESTree.Identifier,
-	basePathNames: Set<TSESTree.Identifier>
-): boolean {
-	if (basePathNames.has(url)) {
-		return true;
-	}
-	const variable = findVariable(context, url);
-	if (
-		variable === null ||
-		variable.identifiers.length !== 1 ||
-		variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
-		variable.identifiers[0].parent.init === null
-	) {
-		return false;
-	}
-	return expressionStartsWithBase(context, variable.identifiers[0].parent.init, basePathNames);
-}
-
-function templateLiteralStartsWithBase(
-	context: RuleContext,
-	url: TSESTree.TemplateLiteral,
-	basePathNames: Set<TSESTree.Identifier>
-): boolean {
-	const startingIdentifier = extractLiteralStartingExpression(url);
-	return (
-		startingIdentifier !== undefined &&
-		expressionStartsWithBase(context, startingIdentifier, basePathNames)
-	);
-}
-
-function extractLiteralStartingExpression(
-	templateLiteral: TSESTree.TemplateLiteral
-): TSESTree.Expression | undefined {
-	const literalParts = [...templateLiteral.expressions, ...templateLiteral.quasis].sort((a, b) =>
-		a.range[0] < b.range[0] ? -1 : 1
-	);
-	for (const part of literalParts) {
-		if (part.type === 'TemplateElement' && part.value.raw === '') {
-			// Skip empty quasi in the begining
-			continue;
-		}
-		if (part.type !== 'TemplateElement') {
-			return part;
-		}
-		return undefined;
-	}
-	return undefined;
+	const prefixVariable = extractExpressionPrefixVariable(context, url);
+	return prefixVariable !== null && basePathNames.has(prefixVariable);
 }
 
 function expressionIsEmpty(url: TSESTree.Expression): boolean {

packages/eslint-plugin-svelte/src/utils/expression-affixes.ts

@@ -0,0 +1,76 @@
+import type { TSESTree } from '@typescript-eslint/types';
+import { findVariable } from './ast-utils.js';
+import type { RuleContext } from '../types.js';
+
+// Variable prefix extraction
+
+export function extractExpressionPrefixVariable(
+	context: RuleContext,
+	expression: TSESTree.Expression
+): TSESTree.Identifier | null {
+	switch (expression.type) {
+		case 'BinaryExpression':
+			return extractBinaryExpressionPrefixVariable(context, expression);
+		case 'Identifier':
+			return extractVariablePrefixVariable(context, expression);
+		case 'MemberExpression':
+			return extractMemberExpressionPrefixVariable(expression);
+		case 'TemplateLiteral':
+			return extractTemplateLiteralPrefixVariable(context, expression);
+		default:
+			return null;
+	}
+}
+
+function extractBinaryExpressionPrefixVariable(
+	context: RuleContext,
+	expression: TSESTree.BinaryExpression
+): TSESTree.Identifier | null {
+	return expression.left.type !== 'PrivateIdentifier'
+		? extractExpressionPrefixVariable(context, expression.left)
+		: null;
+}
+
+function extractVariablePrefixVariable(
+	context: RuleContext,
+	expression: TSESTree.Identifier
+): TSESTree.Identifier | null {
+	const variable = findVariable(context, expression);
+	if (
+		variable === null ||
+		variable.identifiers.length !== 1 ||
+		variable.identifiers[0].parent.type !== 'VariableDeclarator' ||
+		variable.identifiers[0].parent.init === null
+	) {
+		return expression;
+	}
+	return (
+		extractExpressionPrefixVariable(context, variable.identifiers[0].parent.init) ?? expression
+	);
+}
+
+function extractMemberExpressionPrefixVariable(
+	expression: TSESTree.MemberExpression
+): TSESTree.Identifier | null {
+	return expression.property.type === 'Identifier' ? expression.property : null;
+}
+
+function extractTemplateLiteralPrefixVariable(
+	context: RuleContext,
+	expression: TSESTree.TemplateLiteral
+): TSESTree.Identifier | null {
+	const literalParts = [...expression.expressions, ...expression.quasis].sort((a, b) =>
+		a.range[0] < b.range[0] ? -1 : 1
+	);
+	for (const part of literalParts) {
+		if (part.type === 'TemplateElement' && part.value.raw === '') {
+			// Skip empty quasi in the begining
+			continue;
+		}
+		if (part.type !== 'TemplateElement') {
+			return extractExpressionPrefixVariable(context, part);
+		}
+		return null;
+	}
+	return null;
+}