@taiga-ui/eslint-plugin-experience-next 0.473.0 → 0.475.0

package/index.esm.js

@@ -908,6 +908,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
+            '@taiga-ui/experience-next/no-infinite-loop': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
             '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
             '@taiga-ui/experience-next/no-signal-reads-after-await-in-reactive-context': 'error',
@@ -1299,6 +1300,11 @@ const config$4 = {
     },
 };
 
+function intersect(a, b) {
+    const origin = new Set(b);
+    return a.some((type) => origin.has(type));
+}
+
 function getFieldTypes(type, checker) {
     const typeNames = [];
     if (type.isUnionOrIntersection()) {
@@ -1331,16 +1337,24 @@ function getFieldTypes(type, checker) {
     return typeNames;
 }
 
-function intersect(a, b) {
-    const origin = new Set(b);
-    return a.some((type) => origin.has(type));
+function getTypeAwareRuleContext(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const { sourceCode } = context;
+    return {
+        checker: parserServices.program.getTypeChecker(),
+        esTreeNodeToTSNodeMap: parserServices.esTreeNodeToTSNodeMap,
+        parserServices,
+        program: sourceCode.ast,
+        sourceCode,
+        tsNodeToESTreeNodeMap: parserServices.tsNodeToESTreeNodeMap,
+        tsProgram: parserServices.program,
+    };
 }
 
-const createRule$i = ESLintUtils.RuleCreator((name) => name);
-var classPropertyNaming = createRule$i({
+const createRule$j = ESLintUtils.RuleCreator((name) => name);
+var classPropertyNaming = createRule$j({
     create(context, [configs]) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const flatConfig = configs.flat();
         return {
             PropertyDefinition(node) {
@@ -1348,7 +1362,7 @@ var classPropertyNaming = createRule$i({
                 if (!fieldName) {
                     return;
                 }
-                const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+                const tsNode = esTreeNodeToTSNodeMap.get(node);
                 const nodeType = typeChecker.getTypeAtLocation(tsNode);
                 const fieldTypes = getFieldTypes(nodeType, typeChecker);
                 const rule = flatConfig.find((rule) => intersect(fieldTypes, rule.withTypesSpecifier) &&
@@ -1404,6 +1418,10 @@ var classPropertyNaming = createRule$i({
     name: 'class-property-naming',
 });
 
+function sameOrder(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
 const config$3 = {
     create(context) {
         const order = context.options[0] || {};
@@ -1422,7 +1440,7 @@ const config$3 = {
                                 .map((prop) => prop.key?.name)
                                 .filter(Boolean);
                             const correct = getCorrectOrderRelative(orderList, current);
-                            if (!isCorrectSortedAccording(correct, current)) {
+                            if (!sameOrder(correct, current.filter((item) => correct.includes(item)))) {
                                 context.report({
                                     fix: (fixer) => {
                                         const fileContent = context.sourceCode.text;
@@ -1458,10 +1476,6 @@ const config$3 = {
         type: 'problem',
     },
 };
-function isCorrectSortedAccording(correct, current) {
-    return (JSON.stringify(correct) ===
-        JSON.stringify(current.filter((item) => correct.includes(item))));
-}
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
@@ -1506,12 +1520,11 @@ function isExternalPureTuple(typeChecker, type) {
     return typeArgs.every((item) => isClassType(item));
 }
 
-const createRule$h = ESLintUtils.RuleCreator((name) => name);
+const createRule$i = ESLintUtils.RuleCreator((name) => name);
 const MESSAGE_ID$7 = 'spreadArrays';
-var flatExports = createRule$h({
+var flatExports = createRule$i({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const arrays = new Map();
         const purityCache = new WeakMap();
         const isPureArray = (arr) => {
@@ -1595,7 +1608,7 @@ var flatExports = createRule$h({
                         isDirty = true;
                         continue;
                     }
-                    const tsNode = parserServices.esTreeNodeToTSNodeMap.get(el);
+                    const tsNode = esTreeNodeToTSNodeMap.get(el);
                     const elType = typeChecker.getTypeAtLocation(tsNode);
                     const isClass = isClassType(elType);
                     const isArrayLike = typeChecker.isArrayLikeType(elType) ||
@@ -1675,8 +1688,53 @@ function getDecoratorMetadata(decorator, allowedNames) {
     return isObject(arg) ? arg : null;
 }
 
-function sameOrder(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
+function isStringLiteral(node) {
+    return node?.type === AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+function isStaticTemplateLiteral(node) {
+    return (node?.type === AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1);
+}
+function getStaticStringValue(node) {
+    if (isStringLiteral(node)) {
+        return node.value;
+    }
+    if (!isStaticTemplateLiteral(node)) {
+        return null;
+    }
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '';
+}
+function isEmptyStaticString(node) {
+    return getStaticStringValue(node) === '';
+}
+
+function getStaticPropertyName(key) {
+    if (key.type === AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    if (key.type === AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')) {
+        return String(key.value);
+    }
+    return getStaticStringValue(key);
+}
+function getObjectPropertyName(node) {
+    if (node.computed) {
+        return null;
+    }
+    return getStaticPropertyName(node.key);
+}
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return node.computed ? getStaticStringValue(node.property) : null;
+}
+function getClassMemberName(member) {
+    return member.key.type === AST_NODE_TYPES.PrivateIdentifier
+        ? null
+        : getStaticPropertyName(member.key);
 }
 
 const DEFAULT_GROUP = '$DEFAULT';
@@ -1744,8 +1802,8 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const createRule$g = ESLintUtils.RuleCreator((name) => name);
-const rule$j = createRule$g({
+const createRule$h = ESLintUtils.RuleCreator((name) => name);
+const rule$k = createRule$h({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -1867,21 +1925,6 @@ function getHostAttributeProperties(hostObject) {
     }
     return properties;
 }
-function getStaticPropertyName(key) {
-    if (key.type === AST_NODE_TYPES$1.Identifier) {
-        return key.name;
-    }
-    if (key.type === AST_NODE_TYPES$1.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')) {
-        return String(key.value);
-    }
-    if (key.type === AST_NODE_TYPES$1.TemplateLiteral &&
-        key.expressions.length === 0 &&
-        key.quasis.length === 1) {
-        return key.quasis[0]?.value.cooked ?? null;
-    }
-    return null;
-}
 function organizeProperties(properties, options) {
     const groups = getGroups(options.attributeGroups.length > 0 ? options.attributeGroups : ['$ANGULAR'], options.attributeIgnoreCase);
     const defaultGroup = ensureDefaultGroup(groups);
@@ -2021,7 +2064,7 @@ const config$2 = {
 const MESSAGE_ID$5 = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
-const createRule$f = ESLintUtils.RuleCreator((name) => name);
+const createRule$g = ESLintUtils.RuleCreator((name) => name);
 function getVariableName(node) {
     if (node.parent.type !== AST_NODE_TYPES$1.VariableDeclarator) {
         return undefined;
@@ -2029,21 +2072,18 @@ function getVariableName(node) {
     const { id } = node.parent;
     return id.type === AST_NODE_TYPES$1.Identifier ? id.name : undefined;
 }
-function isStringLiteral$1(node) {
-    return node.type === AST_NODE_TYPES$1.Literal && typeof node.value === 'string';
-}
 function isStringLike(node) {
-    return isStringLiteral$1(node) || node.type === AST_NODE_TYPES$1.TemplateLiteral;
+    return isStringLiteral(node) || node.type === AST_NODE_TYPES$1.TemplateLiteral;
 }
 function getStringValue(node) {
-    if (isStringLiteral$1(node)) {
+    if (isStringLiteral(node)) {
         return node.value;
     }
     return node.quasis[0]?.value.raw || '';
 }
-function isEmptyString$1(node) {
-    return (getStringValue(node) === '' &&
-        (!('expressions' in node) || !node.expressions.length));
+function isEmptyString(node) {
+    return (isEmptyStaticString(node) &&
+        (!('expressions' in node) || node.expressions.length === 0));
 }
 function isNgDevModeConditional(node) {
     return (node.type === AST_NODE_TYPES$1.ConditionalExpression &&
@@ -2051,7 +2091,7 @@ function isNgDevModeConditional(node) {
         node.test.name === NG_DEV_MODE &&
         isStringLike(node.consequent) &&
         isStringLike(node.alternate) &&
-        isEmptyString$1(node.alternate));
+        isEmptyString(node.alternate));
 }
 function getDescriptionValue(node) {
     if (isStringLike(node)) {
@@ -2092,7 +2132,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$i = createRule$f({
+const rule$j = createRule$g({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -2160,8 +2200,8 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const createRule$e = ESLintUtils.RuleCreator((name) => name);
-const rule$h = createRule$e({
+const createRule$f = ESLintUtils.RuleCreator((name) => name);
+const rule$i = createRule$f({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -2248,13 +2288,13 @@ const rule$h = createRule$e({
     name: 'no-deep-imports',
 });
 
-const createRule$d = ESLintUtils.RuleCreator((name) => name);
+const createRule$e = ESLintUtils.RuleCreator((name) => name);
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-var noDeepImportsToIndexedPackages = createRule$d({
+var noDeepImportsToIndexedPackages = createRule$e({
     create(context) {
         const parserServices = ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -2443,63 +2483,13 @@ function stripKnownExtensions(filePathOrSpecifier) {
     return filePathOrSpecifier.replace(/\.(?:d\.ts|ts|tsx|js|jsx|mjs|cjs)$/, '');
 }
 
-const ANGULAR_CORE$1 = '@angular/core';
-/**
- * Returns the local name bound to a named import from a given source.
- * Handles aliased imports: `import { untracked as ngUntracked } from '@angular/core'`
- * returns `'ngUntracked'` for `exportedName = 'untracked'`.
- */
-function getLocalNameForImport(program, source, exportedName) {
-    for (const node of program.body) {
-        if (node.type !== AST_NODE_TYPES.ImportDeclaration ||
-            node.source.value !== source) {
-            continue;
-        }
-        for (const spec of node.specifiers) {
-            if (spec.type !== AST_NODE_TYPES.ImportSpecifier) {
-                continue;
-            }
-            const imported = spec.imported.type === AST_NODE_TYPES.Identifier
-                ? spec.imported.name
-                : spec.imported.value;
-            if (imported === exportedName) {
-                return spec.local.name;
-            }
-        }
-    }
-    return null;
-}
-function findAngularCoreImports(program) {
-    return program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
-        node.source.value === ANGULAR_CORE$1);
-}
-function findRuntimeAngularCoreImport(program) {
-    return (findAngularCoreImports(program).find((node) => node.importKind !== 'type') ?? null);
-}
-function findAngularCoreImportSpecifier(program, exportedName) {
-    for (const importDecl of findAngularCoreImports(program)) {
-        for (const specifier of importDecl.specifiers) {
-            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
-                continue;
-            }
-            const imported = specifier.imported.type === AST_NODE_TYPES.Identifier
-                ? specifier.imported.name
-                : specifier.imported.value;
-            if (imported === exportedName) {
-                return { importDecl, specifier };
-            }
-        }
-    }
-    return null;
-}
-
-function isFunctionLike$1(node) {
+function isFunctionLike(node) {
     return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === AST_NODE_TYPES.FunctionDeclaration ||
         node.type === AST_NODE_TYPES.FunctionExpression);
 }
 function getOrderedChildren(node) {
-    if (isFunctionLike$1(node)) {
+    if (isFunctionLike(node)) {
         const children = [
             ...node.params,
             node.body,
@@ -2568,7 +2558,7 @@ function getOrderedChildren(node) {
 function walkSynchronousAst(root, visitor) {
     traverse(root, true);
     function traverse(node, isRoot = false) {
-        if (visitor(node) === false || (!isRoot && isFunctionLike$1(node))) {
+        if (visitor(node) === false || (!isRoot && isFunctionLike(node))) {
             return false;
         }
         if (node.type === AST_NODE_TYPES.AwaitExpression) {
@@ -2597,7 +2587,7 @@ function walkAfterAsyncBoundaryAst(root, visitor) {
         if (afterBoundary) {
             visitor(node);
         }
-        if (!isRoot && isFunctionLike$1(node)) {
+        if (!isRoot && isFunctionLike(node)) {
             return false;
         }
         if (node.type === AST_NODE_TYPES.AwaitExpression) {
@@ -2660,6 +2650,56 @@ function walkAst(root, visitor) {
     }
 }
 
+const ANGULAR_CORE$1 = '@angular/core';
+/**
+ * Returns the local name bound to a named import from a given source.
+ * Handles aliased imports: `import { untracked as ngUntracked } from '@angular/core'`
+ * returns `'ngUntracked'` for `exportedName = 'untracked'`.
+ */
+function getLocalNameForImport(program, source, exportedName) {
+    for (const node of program.body) {
+        if (node.type !== AST_NODE_TYPES.ImportDeclaration ||
+            node.source.value !== source) {
+            continue;
+        }
+        for (const spec of node.specifiers) {
+            if (spec.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = spec.imported.type === AST_NODE_TYPES.Identifier
+                ? spec.imported.name
+                : spec.imported.value;
+            if (imported === exportedName) {
+                return spec.local.name;
+            }
+        }
+    }
+    return null;
+}
+function findAngularCoreImports(program) {
+    return program.body.filter((node) => node.type === AST_NODE_TYPES.ImportDeclaration &&
+        node.source.value === ANGULAR_CORE$1);
+}
+function findRuntimeAngularCoreImport(program) {
+    return (findAngularCoreImports(program).find((node) => node.importKind !== 'type') ?? null);
+}
+function findAngularCoreImportSpecifier(program, exportedName) {
+    for (const importDecl of findAngularCoreImports(program)) {
+        for (const specifier of importDecl.specifiers) {
+            if (specifier.type !== AST_NODE_TYPES.ImportSpecifier) {
+                continue;
+            }
+            const imported = specifier.imported.type === AST_NODE_TYPES.Identifier
+                ? specifier.imported.name
+                : specifier.imported.value;
+            if (imported === exportedName) {
+                return { importDecl, specifier };
+            }
+        }
+    }
+    return null;
+}
+
 const ANGULAR_CORE = '@angular/core';
 const SIGNAL_WRITE_METHODS = new Set(['mutate', 'set', 'update']);
 const AFTER_RENDER_EFFECT_PHASES = new Map([
@@ -2668,10 +2708,14 @@ const AFTER_RENDER_EFFECT_PHASES = new Map([
     ['read', 'afterRenderEffect().read'],
     ['write', 'afterRenderEffect().write'],
 ]);
-function isReactiveCallback$1(node) {
+function isReactiveCallback(node) {
     return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
         node?.type === AST_NODE_TYPES.FunctionExpression);
 }
+function getReactiveCallbackArgument(node) {
+    const [arg] = node.arguments;
+    return isReactiveCallback(arg) ? arg : null;
+}
 function getPropertyName(property) {
     if (property.computed) {
         return null;
@@ -2691,11 +2735,11 @@ function isAngularCoreCall(node, program, exportedName) {
         node.arguments.length >= 1);
 }
 function appendFirstArgReactiveScope(scopes, call, kind) {
-    const [arg] = call.arguments;
-    if (!isReactiveCallback$1(arg)) {
+    const callback = getReactiveCallbackArgument(call);
+    if (!callback) {
         return;
     }
-    scopes.push({ callback: arg, kind, owner: call, reportNode: call });
+    scopes.push({ callback, kind, owner: call, reportNode: call });
 }
 function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
     for (const property of object.properties) {
@@ -2704,7 +2748,7 @@ function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
         }
         const name = getPropertyName(property);
         const label = name ? labels.get(name) : null;
-        if (!label || !isReactiveCallback$1(property.value)) {
+        if (!label || !isReactiveCallback(property.value)) {
             continue;
         }
         scopes.push({
@@ -2718,6 +2762,9 @@ function appendObjectPropertyReactiveScopes(scopes, call, object, labels) {
 function isAngularEffectCall(node, program) {
     return isAngularCoreCall(node, program, 'effect');
 }
+function isAngularInjectCall(node, program) {
+    return isAngularCoreCall(node, program, 'inject');
+}
 function isAngularUntrackedCall(node, program) {
     return isAngularCoreCall(node, program, 'untracked');
 }
@@ -2911,54 +2958,74 @@ function collectSignalUsages(scopeNode, checker, esTreeNodeToTSNodeMap, program)
     });
     return { reads, writes };
 }
-
-const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
-const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
-const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
-const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
-
-/**
- * Collects signal reads that appear inside `untracked(...)` callbacks within
- * `root`, without descending into nested `untracked(...)` scopes.
- */
-function collectReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
+function collectSignalReadsInsideUntracked(root, checker, esTreeNodeToTSNodeMap, program) {
     const reads = [];
     walkSynchronousAst(root, (node) => {
         if (node.type !== AST_NODE_TYPES.CallExpression ||
             !isAngularUntrackedCall(node, program)) {
             return;
         }
-        const [arg] = node.arguments;
-        if (!arg ||
-            (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-                arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+        const callback = getReactiveCallbackArgument(node);
+        if (!callback) {
             return false;
         }
-        walkSynchronousAst(arg, (inner) => {
+        walkSynchronousAst(callback, (inner) => {
             if (inner.type === AST_NODE_TYPES.CallExpression &&
                 isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
                 reads.push(inner);
             }
         });
-        return false; // Do not descend into nested untracked from the outer walk
+        return false;
     });
     return reads;
 }
-const rule$g = createUntrackedRule({
+function isReactiveOwnerCall(node, program) {
+    return (node.type === AST_NODE_TYPES.CallExpression &&
+        getReactiveScopes(node, program).length > 0);
+}
+function getReturnedReactiveOwnerCall(node, program) {
+    const callback = getReactiveCallbackArgument(node);
+    if (!callback) {
+        return null;
+    }
+    if (isReactiveOwnerCall(callback.body, program)) {
+        return callback.body;
+    }
+    if (callback.body.type !== AST_NODE_TYPES.BlockStatement ||
+        callback.body.body.length !== 1) {
+        return null;
+    }
+    const [statement] = callback.body.body;
+    if (statement?.type === AST_NODE_TYPES.ReturnStatement &&
+        statement.argument &&
+        isReactiveOwnerCall(statement.argument, program)) {
+        return statement.argument;
+    }
+    if (node.parent.type === AST_NODE_TYPES.ExpressionStatement &&
+        statement?.type === AST_NODE_TYPES.ExpressionStatement &&
+        isReactiveOwnerCall(statement.expression, program)) {
+        return statement.expression;
+    }
+    return null;
+}
+
+const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
+const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
+const UNTRACKED_RULES_README_URL = 'https://github.com/taiga-family/taiga-ui/blob/main/projects/eslint-plugin-experience-next/README.md';
+const createUntrackedRule = ESLintUtils.RuleCreator((name) => `${UNTRACKED_RULES_README_URL}#${name}`);
+
+const rule$h = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
-                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, signalNodeMap, program);
                     if (trackedReads.length > 0) {
                         continue;
                     }
-                    const untrackedReads = collectReadsInsideUntracked(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const untrackedReads = collectSignalReadsInsideUntracked(scope.callback, checker, signalNodeMap, program);
                     if (untrackedReads.length === 0) {
                         continue;
                     }
@@ -3030,46 +3097,102 @@ const config$1 = {
     },
 };
 
-const createRule$c = ESLintUtils.RuleCreator((name) => name);
-const rule$f = createRule$c({
-    create(context) {
-        const checkImplicitPublic = (node) => {
-            const classRef = getClass(node);
-            if (!classRef ||
-                node.kind === 'constructor' ||
-                !!node?.accessibility ||
-                node.key?.type === AST_NODE_TYPES.PrivateIdentifier) {
-                return;
-            }
-            const name = node?.key?.name ||
-                node?.parameter?.name ||
-                (node?.key?.type === 'Identifier' ? node.key.name : 'member');
-            let range = node?.parameter?.range ??
-                node?.key?.range ??
-                node?.range ?? [0, 0];
-            if (node.kind === 'set' || node.kind === 'get') {
-                const [start, end] = node.key.range;
-                range = [start - node.kind.length - 1, end - node.kind.length - 1];
-            }
-            else if (node.kind === 'method' && node.key?.object?.name === 'Symbol') {
-                const [start, end] = range;
-                range = [start - 1, end - 1];
-            }
-            if (node.type === 'PropertyDefinition' && node.decorators?.length > 0) {
-                const [, end] = node.decorators[node.decorators.length - 1].range ?? [];
-                range = [end + 1, end + 2];
-            }
-            context.report({
-                data: {
-                    kind: node.kind || 'property',
-                    name,
-                },
-                fix: (fixer) => fixer.insertTextBeforeRange(range, ' public '),
-                messageId: 'implicitPublic',
-                node,
-            });
-        };
-        return {
+function findAncestor(node, predicate) {
+    for (let current = node?.parent; current; current = current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function findSelfOrAncestor(node, predicate) {
+    for (let current = node; current; current = current.parent) {
+        if (predicate(current)) {
+            return current;
+        }
+    }
+    return null;
+}
+function hasAncestor(node, predicate) {
+    for (let current = node?.parent; current; current = current.parent) {
+        if (predicate(current)) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNodeInside(node, ancestor) {
+    for (let current = node; current; current = current.parent) {
+        if (current === ancestor) {
+            return true;
+        }
+    }
+    return false;
+}
+function isNodeInsideAny(node, ancestors) {
+    return ancestors.some((ancestor) => isNodeInside(node, ancestor));
+}
+function isClassLike(node) {
+    return (node.type === AST_NODE_TYPES.ClassDeclaration ||
+        node.type === AST_NODE_TYPES.ClassExpression);
+}
+function isClassMember(node) {
+    return (node.type === AST_NODE_TYPES.MethodDefinition ||
+        node.type === AST_NODE_TYPES.PropertyDefinition);
+}
+function getEnclosingFunction(node) {
+    return findAncestor(node, isFunctionLike);
+}
+function getEnclosingClass(node) {
+    return findSelfOrAncestor(node, isClassLike);
+}
+function getEnclosingClassMember(node) {
+    return findAncestor(node, isClassMember);
+}
+function getScopeRoot(node) {
+    return (findAncestor(node, (ancestor) => ancestor.type === AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
+}
+
+const createRule$d = ESLintUtils.RuleCreator((name) => name);
+const rule$g = createRule$d({
+    create(context) {
+        const checkImplicitPublic = (node) => {
+            const classRef = getEnclosingClass(node);
+            if (!classRef ||
+                node.kind === 'constructor' ||
+                !!node?.accessibility ||
+                node.key?.type === AST_NODE_TYPES.PrivateIdentifier) {
+                return;
+            }
+            const name = node?.key?.name ||
+                node?.parameter?.name ||
+                (node?.key?.type === 'Identifier' ? node.key.name : 'member');
+            let range = node?.parameter?.range ??
+                node?.key?.range ??
+                node?.range ?? [0, 0];
+            if (node.kind === 'set' || node.kind === 'get') {
+                const [start, end] = node.key.range;
+                range = [start - node.kind.length - 1, end - node.kind.length - 1];
+            }
+            else if (node.kind === 'method' && node.key?.object?.name === 'Symbol') {
+                const [start, end] = range;
+                range = [start - 1, end - 1];
+            }
+            if (node.type === 'PropertyDefinition' && node.decorators?.length > 0) {
+                const [, end] = node.decorators[node.decorators.length - 1].range ?? [];
+                range = [end + 1, end + 2];
+            }
+            context.report({
+                data: {
+                    kind: node.kind || 'property',
+                    name,
+                },
+                fix: (fixer) => fixer.insertTextBeforeRange(range, ' public '),
+                messageId: 'implicitPublic',
+                node,
+            });
+        };
+        return {
             MethodDefinition(node) {
                 checkImplicitPublic(node);
             },
@@ -3092,16 +3215,64 @@ const rule$f = createRule$c({
     },
     name: 'explicit-public-member',
 });
-function getClass(node) {
-    if (!node) {
-        return null;
+
+function getParenthesizedInner(node) {
+    const maybeNode = node;
+    if (maybeNode.type === 'ParenthesizedExpression') {
+        return maybeNode.expression ?? null;
     }
-    if (node.type === AST_NODE_TYPES.ClassDeclaration) {
-        return node;
+    return null;
+}
+function unwrapParenthesized(node) {
+    let current = node;
+    let inner = getParenthesizedInner(current);
+    while (inner) {
+        current = inner;
+        inner = getParenthesizedInner(current);
     }
-    return getClass(node.parent);
+    return current;
 }
 
+const createRule$c = ESLintUtils.RuleCreator((name) => name);
+function isBooleanTrue(node) {
+    const unwrapped = unwrapParenthesized(node);
+    return unwrapped.type === AST_NODE_TYPES.Literal && unwrapped.value === true;
+}
+const rule$f = createRule$c({
+    create(context) {
+        return {
+            ForStatement(node) {
+                if (!node.test) {
+                    context.report({
+                        messageId: 'forLoop',
+                        node,
+                    });
+                }
+            },
+            WhileStatement(node) {
+                if (isBooleanTrue(node.test)) {
+                    context.report({
+                        messageId: 'whileLoop',
+                        node: node.test,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow `while (true)` and `for` loops without an explicit condition. Prefer loops with meaningful exit conditions.',
+        },
+        messages: {
+            forLoop: 'Use an explicit exit condition instead of a `for` loop without a condition.',
+            whileLoop: 'Use an explicit exit condition instead of `while (true)`.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-infinite-loop',
+});
+
 const createRule$b = ESLintUtils.RuleCreator((name) => name);
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
 const rule$e = createRule$b({
@@ -3145,8 +3316,7 @@ const rule$e = createRule$b({
 const createRule$a = ESLintUtils.RuleCreator((name) => name);
 const rule$d = createRule$a({
     create(context) {
-        const services = ESLintUtils.getParserServices(context);
-        const checker = services.program.getTypeChecker();
+        const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
             CallExpression(node) {
                 const callee = node.callee;
@@ -3160,18 +3330,18 @@ const rule$d = createRule$a({
                     return;
                 }
                 const [argument] = node.arguments;
-                if (!argument || !isEmptyString(argument)) {
+                if (!argument || !isEmptyStaticString(argument)) {
                     return;
                 }
                 const objectExpression = callee.object;
-                const tsNode = services.esTreeNodeToTSNodeMap.get(objectExpression);
+                const tsNode = esTreeNodeToTSNodeMap.get(objectExpression);
                 const type = checker.getTypeAtLocation(tsNode);
                 if (!isPlaywrightLocator(type, checker)) {
                     return;
                 }
                 context.report({
                     fix(fixer) {
-                        const objectText = context.sourceCode.getText(objectExpression);
+                        const objectText = sourceCode.getText(objectExpression);
                         return fixer.replaceText(node, `${objectText}.clear()`);
                     },
                     messageId: 'useClear',
@@ -3191,13 +3361,6 @@ const rule$d = createRule$a({
     },
     name: 'no-playwright-empty-fill',
 });
-function isEmptyString(node) {
-    return ((node.type === AST_NODE_TYPES$1.Literal && node.value === '') ||
-        (node.type === AST_NODE_TYPES$1.TemplateLiteral &&
-            node.expressions.length === 0 &&
-            node.quasis.length === 1 &&
-            node.quasis[0]?.value.cooked === ''));
-}
 function isPlaywrightLocator(type, checker) {
     if (isPlaywrightLocatorType(type)) {
         return true;
@@ -3336,15 +3499,14 @@ function collectArrayExpressions(node) {
 }
 const rule$c = createRule$9({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const typeChecker = parserServices.program.getTypeChecker();
+        const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
         function check(node, typeAnnotation, value) {
             if (!typeAnnotation || !value) {
                 return;
             }
-            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
-            const tsValueNode = parserServices.esTreeNodeToTSNodeMap.get(value);
+            const tsNode = esTreeNodeToTSNodeMap.get(node);
+            const tsValueNode = esTreeNodeToTSNodeMap.get(value);
             const declaredType = typeChecker.getTypeAtLocation(tsNode);
             const inferredType = typeChecker.getTypeAtLocation(tsValueNode);
             if (typeChecker.typeToString(declaredType) !==
@@ -3368,7 +3530,7 @@ const rule$c = createRule$9({
             if (ignoreTupleContextualTyping) {
                 const arrayExpressions = collectArrayExpressions(value);
                 for (const arrayExpression of arrayExpressions) {
-                    const tsArrayNode = parserServices.esTreeNodeToTSNodeMap.get(arrayExpression);
+                    const tsArrayNode = esTreeNodeToTSNodeMap.get(arrayExpression);
                     if (typeChecker.isTupleType(typeChecker.getTypeAtLocation(tsArrayNode))) {
                         return;
                     }
@@ -3462,11 +3624,6 @@ function unwrapExpression(expression) {
     return current;
 }
 
-const createRule$8 = ESLintUtils.RuleCreator((name) => name);
-function isReactiveCallback(node) {
-    return (node?.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node?.type === AST_NODE_TYPES.FunctionExpression);
-}
 function unwrapMutationTarget(node) {
     let current = node;
     while (current.type === AST_NODE_TYPES.TSAsExpression ||
@@ -3500,6 +3657,7 @@ function collectMutationTargets(node) {
             return [];
     }
 }
+
 function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     const tsNode = esTreeNodeToTSNodeMap.get(node);
     if (!tsNode) {
@@ -3507,7 +3665,12 @@ function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     }
     return checker.getSymbolAtLocation(tsNode) ?? null;
 }
-function isLocalIdentifier(node, context) {
+
+const createRule$8 = ESLintUtils.RuleCreator((name) => name);
+function isFunctionLikeScope(node) {
+    return !!node && isFunctionLike(node);
+}
+function isLocalIdentifier(node, context, localScopes) {
     const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
@@ -3515,10 +3678,24 @@ function isLocalIdentifier(node, context) {
     return (symbol.declarations ?? []).some((declaration) => {
         const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
         return (!!estreeDeclaration &&
-            isNodeInsideSynchronousReactiveScope(estreeDeclaration, context.callback));
+            isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
+    });
+}
+function isDeclaredInsideLocalScope(node, localScopes) {
+    return localScopes.some((scope) => isNodeInsideFunctionScope(node, scope));
+}
+function isNodeInsideFunctionScope(node, scope) {
+    let found = false;
+    walkSynchronousAst(scope, (inner) => {
+        if (inner !== node) {
+            return;
+        }
+        found = true;
+        return false;
     });
+    return found;
 }
-function isLocallyCreatedExpression(node, context) {
+function isLocallyCreatedExpression(node, context, localScopes) {
     const expression = unwrapExpression(node);
     switch (expression.type) {
         case AST_NODE_TYPES.ArrayExpression:
@@ -3526,87 +3703,245 @@ function isLocallyCreatedExpression(node, context) {
         case AST_NODE_TYPES.ObjectExpression:
             return true;
         case AST_NODE_TYPES.Identifier:
-            return isLocalIdentifier(expression, context);
+            return isLocalIdentifier(expression, context, localScopes);
         case AST_NODE_TYPES.MemberExpression:
-            return isLocallyCreatedExpression(expression.object, context);
+            return isLocallyCreatedExpression(expression.object, context, localScopes);
         default:
             return false;
     }
 }
-function hasObservableMutationTarget(node, context) {
+function hasObservableMutationTarget(node, context, localScopes) {
     return collectMutationTargets(node).some((target) => {
         if (target.type === AST_NODE_TYPES.Identifier) {
-            return !isLocalIdentifier(target, context);
+            return !isLocalIdentifier(target, context, localScopes);
         }
-        return !isLocallyCreatedExpression(target.object, context);
+        return !isLocallyCreatedExpression(target.object, context, localScopes);
     });
 }
-function reportSideEffect(node, inspectionContext, report) {
+function reportSideEffect(node, context, report) {
     const key = String(node.range);
-    if (inspectionContext.reported.has(key)) {
+    if (context.reported.has(key)) {
         return;
     }
-    inspectionContext.reported.add(key);
+    context.reported.add(key);
     report(node);
 }
-function inspectComputedBody(root, inspectionContext, report) {
+function isDirectAngularSideEffectCall(node, context) {
+    return (isWritableSignalWrite(node, context.checker, context.esTreeNodeToTSNodeMap) ||
+        isAngularEffectCall(node, context.program) ||
+        isAngularInjectCall(node, context.program));
+}
+function isInspectableFunctionContainer(node) {
+    return (!!node &&
+        (isFunctionLikeScope(node) ||
+            node.type === AST_NODE_TYPES.MethodDefinition ||
+            node.type === AST_NODE_TYPES.Property ||
+            node.type === AST_NODE_TYPES.PropertyDefinition ||
+            node.type === AST_NODE_TYPES.VariableDeclarator));
+}
+function resolveFunctionLikeFromContainer(node, context, seenSymbols = new Set()) {
+    if (isFunctionLikeScope(node)) {
+        return [node];
+    }
+    if ((node.type === AST_NODE_TYPES.MethodDefinition &&
+        isFunctionLikeScope(node.value)) ||
+        (node.type === AST_NODE_TYPES.Property && isFunctionLikeScope(node.value))) {
+        return [node.value];
+    }
+    if (node.type === AST_NODE_TYPES.Property &&
+        node.value.type === AST_NODE_TYPES.Identifier) {
+        return resolveFunctionLikeFromIdentifier(node.value, context, seenSymbols);
+    }
+    if (node.type === AST_NODE_TYPES.PropertyDefinition &&
+        node.value &&
+        isFunctionLikeScope(node.value)) {
+        return [node.value];
+    }
+    if (node.type === AST_NODE_TYPES.PropertyDefinition &&
+        node.value?.type === AST_NODE_TYPES.Identifier) {
+        return resolveFunctionLikeFromIdentifier(node.value, context, seenSymbols);
+    }
+    if (node.type === AST_NODE_TYPES.VariableDeclarator) {
+        const { init } = node;
+        if (init && isFunctionLikeScope(init)) {
+            return [init];
+        }
+        if (init?.type === AST_NODE_TYPES.Identifier) {
+            return resolveFunctionLikeFromIdentifier(init, context, seenSymbols);
+        }
+    }
+    return [];
+}
+function resolveFunctionLikeFromIdentifier(node, context, seenSymbols = new Set()) {
+    const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
+    if (!symbol) {
+        return [];
+    }
+    const symbolId = `${symbol.name}:${symbol.declarations?.[0]?.pos ?? -1}`;
+    if (seenSymbols.has(symbolId)) {
+        return [];
+    }
+    seenSymbols.add(symbolId);
+    return (symbol.declarations ?? []).flatMap((declaration) => {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
+            return [];
+        }
+        return resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
+    });
+}
+function resolveCalledFunctions(node, context) {
+    const resolved = new Map();
+    const tsNode = context.esTreeNodeToTSNodeMap.get(node);
+    const signature = tsNode ? context.checker.getResolvedSignature(tsNode) : undefined;
+    const declarations = new Set();
+    if (signature?.declaration) {
+        declarations.add(signature.declaration);
+    }
+    const callee = unwrapExpression(node.callee);
+    if (callee.type === AST_NODE_TYPES.Identifier ||
+        callee.type === AST_NODE_TYPES.MemberExpression) {
+        const symbol = getSymbolAtNode(callee, context.checker, context.esTreeNodeToTSNodeMap);
+        for (const declaration of symbol?.declarations ?? []) {
+            declarations.add(declaration);
+        }
+    }
+    for (const declaration of declarations) {
+        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
+            continue;
+        }
+        for (const fn of resolveFunctionLikeFromContainer(estreeDeclaration, context)) {
+            resolved.set(String(fn.range), fn);
+        }
+    }
+    return [...resolved.values()];
+}
+function functionHasObservableSideEffects(root, context, localScopes, visitedFunctions) {
+    let hasSideEffect = false;
     walkSynchronousAst(root, (node) => {
         if (node.type === AST_NODE_TYPES.CallExpression) {
-            if (isWritableSignalWrite(node, inspectionContext.checker, inspectionContext.esTreeNodeToTSNodeMap)) {
-                reportSideEffect(node, inspectionContext, report);
+            if (isDirectAngularSideEffectCall(node, context)) {
+                hasSideEffect = true;
+                return false;
+            }
+            if (isAngularUntrackedCall(node, context.program)) {
+                const callback = getReactiveCallbackArgument(node);
+                if (callback &&
+                    functionHasObservableSideEffects(callback, context, [...localScopes, callback], visitedFunctions)) {
+                    hasSideEffect = true;
+                }
+                return false;
             }
-            if (isAngularUntrackedCall(node, inspectionContext.program)) {
-                const [arg] = node.arguments;
-                if (isReactiveCallback(arg)) {
-                    inspectComputedBody(arg, inspectionContext, report);
+            if (isReactiveCallback(node.callee)) {
+                if (functionHasObservableSideEffects(node.callee, context, [...localScopes, node.callee], visitedFunctions)) {
+                    hasSideEffect = true;
                 }
                 return false;
             }
-            if (node.callee.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-                node.callee.type === AST_NODE_TYPES.FunctionExpression) {
-                inspectComputedBody(node.callee, inspectionContext, report);
+            for (const calledFunction of resolveCalledFunctions(node, context)) {
+                const key = String(calledFunction.range);
+                if (visitedFunctions.has(key)) {
+                    continue;
+                }
+                visitedFunctions.add(key);
+                const calledFunctionHasSideEffects = functionHasObservableSideEffects(calledFunction, context, [...localScopes, calledFunction], visitedFunctions);
+                visitedFunctions.delete(key);
+                if (!calledFunctionHasSideEffects) {
+                    continue;
+                }
+                hasSideEffect = true;
                 return false;
             }
         }
         if (node.type === AST_NODE_TYPES.AssignmentExpression &&
-            hasObservableMutationTarget(node.left, inspectionContext)) {
-            reportSideEffect(node.left, inspectionContext, report);
+            hasObservableMutationTarget(node.left, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
         }
         if (node.type === AST_NODE_TYPES.UpdateExpression &&
-            hasObservableMutationTarget(node.argument, inspectionContext)) {
-            reportSideEffect(node.argument, inspectionContext, report);
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
         }
         if (node.type === AST_NODE_TYPES.UnaryExpression &&
             node.operator === 'delete' &&
-            hasObservableMutationTarget(node.argument, inspectionContext)) {
-            reportSideEffect(node.argument, inspectionContext, report);
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            hasSideEffect = true;
+            return false;
+        }
+        return;
+    });
+    return hasSideEffect;
+}
+function inspectComputedBody(root, context, localScopes, visitedFunctions, report) {
+    walkSynchronousAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            if (isDirectAngularSideEffectCall(node, context)) {
+                reportSideEffect(node, context, report);
+                return false;
+            }
+            if (isAngularUntrackedCall(node, context.program)) {
+                const callback = getReactiveCallbackArgument(node);
+                if (callback) {
+                    inspectComputedBody(callback, context, [...localScopes, callback], visitedFunctions, report);
+                }
+                return false;
+            }
+            if (isReactiveCallback(node.callee)) {
+                inspectComputedBody(node.callee, context, [...localScopes, node.callee], visitedFunctions, report);
+                return false;
+            }
+            for (const calledFunction of resolveCalledFunctions(node, context)) {
+                const key = String(calledFunction.range);
+                if (visitedFunctions.has(key)) {
+                    continue;
+                }
+                visitedFunctions.add(key);
+                const calledFunctionHasSideEffects = functionHasObservableSideEffects(calledFunction, context, [...localScopes, calledFunction], visitedFunctions);
+                visitedFunctions.delete(key);
+                if (!calledFunctionHasSideEffects) {
+                    continue;
+                }
+                reportSideEffect(node, context, report);
+                return false;
+            }
+        }
+        if (node.type === AST_NODE_TYPES.AssignmentExpression &&
+            hasObservableMutationTarget(node.left, context, localScopes)) {
+            reportSideEffect(node.left, context, report);
+        }
+        if (node.type === AST_NODE_TYPES.UpdateExpression &&
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            reportSideEffect(node.argument, context, report);
+        }
+        if (node.type === AST_NODE_TYPES.UnaryExpression &&
+            node.operator === 'delete' &&
+            hasObservableMutationTarget(node.argument, context, localScopes)) {
+            reportSideEffect(node.argument, context, report);
         }
         return;
     });
 }
 const rule$b = createRule$8({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
+        const estreeNodeMap = tsNodeToESTreeNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
                     if (scope.kind !== 'computed()') {
                         continue;
                     }
-                    const inspectionContext = {
-                        callback: scope.callback,
+                    const analysisContext = {
                         checker,
-                        esTreeNodeToTSNodeMap,
+                        esTreeNodeToTSNodeMap: signalNodeMap,
                         program,
                         reported: new Set(),
-                        tsNodeToESTreeNodeMap,
+                        tsNodeToESTreeNodeMap: estreeNodeMap,
                     };
-                    inspectComputedBody(scope.callback, inspectionContext, (reportNode) => {
+                    inspectComputedBody(scope.callback, analysisContext, [scope.callback], new Set([String(scope.callback.range)]), (reportNode) => {
                         context.report({
                             data: { expression: sourceCode.getText(reportNode) },
                             messageId: 'sideEffectInComputed',
@@ -3633,11 +3968,8 @@ const rule$b = createRule$8({
 
 const rule$a = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
@@ -3645,7 +3977,7 @@ const rule$a = createUntrackedRule({
                     walkAfterAsyncBoundaryAst(scope.callback, (inner) => {
                         if (inner.type !== AST_NODE_TYPES.CallExpression ||
                             isAngularUntrackedCall(inner, program) ||
-                            !isSignalReadCall(inner, checker, esTreeNodeToTSNodeMap)) {
+                            !isSignalReadCall(inner, checker, signalNodeMap)) {
                             return;
                         }
                         const key = String(inner.range);
@@ -3681,10 +4013,6 @@ const rule$a = createUntrackedRule({
 });
 
 const createRule$7 = ESLintUtils.RuleCreator((name) => name);
-function isStringLiteral(node) {
-    return (node.type === AST_NODE_TYPES.Literal &&
-        typeof node.value === 'string');
-}
 function collectParts(node) {
     if (node.type === AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
         return [...collectParts(node.left), ...collectParts(node.right)];
@@ -3734,16 +4062,6 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-function hasTemplateLiteralAncestor(node) {
-    let current = node.parent;
-    while (current != null) {
-        if (current.type === AST_NODE_TYPES.TemplateLiteral) {
-            return true;
-        }
-        current = current.parent;
-    }
-    return false;
-}
 const rule$9 = createRule$7({
     create(context) {
         const { sourceCode } = context;
@@ -3799,7 +4117,7 @@ const rule$9 = createRule$7({
                 }
                 // Nested inside a template but not direct child — would produce
                 // `${`${a}${b}`.method()}`, so skip
-                if (hasTemplateLiteralAncestor(node)) {
+                if (hasAncestor(node, (ancestor) => ancestor.type === AST_NODE_TYPES.TemplateLiteral)) {
                     return;
                 }
                 context.report({
@@ -3913,67 +4231,6 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
     return [fixer.remove(untrackedSpec)];
 }
 
-const IMPERATIVE_UNTRACKED_METHODS = new Set(['registerOnChange', 'writeValue']);
-function dedent$1(text, extraSpaces) {
-    if (extraSpaces <= 0) {
-        return text;
-    }
-    const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
-        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
-}
-function isFunctionLike(node) {
-    return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-        node.type === AST_NODE_TYPES.FunctionDeclaration ||
-        node.type === AST_NODE_TYPES.FunctionExpression);
-}
-function getObjectPropertyName(node) {
-    if (node.computed) {
-        return null;
-    }
-    if (node.key.type === AST_NODE_TYPES.Identifier) {
-        return node.key.name;
-    }
-    return typeof node.key.value === 'string' ? node.key.value : null;
-}
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && node.property.type === AST_NODE_TYPES.Identifier) {
-        return node.property.name;
-    }
-    return node.property.type === AST_NODE_TYPES.Literal &&
-        typeof node.property.value === 'string'
-        ? node.property.value
-        : null;
-}
-function getEnclosingClassMember(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (current.type === AST_NODE_TYPES.MethodDefinition ||
-            current.type === AST_NODE_TYPES.PropertyDefinition) {
-            return current;
-        }
-    }
-    return null;
-}
-function getEnclosingFunction(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (isFunctionLike(current)) {
-            return current;
-        }
-    }
-    return null;
-}
-function getClassMemberName(member) {
-    if (member.key.type === AST_NODE_TYPES.Identifier) {
-        return member.key.name;
-    }
-    if (member.key.type === AST_NODE_TYPES.Literal &&
-        typeof member.key.value === 'string') {
-        return member.key.value;
-    }
-    return null;
-}
 function hasNamedDecorator(node, name) {
     return node.decorators.some((decorator) => {
         const expression = decorator.expression;
@@ -3985,68 +4242,75 @@ function hasNamedDecorator(node, name) {
             expression.callee.name === name);
     });
 }
+
 function isPipeTransformMember(member) {
     if (getClassMemberName(member) !== 'transform') {
         return false;
     }
-    return hasNamedDecorator(member.parent.parent, 'Pipe');
+    const ownerClass = getEnclosingClass(member);
+    return !!ownerClass && hasNamedDecorator(ownerClass, 'Pipe');
 }
-function hasAllowedImperativeAssignment(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (!isFunctionLike(current)) {
-            continue;
-        }
-        const parent = current.parent;
-        if (parent.type === AST_NODE_TYPES.AssignmentExpression &&
-            parent.right === current &&
-            parent.left.type === AST_NODE_TYPES.MemberExpression) {
-            const memberName = getMemberExpressionPropertyName(parent.left);
-            if (memberName && IMPERATIVE_UNTRACKED_METHODS.has(memberName)) {
-                return true;
-            }
-        }
+
+function isAngularInjectionTokenFactoryFunction(fn, program) {
+    const parent = fn.parent;
+    const injectionTokenName = getLocalNameForImport(program, '@angular/core', 'InjectionToken');
+    if (!injectionTokenName ||
+        parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'factory') {
+        return false;
     }
-    return false;
-}
-function isAllowedImperativeAngularContext(node) {
-    const member = getEnclosingClassMember(node);
-    const memberName = member ? getClassMemberName(member) : null;
-    return ((!!member &&
-        !!memberName &&
-        (IMPERATIVE_UNTRACKED_METHODS.has(memberName) ||
-            isPipeTransformMember(member))) ||
-        hasAllowedImperativeAssignment(node));
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.parent.type === AST_NODE_TYPES.NewExpression &&
+        objectExpression.parent.arguments.includes(objectExpression) &&
+        objectExpression.parent.callee.type === AST_NODE_TYPES.Identifier &&
+        objectExpression.parent.callee.name === injectionTokenName);
 }
-function isDirectCallbackArgument(fn) {
+function isAngularUseFactoryFunction(fn) {
     const parent = fn.parent;
-    if (fn.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-        fn.type !== AST_NODE_TYPES.FunctionExpression) {
+    if (parent.type !== AST_NODE_TYPES.Property ||
+        getObjectPropertyName(parent) !== 'useFactory') {
         return false;
     }
-    return ((parent.type === AST_NODE_TYPES.CallExpression ||
-        parent.type === AST_NODE_TYPES.NewExpression) &&
-        parent.arguments.includes(fn));
+    const objectExpression = parent.parent;
+    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
+        objectExpression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
+            getObjectPropertyName(property) === 'provide'));
 }
-function getScopeRoot(node) {
-    for (let current = node.parent; current; current = current.parent) {
-        if (current.type === AST_NODE_TYPES.Program || isFunctionLike(current)) {
-            return current;
-        }
+
+/**
+ * Removes `extraSpaces` leading spaces from every line of `text` that starts
+ * with at least that many spaces.
+ */
+function dedent(text, extraSpaces) {
+    if (extraSpaces <= 0) {
+        return text;
+    }
+    const prefix = ' '.repeat(extraSpaces);
+    return text
+        .split('\n')
+        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
+        .join('\n');
+}
+
+function isDirectCallOrNewArgument(node) {
+    const parent = node.parent;
+    if (node.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== AST_NODE_TYPES.FunctionExpression) {
+        return false;
     }
-    return node;
+    return ((parent.type === AST_NODE_TYPES.CallExpression ||
+        parent.type === AST_NODE_TYPES.NewExpression) &&
+        parent.arguments.includes(node));
 }
-function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
+function isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap) {
     const parent = fn.parent;
     if (parent.type !== AST_NODE_TYPES.VariableDeclarator ||
         parent.id.type !== AST_NODE_TYPES.Identifier) {
         return false;
     }
     const id = parent.id;
-    const tsNode = esTreeNodeToTSNodeMap.get(id);
-    if (!tsNode) {
-        return false;
-    }
-    const symbol = checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(id, checker, esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
     }
@@ -4058,10 +4322,7 @@ function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
             node.name !== id.name) {
             return;
         }
-        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
-        const referenceSymbol = referenceTsNode
-            ? checker.getSymbolAtLocation(referenceTsNode)
-            : null;
+        const referenceSymbol = getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap);
         if (referenceSymbol !== symbol) {
             return;
         }
@@ -4076,81 +4337,50 @@ function isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap) {
     });
     return found;
 }
+
+const IMPERATIVE_UNTRACKED_METHODS = new Set(['registerOnChange', 'writeValue']);
+function hasAllowedImperativeAssignment(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
+            current.type !== AST_NODE_TYPES.FunctionDeclaration &&
+            current.type !== AST_NODE_TYPES.FunctionExpression) {
+            continue;
+        }
+        const parent = current.parent;
+        if (parent.type === AST_NODE_TYPES.AssignmentExpression &&
+            parent.right === current &&
+            parent.left.type === AST_NODE_TYPES.MemberExpression) {
+            const memberName = getMemberExpressionPropertyName(parent.left);
+            if (memberName && IMPERATIVE_UNTRACKED_METHODS.has(memberName)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function isAllowedImperativeAngularContext(node) {
+    const member = getEnclosingClassMember(node);
+    const memberName = member ? getClassMemberName(member) : null;
+    return ((!!member &&
+        !!memberName &&
+        (IMPERATIVE_UNTRACKED_METHODS.has(memberName) ||
+            isPipeTransformMember(member))) ||
+        hasAllowedImperativeAssignment(node));
+}
 function isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    if (!getReactiveCallbackArgument(node)) {
         return false;
     }
     const fn = getEnclosingFunction(node);
     if (!fn) {
         return false;
     }
-    return (isDirectCallbackArgument(fn) ||
-        isStoredCallbackUsedAsArgument(fn, checker, esTreeNodeToTSNodeMap));
-}
-function isAngularInjectionTokenFactoryFunction(fn, program) {
-    const parent = fn.parent;
-    const injectionTokenName = getLocalNameForImport(program, '@angular/core', 'InjectionToken');
-    if (!injectionTokenName ||
-        parent.type !== AST_NODE_TYPES.Property ||
-        getObjectPropertyName(parent) !== 'factory') {
-        return false;
-    }
-    const objectExpression = parent.parent;
-    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
-        objectExpression.parent.type === AST_NODE_TYPES.NewExpression &&
-        objectExpression.parent.arguments.includes(objectExpression) &&
-        objectExpression.parent.callee.type === AST_NODE_TYPES.Identifier &&
-        objectExpression.parent.callee.name === injectionTokenName);
-}
-function isAngularUseFactoryFunction(fn) {
-    const parent = fn.parent;
-    if (parent.type !== AST_NODE_TYPES.Property ||
-        getObjectPropertyName(parent) !== 'useFactory') {
-        return false;
-    }
-    const objectExpression = parent.parent;
-    return (objectExpression.type === AST_NODE_TYPES.ObjectExpression &&
-        objectExpression.properties.some((property) => property.type === AST_NODE_TYPES.Property &&
-            getObjectPropertyName(property) === 'provide'));
-}
-function isReactiveOwnerCall(node, program) {
-    return (node.type === AST_NODE_TYPES.CallExpression &&
-        getReactiveScopes(node, program).length > 0);
-}
-function getFixableReactiveCall(node, program) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
-        return null;
-    }
-    if (isReactiveOwnerCall(arg.body, program)) {
-        return arg.body;
-    }
-    if (arg.body.type !== AST_NODE_TYPES.BlockStatement || arg.body.body.length !== 1) {
-        return null;
-    }
-    const [statement] = arg.body.body;
-    if (statement?.type === AST_NODE_TYPES.ReturnStatement &&
-        statement.argument &&
-        isReactiveOwnerCall(statement.argument, program)) {
-        return statement.argument;
-    }
-    if (node.parent.type === AST_NODE_TYPES.ExpressionStatement &&
-        statement?.type === AST_NODE_TYPES.ExpressionStatement &&
-        isReactiveOwnerCall(statement.expression, program)) {
-        return statement.expression;
-    }
-    return null;
+    return (isDirectCallOrNewArgument(fn) ||
+        isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap));
 }
 function isAllowedLazyAngularFactoryContext(node, program) {
     const fn = getEnclosingFunction(node);
-    if (!fn || !getFixableReactiveCall(node, program)) {
+    if (!fn || !getReturnedReactiveOwnerCall(node, program)) {
         return false;
     }
     return (isAngularInjectionTokenFactoryFunction(fn, program) ||
@@ -4162,16 +4392,12 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
         outerUntrackedCall.parent.type !== AST_NODE_TYPES.ExpressionStatement) {
         return text;
     }
-    return dedent$1(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
+    return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
 const rule$8 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
-        const getUntrackedLocalName = () => findUntrackedAlias(program);
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         function isUntrackedUsedElsewhere(localName, excludeNode) {
             let found = false;
             walkAst(program, (node) => {
@@ -4192,18 +4418,18 @@ const rule$8 = createUntrackedRule({
                     findEnclosingReactiveScope(node, program) ||
                     findEnclosingReactiveScopeAfterAsyncBoundary(node, program) ||
                     isAllowedImperativeAngularContext(node) ||
-                    isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap) ||
+                    isAllowedDeferredCallbackContext(node, checker, signalNodeMap) ||
                     isAllowedLazyAngularFactoryContext(node, program)) {
                     return;
                 }
-                const reactiveCall = getFixableReactiveCall(node, program);
+                const reactiveCall = getReturnedReactiveOwnerCall(node, program);
                 context.report({
                     fix: reactiveCall
                         ? (fixer) => {
                             const fixes = [
                                 fixer.replaceText(node, buildReactiveCallReplacement(node, reactiveCall, sourceCode)),
                             ];
-                            const untrackedLocalName = getUntrackedLocalName();
+                            const untrackedLocalName = findUntrackedAlias(program);
                             const stillUsed = untrackedLocalName !== null &&
                                 isUntrackedUsedElsewhere(untrackedLocalName, node);
                             if (!stillUsed) {
@@ -4235,20 +4461,16 @@ const rule$8 = createUntrackedRule({
     name: 'no-untracked-outside-reactive-context',
 });
 
-/**
- * Removes `extraSpaces` leading spaces from every line of `text` that starts
- * with at least that many spaces.
- */
-function dedent(text, extraSpaces) {
-    if (extraSpaces <= 0) {
-        return text;
-    }
-    const prefix = ' '.repeat(extraSpaces);
-    return text
-        .split('\n')
-        .map((line) => (line.startsWith(prefix) ? line.slice(extraSpaces) : line))
-        .join('\n');
+function collectCallExpressions(root) {
+    const result = [];
+    walkAst(root, (node) => {
+        if (node.type === AST_NODE_TYPES.CallExpression) {
+            result.push(node);
+        }
+    });
+    return result;
 }
+
 /**
  * Builds the replacement text for the parent ExpressionStatement of an
  * `untracked(...)` call.
@@ -4260,13 +4482,11 @@ function dedent(text, extraSpaces) {
  * Returns null if the untracked argument is not a function expression.
  */
 function buildReplacement(untrackedCall, parentStatement, sourceCode) {
-    const [arg] = untrackedCall.arguments;
-    if (!arg ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    const callback = getReactiveCallbackArgument(untrackedCall);
+    if (!callback) {
         return null;
     }
-    const { body } = arg;
+    const { body } = callback;
     if (body.type === AST_NODE_TYPES.BlockStatement) {
         const { body: stmts } = body;
         if (stmts.length === 0) {
@@ -4281,15 +4501,6 @@ function buildReplacement(untrackedCall, parentStatement, sourceCode) {
     // Expression body: arrow `() => expr` — just emit `expr;`
     return `${sourceCode.getText(body)};`;
 }
-function getAllCallExpressions(root) {
-    const result = [];
-    walkAst(root, (node) => {
-        if (node.type === AST_NODE_TYPES.CallExpression) {
-            result.push(node);
-        }
-    });
-    return result;
-}
 function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program) {
     let found = false;
     walkSynchronousAst(root, (node) => {
@@ -4313,27 +4524,21 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
 }
 const rule$7 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
-        const getUntrackedLocalName = () => getLocalNameForImport(program, '@angular/core', 'untracked');
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         function isUntrackedUsedElsewhere(localName, excludeNode) {
-            return getAllCallExpressions(program).some((n) => n !== excludeNode &&
+            return collectCallExpressions(program).some((n) => n !== excludeNode &&
                 n.callee.type === AST_NODE_TYPES.Identifier &&
                 n.callee.name === localName);
         }
         function checkUntrackedCall(untrackedCall, kind) {
-            const [arg] = untrackedCall.arguments;
-            if (!arg ||
-                (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-                    arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+            const callback = getReactiveCallbackArgument(untrackedCall);
+            if (!callback) {
                 return;
             }
-            const { reads } = collectSignalUsages(arg, checker, esTreeNodeToTSNodeMap, program);
+            const { reads } = collectSignalUsages(callback, checker, signalNodeMap, program);
             if (reads.length > 0 ||
-                hasOpaqueSynchronousCalls(arg, checker, esTreeNodeToTSNodeMap, program)) {
+                hasOpaqueSynchronousCalls(callback, checker, signalNodeMap, program)) {
                 // Snapshot reads inside reactive callbacks are a valid Angular
                 // pattern even when the snapshot later influences branching.
                 return;
@@ -4351,7 +4556,7 @@ const rule$7 = createUntrackedRule({
                         if (replacement === null) {
                             return null;
                         }
-                        const untrackedLocalName = getUntrackedLocalName();
+                        const untrackedLocalName = findUntrackedAlias(program);
                         const stillUsed = untrackedLocalName !== null &&
                             isUntrackedUsedElsewhere(untrackedLocalName, untrackedCall);
                         const fixes = [fixer.replaceText(parentStmt, replacement)];
@@ -4654,22 +4859,6 @@ const rule$6 = createRule$6({
 
 const createRule$5 = ESLintUtils.RuleCreator((name) => name);
 const EMPTY_ARGUMENT = '__EMPTY_ARGUMENT__';
-function getParenthesizedInner(node) {
-    const maybeNode = node;
-    if (maybeNode.type === 'ParenthesizedExpression') {
-        return maybeNode.expression ?? null;
-    }
-    return null;
-}
-function unwrapParenthesized(node) {
-    let current = node;
-    let inner = getParenthesizedInner(current);
-    while (inner) {
-        current = inner;
-        inner = getParenthesizedInner(current);
-    }
-    return current;
-}
 function isSupportedControlFlowStatement(node) {
     return (node.type === AST_NODE_TYPES.BreakStatement ||
         node.type === AST_NODE_TYPES.ContinueStatement ||
@@ -5309,17 +5498,6 @@ function unwrapUsageExpression(node) {
     }
     return current;
 }
-function isNodeInside(node, ancestor) {
-    for (let current = node; current; current = current.parent) {
-        if (current === ancestor) {
-            return true;
-        }
-    }
-    return false;
-}
-function isNodeInsideAny(node, ancestors) {
-    return ancestors.some((ancestor) => isNodeInside(node, ancestor));
-}
 function isStatementPositionCall(node) {
     const usage = unwrapUsageExpression(node);
     if (usage.parent?.type === AST_NODE_TYPES.ExpressionStatement) {
@@ -5372,11 +5550,7 @@ function isAliasDeclarationIdentifier(node) {
         node.parent.id === node);
 }
 function aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap) {
-    const tsNode = esTreeNodeToTSNodeMap.get(alias);
-    if (!tsNode) {
-        return false;
-    }
-    const symbol = checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(alias, checker, esTreeNodeToTSNodeMap);
     if (!symbol) {
         return false;
     }
@@ -5388,10 +5562,7 @@ function aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSN
             isNodeInsideAny(node, consumers)) {
             return;
         }
-        const referenceTsNode = esTreeNodeToTSNodeMap.get(node);
-        const referenceSymbol = referenceTsNode
-            ? checker.getSymbolAtLocation(referenceTsNode)
-            : null;
+        const referenceSymbol = getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap);
         if (referenceSymbol !== symbol) {
             return;
         }
@@ -5418,11 +5589,7 @@ function resolveSignalReadAlias(expression, context, seen = new Set()) {
     if (unwrapped.type !== AST_NODE_TYPES.Identifier) {
         return null;
     }
-    const tsNode = context.esTreeNodeToTSNodeMap.get(unwrapped);
-    if (!tsNode) {
-        return null;
-    }
-    const symbol = context.checker.getSymbolAtLocation(tsNode);
+    const symbol = getSymbolAtNode(unwrapped, context.checker, context.esTreeNodeToTSNodeMap);
     if (!symbol) {
         return null;
     }
@@ -5510,12 +5677,9 @@ function collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToE
 }
 const rule$3 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const tsNodeToESTreeNodeMap = parserServices.tsNodeToESTreeNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
+        const estreeNodeMap = tsNodeToESTreeNodeMap;
         function buildFix(read) {
             const untrackedAlias = findUntrackedAlias(program);
             const alreadyHasUntracked = untrackedAlias !== null;
@@ -5531,13 +5695,13 @@ const rule$3 = createUntrackedRule({
         return {
             CallExpression(node) {
                 for (const scope of getReactiveScopes(node, program)) {
-                    const suspicious = collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToESTreeNodeMap, program);
-                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, esTreeNodeToTSNodeMap, program);
+                    const suspicious = collectSuspiciousReads(scope, checker, signalNodeMap, estreeNodeMap, program);
+                    const { reads: trackedReads } = collectSignalUsages(scope.callback, checker, signalNodeMap, program);
                     const suspiciousReads = new Set(suspicious.map(({ read }) => read));
                     for (const { aliases, consumers, read } of suspicious) {
                         const hasTrackedDependency = consumers.some((consumer) => trackedReads.some((trackedRead) => !suspiciousReads.has(trackedRead) &&
                             !isNodeInside(trackedRead, consumer)));
-                        const hasExternalAliasUsage = aliases.some((alias) => aliasHasExternalUsage(alias, consumers, scope, checker, esTreeNodeToTSNodeMap));
+                        const hasExternalAliasUsage = aliases.some((alias) => aliasHasExternalUsage(alias, consumers, scope, checker, signalNodeMap));
                         if (!hasTrackedDependency || hasExternalAliasUsage) {
                             continue;
                         }
@@ -5569,7 +5733,7 @@ const rule$3 = createUntrackedRule({
 
 function getReturnedExpression(node) {
     if (node.body.type !== AST_NODE_TYPES.BlockStatement) {
-        return unwrapExpression(node.body);
+        return node.body;
     }
     if (node.body.body.length !== 1) {
         return null;
@@ -5578,17 +5742,16 @@ function getReturnedExpression(node) {
     if (statement?.type !== AST_NODE_TYPES.ReturnStatement || !statement.argument) {
         return null;
     }
-    return unwrapExpression(statement.argument);
+    return statement.argument;
 }
+
 function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
-    const [arg] = node.arguments;
-    if (!arg ||
-        arg.type === AST_NODE_TYPES.SpreadElement ||
-        (arg.type !== AST_NODE_TYPES.ArrowFunctionExpression &&
-            arg.type !== AST_NODE_TYPES.FunctionExpression)) {
+    const callback = getReactiveCallbackArgument(node);
+    if (!callback) {
         return null;
     }
-    const body = getReturnedExpression(arg);
+    const returnedExpression = getReturnedExpression(callback);
+    const body = returnedExpression ? unwrapExpression(returnedExpression) : null;
     if (body?.type !== AST_NODE_TYPES.CallExpression ||
         !isSignalReadCall(body, checker, esTreeNodeToTSNodeMap)) {
         return null;
@@ -5602,17 +5765,14 @@ function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
 }
 const rule$2 = createUntrackedRule({
     create(context) {
-        const parserServices = ESLintUtils.getParserServices(context);
-        const checker = parserServices.program.getTypeChecker();
-        const esTreeNodeToTSNodeMap = parserServices.esTreeNodeToTSNodeMap;
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
+        const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
         return {
             CallExpression(node) {
                 if (!isAngularUntrackedCall(node, program)) {
                     return;
                 }
-                const getter = getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap);
+                const getter = getWrappedSignalGetter(node, checker, signalNodeMap);
                 if (!getter) {
                     return;
                 }
@@ -5639,13 +5799,6 @@ const rule$2 = createUntrackedRule({
     name: 'prefer-untracked-signal-getter',
 });
 
-function getImportedName(spec) {
-    if (spec.imported.type === AST_NODE_TYPES.Identifier) {
-        return spec.imported.name;
-    }
-    return spec.imported.value;
-}
-
 function isImportsArrayProperty(property) {
     const isProperty = property?.type === AST_NODE_TYPES.Property;
     const hasIdentifierKey = property?.key.type === AST_NODE_TYPES.Identifier &&
@@ -5653,6 +5806,13 @@ function isImportsArrayProperty(property) {
     return isProperty && hasIdentifierKey && isArray(property.value);
 }
 
+function getImportedName(spec) {
+    if (spec.imported.type === AST_NODE_TYPES.Identifier) {
+        return spec.imported.name;
+    }
+    return spec.imported.value;
+}
+
 const MESSAGE_ID = 'replaceTuiImport';
 const DEFAULT_DECORATORS = ['Component', 'Directive', 'NgModule', 'Pipe'];
 const DEFAULT_EXCEPTIONS = [
@@ -6063,14 +6223,15 @@ const plugin = {
         'class-property-naming': classPropertyNaming,
         'decorator-key-sort': config$3,
         'flat-exports': flatExports,
-        'host-attributes-sort': rule$j,
+        'host-attributes-sort': rule$k,
         'html-logical-properties': config$2,
-        'injection-token-description': rule$i,
-        'no-deep-imports': rule$h,
+        'injection-token-description': rule$j,
+        'no-deep-imports': rule$i,
         'no-deep-imports-to-indexed-packages': noDeepImportsToIndexedPackages,
-        'no-fully-untracked-effect': rule$g,
+        'no-fully-untracked-effect': rule$h,
         'no-href-with-router-link': config$1,
-        'no-implicit-public': rule$f,
+        'no-implicit-public': rule$g,
+        'no-infinite-loop': rule$f,
         'no-legacy-peer-deps': rule$e,
         'no-playwright-empty-fill': rule$d,
         'no-project-as-in-ng-template': config,