@dereekb/dbx-web 13.11.13 → 13.11.15

package/eslint/index.esm.js

@@ -121,22 +121,20 @@
  * @returns The decorator name, or empty string when unrecognized.
  */ function getDecoratorName(decorator) {
     var expression = decorator === null || decorator === void 0 ? void 0 : decorator.expression;
-    if (!expression) {
-        return '';
-    }
-    if (expression.type === 'CallExpression') {
-        var _expression_callee, _expression_callee1, _expression_callee_property;
-        if (((_expression_callee = expression.callee) === null || _expression_callee === void 0 ? void 0 : _expression_callee.type) === 'Identifier') {
-            return expression.callee.name;
-        }
-        if (((_expression_callee1 = expression.callee) === null || _expression_callee1 === void 0 ? void 0 : _expression_callee1.type) === 'MemberExpression' && ((_expression_callee_property = expression.callee.property) === null || _expression_callee_property === void 0 ? void 0 : _expression_callee_property.type) === 'Identifier') {
-            return expression.callee.property.name;
+    var result = '';
+    if (expression) {
+        if (expression.type === 'CallExpression') {
+            var _expression_callee, _expression_callee1, _expression_callee_property;
+            if (((_expression_callee = expression.callee) === null || _expression_callee === void 0 ? void 0 : _expression_callee.type) === 'Identifier') {
+                result = expression.callee.name;
+            } else if (((_expression_callee1 = expression.callee) === null || _expression_callee1 === void 0 ? void 0 : _expression_callee1.type) === 'MemberExpression' && ((_expression_callee_property = expression.callee.property) === null || _expression_callee_property === void 0 ? void 0 : _expression_callee_property.type) === 'Identifier') {
+                result = expression.callee.property.name;
+            }
+        } else if (expression.type === 'Identifier') {
+            result = expression.name;
         }
     }
-    if (expression.type === 'Identifier') {
-        return expression.name;
-    }
-    return '';
+    return result;
 }
 /**
  * Returns the first decorator on the class that names a component-tier
@@ -190,16 +188,15 @@
  * @returns The property name, or null when not a simple key.
  */ function getClassMemberName(member) {
     var key = member === null || member === void 0 ? void 0 : member.key;
-    if (!key || member.computed) {
-        return null;
-    }
-    if (key.type === 'Identifier') {
-        return key.name;
-    }
-    if (key.type === 'Literal' && typeof key.value === 'string') {
-        return key.value;
+    var result = null;
+    if (key && !member.computed) {
+        if (key.type === 'Identifier') {
+            result = key.name;
+        } else if (key.type === 'Literal' && typeof key.value === 'string') {
+            result = key.value;
+        }
     }
-    return null;
+    return result;
 }
 /**
  * Finds the `ngOnDestroy` method declaration on the given class, if any.
@@ -241,23 +238,23 @@
  * If the given expression is a `CallExpression` whose callee is one of the
  * accepted identifier names, returns the matching name. Otherwise null.
  *
+ * @param node - The expression AST node.
+ * @param names - The accepted identifier names.
+ * @returns The matched name, or null.
+ *
  * @example
  * ```
  * isCalledIdentifier(node, ['cleanSubscription', 'clean']) // returns 'cleanSubscription'
  * ```
- *
- * @param node - The expression AST node.
- * @param names - The accepted identifier names.
- * @returns The matched name, or null.
  */ function isCalledIdentifier(node, names) {
-    if ((node === null || node === void 0 ? void 0 : node.type) !== 'CallExpression') {
-        return null;
-    }
-    var callee = node.callee;
-    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier' && names.has(callee.name)) {
-        return callee.name;
+    var result = null;
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'CallExpression') {
+        var callee = node.callee;
+        if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier' && names.has(callee.name)) {
+            result = callee.name;
+        }
     }
-    return null;
+    return result;
 }
 /**
  * Returns true when the given AST node is a `this.<propName>` MemberExpression.
@@ -281,27 +278,26 @@
  */ function ensureNamedImportFix(input) {
     var fixer = input.fixer, registry = input.registry, importName = input.importName, fromSource = input.fromSource;
     var existing = registry.bySource.get(fromSource);
-    if (existing === null || existing === void 0 ? void 0 : existing.has(importName)) {
-        return null;
-    }
-    var declaration = registry.sourceToDeclaration.get(fromSource);
     var result = null;
-    if (declaration) {
-        var _declaration_specifiers;
-        var lastSpecifier = (_declaration_specifiers = declaration.specifiers) === null || _declaration_specifiers === void 0 ? void 0 : _declaration_specifiers[declaration.specifiers.length - 1];
-        if (lastSpecifier) {
-            var updatedSet = existing !== null && existing !== void 0 ? existing : new Set();
-            updatedSet.add(importName);
-            registry.bySource.set(fromSource, updatedSet);
+    if (!(existing === null || existing === void 0 ? void 0 : existing.has(importName))) {
+        var declaration = registry.sourceToDeclaration.get(fromSource);
+        if (declaration) {
+            var _declaration_specifiers;
+            var lastSpecifier = (_declaration_specifiers = declaration.specifiers) === null || _declaration_specifiers === void 0 ? void 0 : _declaration_specifiers[declaration.specifiers.length - 1];
+            if (lastSpecifier) {
+                var updatedSet = existing !== null && existing !== void 0 ? existing : new Set();
+                updatedSet.add(importName);
+                registry.bySource.set(fromSource, updatedSet);
+                registry.localToSource.set(importName, fromSource);
+                result = fixer.insertTextAfter(lastSpecifier, ", ".concat(importName));
+            }
+        } else if (registry.lastImportDeclaration) {
+            var updatedSet1 = existing !== null && existing !== void 0 ? existing : new Set();
+            updatedSet1.add(importName);
+            registry.bySource.set(fromSource, updatedSet1);
             registry.localToSource.set(importName, fromSource);
-            result = fixer.insertTextAfter(lastSpecifier, ", ".concat(importName));
+            result = fixer.insertTextAfter(registry.lastImportDeclaration, "\nimport { ".concat(importName, " } from '").concat(fromSource, "';"));
         }
-    } else if (registry.lastImportDeclaration) {
-        var updatedSet1 = existing !== null && existing !== void 0 ? existing : new Set();
-        updatedSet1.add(importName);
-        registry.bySource.set(fromSource, updatedSet1);
-        registry.localToSource.set(importName, fromSource);
-        result = fixer.insertTextAfter(registry.lastImportDeclaration, "\nimport { ".concat(importName, " } from '").concat(fromSource, "';"));
     }
     return result;
 }
@@ -419,7 +415,7 @@
  * - Rewrites the initializer to `cleanSubscription(...)` (preserving any constructor argument).
  * - Inserts the `cleanSubscription` named import from `@dereekb/dbx-core` if missing.
  * - Removes any matching `this.<field>.destroy();` line from the same class's `ngOnDestroy`.
- */ var dbxWebRequireCleanSubscriptionRule = {
+ */ var DBX_WEB_REQUIRE_CLEAN_SUBSCRIPTION_RULE = {
     meta: {
         type: 'problem',
         fixable: 'code',
@@ -657,7 +653,7 @@
  * - Wraps the initializer with `completeOnDestroy(...)`.
  * - Inserts the `completeOnDestroy` named import from `@dereekb/dbx-core` if missing.
  * - Removes any matching `this.<field>.complete();` line from the same class's `ngOnDestroy`.
- */ var dbxWebRequireCompleteOnDestroyRule = {
+ */ var DBX_WEB_REQUIRE_COMPLETE_ON_DESTROY_RULE = {
     meta: {
         type: 'problem',
         fixable: 'code',
@@ -826,7 +822,7 @@
  * - When a class declares `implements OnDestroy` from `@angular/core` but has
  *   no `ngOnDestroy()` method (e.g. left over from a previous run), the
  *   orphaned implements clause is removed.
- */ var dbxWebNoRedundantOnDestroyRule = {
+ */ var DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE = {
     meta: {
         type: 'suggestion',
         fixable: 'code',
@@ -845,59 +841,56 @@
     create: function create(context) {
         var registry = createImportRegistry();
         var sourceCode = context.sourceCode;
-        var visitClass = function visitClass(classNode) {
-            var _ngOnDestroy_value_body, _ngOnDestroy_value;
-            var matchedDecorator = findAngularComponentDecorator(classNode, registry);
-            if (!matchedDecorator) {
-                return;
-            }
-            var ngOnDestroy = findNgOnDestroyMethod(classNode);
-            var body = ngOnDestroy === null || ngOnDestroy === void 0 ? void 0 : (_ngOnDestroy_value = ngOnDestroy.value) === null || _ngOnDestroy_value === void 0 ? void 0 : (_ngOnDestroy_value_body = _ngOnDestroy_value.body) === null || _ngOnDestroy_value_body === void 0 ? void 0 : _ngOnDestroy_value_body.body;
-            if (!ngOnDestroy || !body) {
-                var implementsMatch = findOnDestroyImplementsClause(classNode, registry);
-                if (implementsMatch) {
-                    context.report({
-                        node: implementsMatch.clauseSpecifier,
-                        messageId: 'orphanedImplementsOnDestroy',
-                        fix: function fix(fixer) {
-                            return [
-                                fixer.removeRange(getImplementsSpecifierRemovalRange(implementsMatch, sourceCode))
-                            ];
-                        }
-                    });
-                }
-                return;
-            }
-            if (body.length === 0) {
+        var reportOrphanedImplements = function reportOrphanedImplements(classNode) {
+            var implementsMatch = findOnDestroyImplementsClause(classNode, registry);
+            if (implementsMatch) {
                 context.report({
-                    node: ngOnDestroy,
-                    messageId: 'emptyNgOnDestroy',
+                    node: implementsMatch.clauseSpecifier,
+                    messageId: 'orphanedImplementsOnDestroy',
                     fix: function fix(fixer) {
-                        return buildRemoveNgOnDestroyFixes({
-                            fixer: fixer,
-                            ngOnDestroy: ngOnDestroy,
-                            classNode: classNode,
-                            registry: registry,
-                            sourceCode: sourceCode
-                        });
+                        return [
+                            fixer.removeRange(getImplementsSpecifierRemovalRange(implementsMatch, sourceCode))
+                        ];
                     }
                 });
-                return;
             }
-            var wrappedFields = collectWrappedFieldNames(classNode);
-            var redundantStatements = [];
-            var hasNonRedundantStatement = false;
+        };
+        var reportRemoveNgOnDestroy = function reportRemoveNgOnDestroy(ngOnDestroy, classNode, messageId) {
+            context.report({
+                node: ngOnDestroy,
+                messageId: messageId,
+                fix: function fix(fixer) {
+                    return buildRemoveNgOnDestroyFixes({
+                        fixer: fixer,
+                        ngOnDestroy: ngOnDestroy,
+                        classNode: classNode,
+                        registry: registry,
+                        sourceCode: sourceCode
+                    });
+                }
+            });
+        };
+        var reportRedundantStatements = function reportRedundantStatements(entries) {
             var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
             try {
-                for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
-                    var statement = _step.value;
-                    var match = matchRedundantCleanupStatement(statement, wrappedFields);
-                    if (match) {
-                        redundantStatements.push(match);
-                    } else {
-                        hasNonRedundantStatement = true;
-                    }
-                }
+                var _loop = function() {
+                    var entry = _step.value;
+                    context.report({
+                        node: entry.statement,
+                        messageId: 'redundantCleanupCall',
+                        data: {
+                            name: entry.fieldName,
+                            method: entry.method,
+                            wrapper: entry.wrapper
+                        },
+                        fix: function fix(fixer) {
+                            return [
+                                fixer.removeRange(getStatementRangeWithLeadingWhitespace(entry.statement, sourceCode))
+                            ];
+                        }
+                    });
+                };
+                for(var _iterator = entries[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
             } catch (err) {
                 _didIteratorError = true;
                 _iteratorError = err;
@@ -912,58 +905,29 @@
                     }
                 }
             }
-            if (redundantStatements.length === 0) {
-                return;
+        };
+        var visitNgOnDestroyBody = function visitNgOnDestroyBody(ngOnDestroy, body, classNode) {
+            var _partitionNgOnDestroyStatements = partitionNgOnDestroyStatements(body, classNode), redundantStatements = _partitionNgOnDestroyStatements.redundantStatements, hasNonRedundantStatement = _partitionNgOnDestroyStatements.hasNonRedundantStatement;
+            if (redundantStatements.length > 0) {
+                if (hasNonRedundantStatement) {
+                    reportRedundantStatements(redundantStatements);
+                } else {
+                    reportRemoveNgOnDestroy(ngOnDestroy, classNode, 'redundantNgOnDestroy');
+                }
             }
-            if (hasNonRedundantStatement) {
-                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
-                try {
-                    var _loop = function() {
-                        var entry = _step1.value;
-                        context.report({
-                            node: entry.statement,
-                            messageId: 'redundantCleanupCall',
-                            data: {
-                                name: entry.fieldName,
-                                method: entry.method,
-                                wrapper: entry.wrapper
-                            },
-                            fix: function fix(fixer) {
-                                return [
-                                    fixer.removeRange(getStatementRangeWithLeadingWhitespace(entry.statement, sourceCode))
-                                ];
-                            }
-                        });
-                    };
-                    for(var _iterator1 = redundantStatements[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true)_loop();
-                } catch (err) {
-                    _didIteratorError1 = true;
-                    _iteratorError1 = err;
-                } finally{
-                    try {
-                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
-                            _iterator1.return();
-                        }
-                    } finally{
-                        if (_didIteratorError1) {
-                            throw _iteratorError1;
-                        }
-                    }
+        };
+        var visitClass = function visitClass(classNode) {
+            if (findAngularComponentDecorator(classNode, registry)) {
+                var _ngOnDestroy_value_body, _ngOnDestroy_value;
+                var ngOnDestroy = findNgOnDestroyMethod(classNode);
+                var body = ngOnDestroy === null || ngOnDestroy === void 0 ? void 0 : (_ngOnDestroy_value = ngOnDestroy.value) === null || _ngOnDestroy_value === void 0 ? void 0 : (_ngOnDestroy_value_body = _ngOnDestroy_value.body) === null || _ngOnDestroy_value_body === void 0 ? void 0 : _ngOnDestroy_value_body.body;
+                if (!ngOnDestroy || !body) {
+                    reportOrphanedImplements(classNode);
+                } else if (body.length === 0) {
+                    reportRemoveNgOnDestroy(ngOnDestroy, classNode, 'emptyNgOnDestroy');
+                } else {
+                    visitNgOnDestroyBody(ngOnDestroy, body, classNode);
                 }
-            } else {
-                context.report({
-                    node: ngOnDestroy,
-                    messageId: 'redundantNgOnDestroy',
-                    fix: function fix(fixer) {
-                        return buildRemoveNgOnDestroyFixes({
-                            fixer: fixer,
-                            ngOnDestroy: ngOnDestroy,
-                            classNode: classNode,
-                            registry: registry,
-                            sourceCode: sourceCode
-                        });
-                    }
-                });
             }
         };
         return {
@@ -1030,6 +994,87 @@
  */ function wrapperNameFromInitializer(expression) {
     return expression ? isCalledIdentifier(expression, HELPER_NAMES) : null;
 }
+/**
+ * Splits an `ngOnDestroy` body into redundant cleanup matches and a flag
+ * indicating whether any other (non-redundant) statement is present.
+ *
+ * @param body - The statements of the `ngOnDestroy` method body.
+ * @param classNode - The owning class node, used to gather wrapped fields.
+ * @returns The redundant matches and the non-redundant flag.
+ */ function partitionNgOnDestroyStatements(body, classNode) {
+    var wrappedFields = collectWrappedFieldNames(classNode);
+    var redundantStatements = [];
+    var hasNonRedundantStatement = false;
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = body[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var statement = _step.value;
+            var match = matchRedundantCleanupStatement(statement, wrappedFields);
+            if (match) {
+                redundantStatements.push(match);
+            } else {
+                hasNonRedundantStatement = true;
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return {
+        redundantStatements: redundantStatements,
+        hasNonRedundantStatement: hasNonRedundantStatement
+    };
+}
+/**
+ * Returns the redundant method name (`destroy` / `complete`) when the call
+ * expression is a zero-argument member call to one of those methods.
+ *
+ * @param expression - The expression to inspect.
+ * @returns The method name and its callee MemberExpression, or null.
+ */ function getRedundantMethodCall(expression) {
+    var _expression_arguments, _expression_callee;
+    var result = null;
+    var isZeroArgMemberCall = (expression === null || expression === void 0 ? void 0 : expression.type) === 'CallExpression' && ((_expression_arguments = expression.arguments) === null || _expression_arguments === void 0 ? void 0 : _expression_arguments.length) === 0 && ((_expression_callee = expression.callee) === null || _expression_callee === void 0 ? void 0 : _expression_callee.type) === 'MemberExpression';
+    if (isZeroArgMemberCall) {
+        var _callee_property;
+        var callee = expression.callee;
+        var methodName = !callee.computed && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' ? callee.property.name : null;
+        if (methodName && REDUNDANT_METHODS.has(methodName)) {
+            result = {
+                methodName: methodName,
+                callee: callee
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Returns the `this.<fieldName>` field name from a callee object, or null
+ * when the receiver is not a non-computed `this.<identifier>` access.
+ *
+ * @param calleeObject - The callee's object (the receiver of the method call).
+ * @returns The field name or null.
+ */ function getThisFieldName(calleeObject) {
+    var _calleeObject_property;
+    var result = null;
+    if ((calleeObject === null || calleeObject === void 0 ? void 0 : calleeObject.type) === 'MemberExpression' && !calleeObject.computed && ((_calleeObject_property = calleeObject.property) === null || _calleeObject_property === void 0 ? void 0 : _calleeObject_property.type) === 'Identifier') {
+        var fieldName = calleeObject.property.name;
+        if (isThisMemberAccess(calleeObject, fieldName)) {
+            result = fieldName;
+        }
+    }
+    return result;
+}
 /**
  * Returns details for a redundant cleanup statement, or null when the
  * statement is anything other than a redundant `this.<field>.<destroy|complete>()` call.
@@ -1040,25 +1085,16 @@
  */ function matchRedundantCleanupStatement(statement, wrappedFields) {
     var result = null;
     if (statement.type === 'ExpressionStatement') {
-        var _call_arguments, _call_callee;
-        var call = statement.expression;
-        var isZeroArgMemberCall = (call === null || call === void 0 ? void 0 : call.type) === 'CallExpression' && ((_call_arguments = call.arguments) === null || _call_arguments === void 0 ? void 0 : _call_arguments.length) === 0 && ((_call_callee = call.callee) === null || _call_callee === void 0 ? void 0 : _call_callee.type) === 'MemberExpression';
-        if (isZeroArgMemberCall) {
-            var _callee_property, _callee_object, _callee_object_property;
-            var callee = call.callee;
-            var methodName = !callee.computed && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' ? callee.property.name : null;
-            if (methodName && REDUNDANT_METHODS.has(methodName) && ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'MemberExpression' && ((_callee_object_property = callee.object.property) === null || _callee_object_property === void 0 ? void 0 : _callee_object_property.type) === 'Identifier' && !callee.object.computed) {
-                var fieldName = callee.object.property.name;
-                var wrapper = isThisMemberAccess(callee.object, fieldName) ? wrappedFields.get(fieldName) : undefined;
-                if (wrapper) {
-                    result = {
-                        statement: statement,
-                        fieldName: fieldName,
-                        method: methodName,
-                        wrapper: wrapper
-                    };
-                }
-            }
+        var methodCall = getRedundantMethodCall(statement.expression);
+        var fieldName = methodCall ? getThisFieldName(methodCall.callee.object) : null;
+        var wrapper = fieldName ? wrappedFields.get(fieldName) : undefined;
+        if (methodCall && fieldName && wrapper) {
+            result = {
+                statement: statement,
+                fieldName: fieldName,
+                method: methodCall.methodName,
+                wrapper: wrapper
+            };
         }
     }
     return result;
@@ -1081,17 +1117,1427 @@
     return fixes;
 }
 
+/**
+ * Initializer call names that produce a computed Signal whose property must end with `Signal`.
+ */ var COMPUTED_INITIALIZERS = new Set([
+    'computed'
+]);
+/**
+ * Initializer call names that produce a raw signal-input whose property must NOT end with `Signal`.
+ *
+ * Includes `input.required(...)` (handled below via CallExpression callee inspection) and
+ * `model.required(...)` — those are recognized when the callee's MemberExpression `object` name
+ * is in this set.
+ */ var INPUT_INITIALIZERS$1 = new Set([
+    'input',
+    'model'
+]);
+/**
+ * Suffix that distinguishes computed signals from raw input signals.
+ */ var SIGNAL_SUFFIX = 'Signal';
+/**
+ * ESLint rule that enforces the dbx-components Angular signal naming convention:
+ *
+ * - Class properties initialized with `computed(...)` must end with `Signal`.
+ * - Class properties initialized with `input(...)`, `input.required(...)`, `model(...)`,
+ *   or `model.required(...)` must NOT end with `Signal`.
+ *
+ * Fires only on classes decorated with `@Component`, `@Directive`, or `@Pipe` from
+ * `@angular/core`, and only when the relevant initializer identifier is imported from
+ * `@angular/core`.
+ *
+ * Not auto-fixable: renaming a class field also requires updating every reference in the
+ * class body and any associated templates, which is outside the safe scope of an ESLint
+ * autofix.
+ *
+ * @see `dbx__note__angular-conventions` → ANG-C2 Computed Signal Naming.
+ */ var DBX_WEB_REQUIRE_COMPUTED_SIGNAL_SUFFIX_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: undefined,
+        docs: {
+            description: 'Require the `Signal` suffix on computed() class properties and disallow it on input()/model() class properties in Angular component classes.',
+            recommended: true
+        },
+        messages: {
+            missingSignalSuffix: "Computed signal '{{property}}' must end with the 'Signal' suffix (e.g. '{{suggested}}') to distinguish it from raw input signals.",
+            signalSuffixOnInput: "Raw input signal '{{property}}' must NOT end with the 'Signal' suffix — reserve that for computed signals."
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var registry = createImportRegistry();
+        var visitClass = function visitClass(classNode) {
+            var _ref;
+            var _classNode_body;
+            var matched = findAngularComponentDecorator(classNode, registry);
+            if (!matched) {
+                return;
+            }
+            var members = (_ref = (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body) !== null && _ref !== void 0 ? _ref : [];
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var member = _step.value;
+                    if (member.type !== 'PropertyDefinition' || isStaticProperty(member) || isDeclareProperty(member)) {
+                        continue;
+                    }
+                    var propName = getClassMemberName(member);
+                    var initializer = member.value;
+                    if (!propName || (initializer === null || initializer === void 0 ? void 0 : initializer.type) !== 'CallExpression') {
+                        continue;
+                    }
+                    var initializerKind = classifyInitializer(initializer, registry);
+                    if (initializerKind === 'computed') {
+                        if (!propName.endsWith(SIGNAL_SUFFIX)) {
+                            var _member_key;
+                            context.report({
+                                node: (_member_key = member.key) !== null && _member_key !== void 0 ? _member_key : member,
+                                messageId: 'missingSignalSuffix',
+                                data: {
+                                    property: propName,
+                                    suggested: "".concat(propName).concat(SIGNAL_SUFFIX)
+                                }
+                            });
+                        }
+                    } else if (initializerKind === 'input' && propName.endsWith(SIGNAL_SUFFIX) && propName !== SIGNAL_SUFFIX) {
+                        var _member_key1;
+                        context.report({
+                            node: (_member_key1 = member.key) !== null && _member_key1 !== void 0 ? _member_key1 : member,
+                            messageId: 'signalSuffixOnInput',
+                            data: {
+                                property: propName
+                            }
+                        });
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+        };
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                trackImportDeclaration(registry, node);
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                visitClass(classNode);
+            },
+            ClassExpression: function ClassExpression(classNode) {
+                visitClass(classNode);
+            }
+        };
+    }
+};
+/**
+ * Classifies a CallExpression initializer as a computed signal, raw input signal, or neither.
+ *
+ * Recognizes:
+ * - `computed(...)` → `'computed'`
+ * - `input(...)`, `input.required(...)` → `'input'`
+ * - `model(...)`, `model.required(...)` → `'input'`
+ *
+ * Each form requires the root identifier to be imported from `@angular/core`.
+ *
+ * @param callExpression - The CallExpression AST node serving as the property initializer.
+ * @param registry - The file's import registry.
+ * @returns The initializer kind, or `null` when the call is unrelated.
+ */ function classifyInitializer(callExpression, registry) {
+    var _callee_object, _callee_property;
+    var callee = callExpression.callee;
+    var result = null;
+    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier') {
+        var name = callee.name;
+        if (COMPUTED_INITIALIZERS.has(name) && isImportedFrom(registry, name, ANGULAR_CORE_MODULE)) {
+            result = 'computed';
+        } else if (INPUT_INITIALIZERS$1.has(name) && isImportedFrom(registry, name, ANGULAR_CORE_MODULE)) {
+            result = 'input';
+        }
+    } else if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && callee.computed === false && ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'Identifier' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' && callee.property.name === 'required') {
+        var rootName = callee.object.name;
+        if (INPUT_INITIALIZERS$1.has(rootName) && isImportedFrom(registry, rootName, ANGULAR_CORE_MODULE)) {
+            result = 'input';
+        }
+    }
+    return result;
+}
+
+/**
+ * Initializer call identifiers that produce an Angular signal input.
+ *
+ * Includes the bare `input(...)` form and the `input.required(...)` member form.
+ * `model()` / `model.required()` are intentionally excluded — two-way bindings are
+ * rare and counting them would inflate the threshold for components that mix them
+ * sparingly. Extending the set is a one-line change.
+ */ var INPUT_INITIALIZERS = new Set([
+    'input'
+]);
+/**
+ * Default cap on the number of `input(...)` / `input.required(...)` properties a
+ * single Angular component-tier class may declare before the rule fires.
+ */ var DEFAULT_INPUT_THRESHOLD = 3;
+/**
+ * ESLint rule that flags `@Component` / `@Directive` / `@Pipe` classes which
+ * declare more than `threshold` (default 3) signal-input properties.
+ *
+ * When a component-tier class drifts past the threshold, the convention is to
+ * consolidate the loose inputs into a single config-typed input, e.g.
+ * `config = input<Maybe<DbxFooConfig>>()`. This rule does not enforce a specific
+ * property name or shape — it is purely a count, analogous to the workspace's
+ * `dereekb-util/prefer-config-object` rule for function parameters.
+ *
+ * Only `input(...)` and `input.required(...)` calls whose root identifier is
+ * imported from `@angular/core` are counted. Static and `declare` members are
+ * ignored, as are non-decorated classes and imports from other modules.
+ *
+ * Not auto-fixable: consolidating loose inputs into a config interface is a
+ * design-level refactor that updates the template, the consuming sites, and the
+ * type surface — outside the safe scope of an ESLint autofix.
+ *
+ * @see `dbx__note__angular-conventions` → ANG-C1 Component Config Input.
+ */ var DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE = {
+    meta: {
+        type: 'suggestion',
+        fixable: undefined,
+        docs: {
+            description: 'Disallow more than `threshold` (default 3) signal-input properties on a single @Component/@Directive/@Pipe class; consolidate them into a single config-typed input.',
+            recommended: true
+        },
+        messages: {
+            tooManySignalInputs: "Class '{{className}}' declares {{count}} signal inputs (more than {{threshold}}). Consolidate them into a single config-typed input (e.g. `config = input<Maybe<...Config>>()`). See dbx__note__angular-conventions → ANG-C1."
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    threshold: {
+                        type: 'number',
+                        minimum: 0,
+                        description: 'Maximum number of signal-input properties allowed before the rule reports. Defaults to 3.'
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+    create: function create(context) {
+        var _ref;
+        var _context_options;
+        var registry = createImportRegistry();
+        var options = (_ref = (_context_options = context.options) === null || _context_options === void 0 ? void 0 : _context_options[0]) !== null && _ref !== void 0 ? _ref : {};
+        var threshold = typeof options.threshold === 'number' ? options.threshold : DEFAULT_INPUT_THRESHOLD;
+        var visitClass = function visitClass(classNode) {
+            var _ref;
+            var _classNode_body;
+            var matched = findAngularComponentDecorator(classNode, registry);
+            if (!matched) {
+                return;
+            }
+            var members = (_ref = (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body) !== null && _ref !== void 0 ? _ref : [];
+            var inputCount = 0;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var member = _step.value;
+                    if (member.type !== 'PropertyDefinition' || isStaticProperty(member) || isDeclareProperty(member)) {
+                        continue;
+                    }
+                    var initializer = member.value;
+                    if ((initializer === null || initializer === void 0 ? void 0 : initializer.type) === 'CallExpression' && isAngularInputCall(initializer, registry)) {
+                        inputCount += 1;
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            if (inputCount > threshold) {
+                var _ref1, _classNode_id;
+                var _classNode_id1;
+                var className = (_ref1 = (_classNode_id1 = classNode.id) === null || _classNode_id1 === void 0 ? void 0 : _classNode_id1.name) !== null && _ref1 !== void 0 ? _ref1 : '<anonymous>';
+                context.report({
+                    node: (_classNode_id = classNode.id) !== null && _classNode_id !== void 0 ? _classNode_id : classNode,
+                    messageId: 'tooManySignalInputs',
+                    data: {
+                        className: className,
+                        count: String(inputCount),
+                        threshold: String(threshold)
+                    }
+                });
+            }
+        };
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                trackImportDeclaration(registry, node);
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                visitClass(classNode);
+            },
+            ClassExpression: function ClassExpression(classNode) {
+                visitClass(classNode);
+            }
+        };
+    }
+};
+/**
+ * Returns true when `callExpression` is a call to an Angular signal-input
+ * factory — either `input(...)` (Identifier callee) or `input.required(...)`
+ * (MemberExpression callee whose root identifier is `input`) — and the root
+ * identifier was imported from `@angular/core`.
+ *
+ * @param callExpression - The CallExpression AST node serving as a property initializer.
+ * @param registry - The file's import registry.
+ * @returns True when the call should be counted as a signal input.
+ */ function isAngularInputCall(callExpression, registry) {
+    var _callee_object, _callee_property;
+    var callee = callExpression.callee;
+    var result = false;
+    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier') {
+        var name = callee.name;
+        if (INPUT_INITIALIZERS.has(name) && isImportedFrom(registry, name, ANGULAR_CORE_MODULE)) {
+            result = true;
+        }
+    } else if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && callee.computed === false && ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'Identifier' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' && callee.property.name === 'required') {
+        var rootName = callee.object.name;
+        if (INPUT_INITIALIZERS.has(rootName) && isImportedFrom(registry, rootName, ANGULAR_CORE_MODULE)) {
+            result = true;
+        }
+    }
+    return result;
+}
+
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+/**
+ * Module that exposes the `toSignal` factory.
+ */ var ANGULAR_CORE_RXJS_INTEROP_MODULE = '@angular/core/rxjs-interop';
+/**
+ * Name of the Angular `computed` factory whose callbacks this rule inspects.
+ */ var COMPUTED_INITIALIZER_NAME = 'computed';
+/**
+ * Bare-identifier signal factories exported from `@angular/core`.
+ *
+ * Each name corresponds to a function that returns a Signal/InputSignal/
+ * WritableSignal/ModelSignal — the kind of getter the rule needs to track
+ * across class properties and module-level `const`s.
+ */ var ANGULAR_CORE_SIGNAL_FACTORIES = new Set([
+    'signal',
+    'computed',
+    'input',
+    'model',
+    'linkedSignal'
+]);
+/**
+ * `Identifier.required(...)` member-form factories. Each entry's value is the
+ * root identifier whose `required` property returns another signal factory.
+ *
+ * Example: `input.required<string>()` — `input` is the root identifier and
+ * the result is still an InputSignal.
+ */ var ANGULAR_CORE_REQUIRED_FACTORIES = new Set([
+    'input',
+    'model'
+]);
+/**
+ * Bare-identifier signal factories exported from `@angular/core/rxjs-interop`.
+ */ var ANGULAR_CORE_RXJS_INTEROP_SIGNAL_FACTORIES = new Set([
+    'toSignal'
+]);
+/**
+ * Signal type names exported from `@angular/core`. A property or variable
+ * whose declared type is one of these (and whose root identifier was imported
+ * from `@angular/core`) is treated as a signal getter, even when its
+ * initializer is not a recognized signal factory call (e.g. produced by a
+ * helper or returned from a base class).
+ */ var ANGULAR_CORE_SIGNAL_TYPE_NAMES = new Set([
+    'Signal',
+    'WritableSignal',
+    'InputSignal',
+    'InputSignalWithTransform',
+    'ModelSignal'
+]);
+/**
+ * Maximum number of characters from the offending call expression that should
+ * appear in the report message. Long expressions are truncated so the message
+ * stays readable in editor tooltips.
+ */ var CALL_PREVIEW_MAX_LENGTH = 40;
+/**
+ * ESLint rule that requires every signal read inside a `computed(() => { ... })`
+ * callback to appear in an unconditional, top-level position rather than
+ * inside a branching path (if/else, ternary, short-circuit, switch case,
+ * loop body, catch handler).
+ *
+ * Angular `computed` re-tracks its dependencies on every run, so a signal
+ * read that only happens inside one branch is not registered as a dependency
+ * when the other branch executes. When that signal subsequently changes the
+ * computed does not recompute and the value goes stale. Reading every signal
+ * up front — before any branching — keeps the dependency set stable.
+ *
+ * To avoid false positives on plain methods and utility functions, the rule
+ * only flags calls whose name can be statically traced back to a signal
+ * factory:
+ *
+ * - `this.<name>()` is flagged when `<name>` is a class property initialized
+ *   with one of `signal`, `computed`, `input`, `input.required`, `model`,
+ *   `model.required`, `linkedSignal` (from `@angular/core`), or `toSignal`
+ *   (from `@angular/core/rxjs-interop`).
+ * - `<name>()` (bare identifier) is flagged when `<name>` is a module-level
+ *   `const` initialized with one of those factories.
+ *
+ * Everything else — calls with arguments, chained property accesses on
+ * services, calls on local loop variables, calls on globals — is left
+ * alone. Cross-class signal tracking (e.g. `this.someService.someSignal()`)
+ * is intentionally out of scope: it would require type analysis to
+ * distinguish signal getters from plain getter methods, and the rule
+ * prefers a clean report set over partial coverage.
+ *
+ * Only `computed` identifiers imported from `@angular/core` are considered.
+ * Nested function expressions (callbacks passed to `.map` / `.filter` etc.)
+ * are not inspected because Angular does not synchronously track signals
+ * read inside them.
+ *
+ * Auto-fix: for each flagged callback, the fix inserts one
+ * `const <localName> = this.<signalName>();` (or `const <localName> = <signalName>();`
+ * for module-scope captures) at the top of the callback body and replaces
+ * every flagged call with `<localName>`. The local name is the signal name
+ * with the trailing `Signal` suffix removed when present (`xSignal` → `x`).
+ * If that name would shadow an existing local binding in the callback, the
+ * fix is skipped for that signal to avoid generating a syntax error.
+ * Expression-body callbacks (`computed(() => …)`) are converted to block
+ * bodies as part of the fix; the previous expression becomes the `return`
+ * value.
+ */ var DBX_WEB_REQUIRE_TOP_LEVEL_COMPUTED_SIGNALS_RULE = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require signal reads inside a computed() callback to occur in unconditional top-level statements, not inside if/else, ternary, short-circuit, switch, loop, or catch branches.',
+            recommended: true
+        },
+        messages: {
+            conditionalSignalRead: "Signal read '{{call}}' is inside a conditional execution path of computed(); hoist it to an unconditional top-level read before the branch so the computed tracks it on every run."
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var imports = createImportRegistry();
+        var signals = {
+            classSignalProps: new WeakMap(),
+            moduleSignalNames: new Set()
+        };
+        var visitClass = function visitClass(classNode) {
+            collectClassSignalProperties(classNode, imports, signals);
+        };
+        var inspectComputedCall = function inspectComputedCall(callNode) {
+            var _callNode_arguments;
+            if (!isComputedCall(callNode, imports)) {
+                return;
+            }
+            var callback = (_callNode_arguments = callNode.arguments) === null || _callNode_arguments === void 0 ? void 0 : _callNode_arguments[0];
+            if (!callback || !isFunctionNode(callback) || !callback.body) {
+                return;
+            }
+            var enclosingClass = findEnclosingClass(callNode);
+            var classSignalNames = enclosingClass ? signals.classSignalProps.get(enclosingClass) : null;
+            var violations = [];
+            // The function body itself is the entry point. Conditional state starts
+            // as `false` — top-level statements in the body run unconditionally.
+            walk(callback.body, false, {
+                classSignalNames: classSignalNames,
+                moduleSignalNames: signals.moduleSignalNames,
+                violations: violations
+            });
+            if (violations.length === 0) {
+                return;
+            }
+            reportViolations(callback, violations, context);
+        };
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                trackImportDeclaration(imports, node);
+            },
+            VariableDeclaration: function VariableDeclaration(node) {
+                collectModuleSignalConsts(node, imports, signals);
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                visitClass(classNode);
+            },
+            ClassExpression: function ClassExpression(classNode) {
+                visitClass(classNode);
+            },
+            CallExpression: function CallExpression(node) {
+                inspectComputedCall(node);
+            }
+        };
+    }
+};
+/**
+ * Returns true when `node` is a `computed(...)` call whose `computed`
+ * identifier was imported from `@angular/core`.
+ *
+ * @param node - The CallExpression AST node to test.
+ * @param imports - The file's import registry.
+ * @returns True when the call refers to Angular's `computed`.
+ */ function isComputedCall(node, imports) {
+    var _node_callee;
+    return (node === null || node === void 0 ? void 0 : node.type) === 'CallExpression' && ((_node_callee = node.callee) === null || _node_callee === void 0 ? void 0 : _node_callee.type) === 'Identifier' && node.callee.name === COMPUTED_INITIALIZER_NAME && isImportedFrom(imports, COMPUTED_INITIALIZER_NAME, ANGULAR_CORE_MODULE);
+}
+/**
+ * Returns true when `callExpression` is a call to one of the Angular signal
+ * factories whose return value is a Signal/InputSignal/WritableSignal/
+ * ModelSignal. Handles bare-identifier calls (`signal(...)`), required
+ * member-form calls (`input.required(...)`, `model.required(...)`), and
+ * `toSignal(...)` from `@angular/core/rxjs-interop`.
+ *
+ * @param callExpression - The CallExpression AST node serving as an initializer.
+ * @param imports - The file's import registry.
+ * @returns True when the call returns a signal.
+ */ function isSignalFactoryCall(callExpression, imports) {
+    var _callee_object, _callee_property;
+    var callee = callExpression === null || callExpression === void 0 ? void 0 : callExpression.callee;
+    var result = false;
+    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier') {
+        var name = callee.name;
+        if (ANGULAR_CORE_SIGNAL_FACTORIES.has(name) && isImportedFrom(imports, name, ANGULAR_CORE_MODULE)) {
+            result = true;
+        } else if (ANGULAR_CORE_RXJS_INTEROP_SIGNAL_FACTORIES.has(name) && isImportedFrom(imports, name, ANGULAR_CORE_RXJS_INTEROP_MODULE)) {
+            result = true;
+        }
+    } else if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && callee.computed === false && ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'Identifier' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier' && callee.property.name === 'required') {
+        var rootName = callee.object.name;
+        if (ANGULAR_CORE_REQUIRED_FACTORIES.has(rootName) && isImportedFrom(imports, rootName, ANGULAR_CORE_MODULE)) {
+            result = true;
+        }
+    }
+    return result;
+}
+/**
+ * Returns true when `typeAnnotation` is a TypeScript type annotation node whose
+ * root type name is one of the Angular signal types and resolves to an
+ * `@angular/core` import (e.g. `Signal<number>`, `InputSignal<string>`).
+ *
+ * Accepts both the `TSTypeAnnotation` wrapper and the inner `TSTypeReference`
+ * form. Returns false for any other shape (unions, intersections, generic
+ * wrappers, etc.) — the rule prefers under-coverage to false positives.
+ *
+ * @param typeAnnotation - The TSTypeAnnotation / TSTypeReference AST node.
+ * @param imports - The file's import registry.
+ * @returns True when the type annotation names an Angular signal type.
+ */ function isSignalTypeAnnotation(typeAnnotation, imports) {
+    var _typeNode_typeName;
+    var typeNode = typeAnnotation;
+    if ((typeNode === null || typeNode === void 0 ? void 0 : typeNode.type) === 'TSTypeAnnotation') {
+        typeNode = typeNode.typeAnnotation;
+    }
+    var result = false;
+    if ((typeNode === null || typeNode === void 0 ? void 0 : typeNode.type) === 'TSTypeReference' && ((_typeNode_typeName = typeNode.typeName) === null || _typeNode_typeName === void 0 ? void 0 : _typeNode_typeName.type) === 'Identifier') {
+        var name = typeNode.typeName.name;
+        if (ANGULAR_CORE_SIGNAL_TYPE_NAMES.has(name) && isImportedFrom(imports, name, ANGULAR_CORE_MODULE)) {
+            result = true;
+        }
+    }
+    return result;
+}
+/**
+ * Scans the class body for `PropertyDefinition` members whose initializer is
+ * a signal factory call, and stores their names in `signals.classSignalProps`.
+ *
+ * Static and `declare` properties are ignored. Property names that are not
+ * simple identifiers (e.g. computed keys, symbols) are also ignored.
+ *
+ * @param classNode - The ClassDeclaration / ClassExpression AST node.
+ * @param imports - The file's import registry.
+ * @param signals - The signal registry that is mutated with the results.
+ */ function collectClassSignalProperties(classNode, imports, signals) {
+    var _ref;
+    var _classNode_body;
+    var members = (_ref = (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body) !== null && _ref !== void 0 ? _ref : [];
+    var names = new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var member = _step.value;
+            if ((member === null || member === void 0 ? void 0 : member.type) !== 'PropertyDefinition' || member.static === true || member.declare === true || member.computed === true) {
+                continue;
+            }
+            var key = member.key;
+            var initializer = member.value;
+            var propName = null;
+            if ((key === null || key === void 0 ? void 0 : key.type) === 'Identifier') {
+                propName = key.name;
+            } else if ((key === null || key === void 0 ? void 0 : key.type) === 'Literal' && typeof key.value === 'string') {
+                propName = key.value;
+            }
+            if (propName) {
+                var initializerIsSignal = (initializer === null || initializer === void 0 ? void 0 : initializer.type) === 'CallExpression' && isSignalFactoryCall(initializer, imports);
+                var typeIsSignal = member.typeAnnotation && isSignalTypeAnnotation(member.typeAnnotation, imports);
+                if (initializerIsSignal || typeIsSignal) {
+                    names.add(propName);
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    signals.classSignalProps.set(classNode, names);
+}
+/**
+ * Scans a `VariableDeclaration` node that lives directly inside the program
+ * body for `const` declarators whose initializer is a signal factory call,
+ * adding their names to `signals.moduleSignalNames`.
+ *
+ * Non-`const` declarations, declarations nested inside functions or blocks,
+ * and declarations whose initializer is not a signal factory are skipped.
+ *
+ * @param node - The VariableDeclaration AST node.
+ * @param imports - The file's import registry.
+ * @param signals - The signal registry that is mutated with the results.
+ */ function collectModuleSignalConsts(node, imports, signals) {
+    var _node_declarations;
+    var _node_parent;
+    if ((node === null || node === void 0 ? void 0 : node.kind) !== 'const' || ((_node_parent = node.parent) === null || _node_parent === void 0 ? void 0 : _node_parent.type) !== 'Program') {
+        return;
+    }
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = ((_node_declarations = node.declarations) !== null && _node_declarations !== void 0 ? _node_declarations : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var declarator = _step.value;
+            var id = declarator === null || declarator === void 0 ? void 0 : declarator.id;
+            var init = declarator === null || declarator === void 0 ? void 0 : declarator.init;
+            if ((id === null || id === void 0 ? void 0 : id.type) === 'Identifier') {
+                var initIsSignal = (init === null || init === void 0 ? void 0 : init.type) === 'CallExpression' && isSignalFactoryCall(init, imports);
+                var typeIsSignal = id.typeAnnotation && isSignalTypeAnnotation(id.typeAnnotation, imports);
+                if (initIsSignal || typeIsSignal) {
+                    signals.moduleSignalNames.add(id.name);
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * Walks up from `node` via `parent` references to find the nearest enclosing
+ * `ClassDeclaration` or `ClassExpression`, or null if there isn't one.
+ *
+ * @param node - The starting AST node.
+ * @returns The enclosing class node, or null.
+ */ function findEnclosingClass(node) {
+    var current = node.parent;
+    var result = null;
+    while(current && !result){
+        if (current.type === 'ClassDeclaration' || current.type === 'ClassExpression') {
+            result = current;
+        } else {
+            current = current.parent;
+        }
+    }
+    return result;
+}
+/**
+ * Returns true when `node` is any function-like AST node (arrow, expression,
+ * declaration). Used both to find the computed callback and to stop the walk
+ * when it would otherwise descend into a nested function body.
+ *
+ * @param node - The AST node to test.
+ * @returns True when `node` is a function-like node.
+ */ function isFunctionNode(node) {
+    return (node === null || node === void 0 ? void 0 : node.type) === 'ArrowFunctionExpression' || (node === null || node === void 0 ? void 0 : node.type) === 'FunctionExpression' || (node === null || node === void 0 ? void 0 : node.type) === 'FunctionDeclaration';
+}
+/**
+ * Recursively walks the body of a `computed(...)` callback. For each
+ * zero-argument `CallExpression` that can be statically traced to a known
+ * signal getter, records a violation when `conditional` is true. Stops at
+ * any nested function boundary.
+ *
+ * @param node - The current AST node being inspected.
+ * @param conditional - True when `node` is inside a conditional execution path.
+ * @param state - Shared walk state (signal registries + violation accumulator).
+ */ function walk(node, conditional, state) {
+    if (!node || typeof node.type !== 'string') {
+        return;
+    }
+    // Stop at nested functions. The caller passes the computed callback's body
+    // (not the function node itself) as the entry point, so any function node
+    // we encounter while walking children is a nested function whose interior
+    // is not synchronously tracked by Angular.
+    if (isFunctionNode(node)) {
+        return;
+    }
+    if (conditional && node.type === 'CallExpression' && Array.isArray(node.arguments) && node.arguments.length === 0) {
+        var match = classifySignalRead(node.callee, state);
+        if (match) {
+            state.violations.push({
+                node: node,
+                signalName: match.name,
+                source: match.source
+            });
+        }
+    }
+    walkChildren(node, conditional, state);
+}
+/**
+ * Returns the signal-name match for `callee` when it reads a known signal:
+ * either a `this.<name>` access where `<name>` is a class signal property,
+ * or a bare `<name>` identifier where `<name>` is a module-level signal
+ * `const`. Returns null otherwise.
+ *
+ * Cross-class accesses (`this.someService.someSignal()`), method calls on
+ * locals (`icons.reverse()`), and untracked identifiers (`Math.random()`)
+ * return null: the rule prefers silent under-coverage to false positives.
+ *
+ * @param callee - The CallExpression's callee AST node.
+ * @param state - The shared walk state (used to read the signal registries).
+ * @returns Match details (signal name + source), or null when not a known signal read.
+ */ function classifySignalRead(callee, state) {
+    var _callee_object, _callee_property;
+    var result = null;
+    if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier') {
+        if (state.moduleSignalNames.has(callee.name)) {
+            result = {
+                name: callee.name,
+                source: 'module'
+            };
+        }
+    } else if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'MemberExpression' && callee.computed === false && ((_callee_object = callee.object) === null || _callee_object === void 0 ? void 0 : _callee_object.type) === 'ThisExpression' && ((_callee_property = callee.property) === null || _callee_property === void 0 ? void 0 : _callee_property.type) === 'Identifier') {
+        var _state_classSignalNames;
+        var propName = callee.property.name;
+        if (((_state_classSignalNames = state.classSignalNames) === null || _state_classSignalNames === void 0 ? void 0 : _state_classSignalNames.has(propName)) === true) {
+            result = {
+                name: propName,
+                source: 'this'
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Recurses into the appropriate children of `node`, switching `conditional`
+ * to true when descending into a branch that may not execute on every run.
+ *
+ * @param node - The current AST node whose children are walked.
+ * @param conditional - True when `node` itself is in a conditional path.
+ * @param state - Shared walk state.
+ */ function walkChildren(node, conditional, state) {
+    switch(node.type){
+        case 'IfStatement':
+            walk(node.test, conditional, state);
+            walk(node.consequent, true, state);
+            walk(node.alternate, true, state);
+            break;
+        case 'ConditionalExpression':
+            walk(node.test, conditional, state);
+            walk(node.consequent, true, state);
+            walk(node.alternate, true, state);
+            break;
+        case 'LogicalExpression':
+            // `&&`, `||`, and `??` all short-circuit: the right operand only runs
+            // when the left operand triggers the corresponding short-circuit miss.
+            walk(node.left, conditional, state);
+            walk(node.right, true, state);
+            break;
+        case 'SwitchStatement':
+            var _node_cases;
+            walk(node.discriminant, conditional, state);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = ((_node_cases = node.cases) !== null && _node_cases !== void 0 ? _node_cases : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var switchCase = _step.value;
+                    var _switchCase_consequent;
+                    walk(switchCase.test, conditional, state);
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = ((_switchCase_consequent = switchCase.consequent) !== null && _switchCase_consequent !== void 0 ? _switchCase_consequent : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var statement = _step1.value;
+                            walk(statement, true, state);
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            break;
+        case 'ForStatement':
+            walk(node.init, conditional, state);
+            walk(node.test, conditional, state);
+            walk(node.update, true, state);
+            walk(node.body, true, state);
+            break;
+        case 'ForInStatement':
+        case 'ForOfStatement':
+            walk(node.left, conditional, state);
+            walk(node.right, conditional, state);
+            walk(node.body, true, state);
+            break;
+        case 'WhileStatement':
+        case 'DoWhileStatement':
+            walk(node.test, conditional, state);
+            walk(node.body, true, state);
+            break;
+        case 'TryStatement':
+            walk(node.block, conditional, state);
+            walk(node.handler, true, state);
+            walk(node.finalizer, conditional, state);
+            break;
+        default:
+            walkGenericChildren(node, conditional, state);
+    }
+}
+/**
+ * Generic AST-walking fallback used for node types that do not introduce
+ * conditional execution. Recurses into every object-valued or array-valued
+ * property whose value looks like an AST node.
+ *
+ * @param node - The current AST node.
+ * @param conditional - True when `node` itself is in a conditional path.
+ * @param state - Shared walk state.
+ */ function walkGenericChildren(node, conditional, state) {
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = Object.keys(node)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var key = _step.value;
+            if (key === 'parent' || key === 'loc' || key === 'range' || key === 'start' || key === 'end') {
+                continue;
+            }
+            var child = node[key];
+            if (Array.isArray(child)) {
+                var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                try {
+                    for(var _iterator1 = child[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                        var entry = _step1.value;
+                        walk(entry, conditional, state);
+                    }
+                } catch (err) {
+                    _didIteratorError1 = true;
+                    _iteratorError1 = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                            _iterator1.return();
+                        }
+                    } finally{
+                        if (_didIteratorError1) {
+                            throw _iteratorError1;
+                        }
+                    }
+                }
+            } else if (child && (typeof child === "undefined" ? "undefined" : _type_of(child)) === 'object' && typeof child.type === 'string') {
+                walk(child, conditional, state);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * Emits one diagnostic per accumulated violation. The first emitted report
+ * carries a combined autofix that hoists each flagged signal read to the top
+ * of the callback body and replaces every flagged call with the hoisted
+ * local. Subsequent reports do not carry a fix because `--fix` will already
+ * have rewritten them via the first report's fix.
+ *
+ * @param callback - The Function/ArrowFunction AST node passed to `computed(...)`.
+ * @param violations - Conditional signal reads collected during the walk.
+ * @param context - The ESLint rule context.
+ */ function reportViolations(callback, violations, context) {
+    var _context_sourceCode;
+    var _context_getSourceCode;
+    var sourceCode = (_context_sourceCode = context.sourceCode) !== null && _context_sourceCode !== void 0 ? _context_sourceCode : (_context_getSourceCode = context.getSourceCode) === null || _context_getSourceCode === void 0 ? void 0 : _context_getSourceCode.call(context);
+    var plan = buildFixPlan(callback, violations);
+    violations.forEach(function(violation, index) {
+        context.report({
+            node: violation.node,
+            messageId: 'conditionalSignalRead',
+            data: {
+                call: getCallPreview(violation.node, context)
+            },
+            fix: index === 0 && plan ? function(fixer) {
+                return applyFixPlan(fixer, plan, sourceCode);
+            } : undefined
+        });
+    });
+}
+/**
+ * Plans the hoisting transformation for a callback whose violations have
+ * been collected. Returns null when no hoist can be planned (e.g. every
+ * candidate name would shadow an existing binding).
+ *
+ * @param callback - The Function/ArrowFunction AST node passed to `computed(...)`.
+ * @param violations - Conditional signal reads collected during the walk.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns A fix plan, or null when no hoist is possible.
+ */ function buildFixPlan(callback, violations, sourceCode) {
+    var body = callback === null || callback === void 0 ? void 0 : callback.body;
+    var result = null;
+    if (body) {
+        var existingLocals = collectExistingLocalNames(body);
+        var localNames = new Map();
+        var usedNames = new Set(existingLocals);
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = violations[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var violation = _step.value;
+                if (localNames.has(violation.signalName)) {
+                    continue;
+                }
+                var preferred = computeLocalName(violation.signalName);
+                if (usedNames.has(preferred)) {
+                    continue;
+                }
+                usedNames.add(preferred);
+                localNames.set(violation.signalName, {
+                    name: preferred,
+                    source: violation.source
+                });
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+        if (localNames.size > 0) {
+            var replacements = violations.filter(function(violation) {
+                return localNames.has(violation.signalName);
+            });
+            if (replacements.length > 0) {
+                result = {
+                    callback: callback,
+                    body: body,
+                    localNames: localNames,
+                    replacements: replacements
+                };
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Computes the local variable name for a signal property name. Strips the
+ * trailing `Signal` suffix when present (`xSignal` → `x`, `_configSignal` →
+ * `_config`); otherwise returns the original name unchanged.
+ *
+ * A name that is purely `'Signal'` is returned as-is rather than stripped
+ * to an empty string.
+ *
+ * @param signalName - The signal property name to derive the local from.
+ * @returns The local variable name.
+ */ function computeLocalName(signalName) {
+    var suffix = 'Signal';
+    var result = signalName;
+    if (signalName.length > suffix.length && signalName.endsWith(suffix)) {
+        result = signalName.slice(0, signalName.length - suffix.length);
+    }
+    return result;
+}
+/**
+ * Collects all identifier names introduced by `VariableDeclarator`s within
+ * the function body's top-level statements (the only locations a hoist
+ * could possibly shadow). Nested function bodies and inner block scopes are
+ * not inspected — shadowing those is harmless.
+ *
+ * Also accepts expression-body callbacks: an expression body cannot declare
+ * locals, so it contributes no names.
+ *
+ * @param body - The callback's BlockStatement or expression AST node.
+ * @returns Identifier names already declared in the body's scope.
+ */ function collectExistingLocalNames(body) {
+    var names = new Set();
+    if ((body === null || body === void 0 ? void 0 : body.type) === 'BlockStatement') {
+        var _body_body;
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = ((_body_body = body.body) !== null && _body_body !== void 0 ? _body_body : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var statement = _step.value;
+                if ((statement === null || statement === void 0 ? void 0 : statement.type) === 'VariableDeclaration') {
+                    var _statement_declarations;
+                    var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+                    try {
+                        for(var _iterator1 = ((_statement_declarations = statement.declarations) !== null && _statement_declarations !== void 0 ? _statement_declarations : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                            var declarator = _step1.value;
+                            collectPatternNames(declarator === null || declarator === void 0 ? void 0 : declarator.id, names);
+                        }
+                    } catch (err) {
+                        _didIteratorError1 = true;
+                        _iteratorError1 = err;
+                    } finally{
+                        try {
+                            if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                                _iterator1.return();
+                            }
+                        } finally{
+                            if (_didIteratorError1) {
+                                throw _iteratorError1;
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return names;
+}
+/**
+ * Recursively collects identifier names introduced by a destructuring
+ * pattern (or a plain Identifier). Handles ObjectPattern, ArrayPattern,
+ * RestElement, and AssignmentPattern; ignores other shapes.
+ *
+ * @param pattern - The Identifier or destructuring pattern AST node.
+ * @param names - The set that is mutated with discovered names.
+ */ function collectPatternNames(pattern, names) {
+    if (!pattern || typeof pattern.type !== 'string') {
+        return;
+    }
+    switch(pattern.type){
+        case 'Identifier':
+            names.add(pattern.name);
+            break;
+        case 'ObjectPattern':
+            var _pattern_properties;
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                for(var _iterator = ((_pattern_properties = pattern.properties) !== null && _pattern_properties !== void 0 ? _pattern_properties : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                    var property = _step.value;
+                    if ((property === null || property === void 0 ? void 0 : property.type) === 'Property') {
+                        collectPatternNames(property.value, names);
+                    } else if ((property === null || property === void 0 ? void 0 : property.type) === 'RestElement') {
+                        collectPatternNames(property.argument, names);
+                    }
+                }
+            } catch (err) {
+                _didIteratorError = true;
+                _iteratorError = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion && _iterator.return != null) {
+                        _iterator.return();
+                    }
+                } finally{
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                }
+            }
+            break;
+        case 'ArrayPattern':
+            var _pattern_elements;
+            var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+            try {
+                for(var _iterator1 = ((_pattern_elements = pattern.elements) !== null && _pattern_elements !== void 0 ? _pattern_elements : [])[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                    var element = _step1.value;
+                    collectPatternNames(element, names);
+                }
+            } catch (err) {
+                _didIteratorError1 = true;
+                _iteratorError1 = err;
+            } finally{
+                try {
+                    if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                        _iterator1.return();
+                    }
+                } finally{
+                    if (_didIteratorError1) {
+                        throw _iteratorError1;
+                    }
+                }
+            }
+            break;
+        case 'RestElement':
+            collectPatternNames(pattern.argument, names);
+            break;
+        case 'AssignmentPattern':
+            collectPatternNames(pattern.left, names);
+            break;
+    }
+}
+/**
+ * Applies a fix plan, returning the list of fixer operations that hoist each
+ * planned signal read and replace its flagged call sites.
+ *
+ * For BlockStatement bodies the hoists are inserted before the first
+ * statement (or after the opening brace when the body is empty). For
+ * expression-body callbacks the entire body expression is replaced with a
+ * BlockStatement that contains the hoists followed by a `return <expr>;`.
+ *
+ * @param fixer - The ESLint RuleFixer.
+ * @param plan - The fix plan to apply.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns The list of fixer operations.
+ */ function applyFixPlan(fixer, plan, sourceCode) {
+    var fixes = [];
+    var hoistLines = [];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = plan.localNames[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var _step_value = _sliced_to_array(_step.value, 2), signalName = _step_value[0], local = _step_value[1];
+            var rhs = local.source === 'this' ? "this.".concat(signalName, "()") : "".concat(signalName, "()");
+            hoistLines.push("const ".concat(local.name, " = ").concat(rhs, ";"));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    if (plan.body.type === 'BlockStatement') {
+        var _plan_body_body;
+        var indent = getBlockIndent(plan.body, sourceCode);
+        var firstStatement = (_plan_body_body = plan.body.body) === null || _plan_body_body === void 0 ? void 0 : _plan_body_body[0];
+        if (firstStatement) {
+            // `insertTextBefore(firstStatement, …)` inserts at the position of the
+            // first non-whitespace character of the statement; the existing line
+            // already carries the leading indent up to that position. So the first
+            // hoist line is emitted WITHOUT a leading indent (it reuses the
+            // existing one), every subsequent line carries the full indent, and
+            // the trailing `\n${indent}` re-establishes the indent for the
+            // original statement that follows.
+            var hoistText = hoistLines.map(function(line, index) {
+                return index === 0 ? line : "".concat(indent).concat(line);
+            }).join('\n');
+            fixes.push(fixer.insertTextBefore(firstStatement, "".concat(hoistText, "\n").concat(indent)));
+        } else {
+            var openBrace = sourceCode.getFirstToken(plan.body);
+            if (openBrace) {
+                var hoistText1 = hoistLines.map(function(line) {
+                    return "".concat(indent).concat(line);
+                }).join('\n');
+                fixes.push(fixer.insertTextAfter(openBrace, "\n".concat(hoistText1, "\n")));
+            }
+        }
+        var _iteratorNormalCompletion1 = true, _didIteratorError1 = false, _iteratorError1 = undefined;
+        try {
+            for(var _iterator1 = plan.replacements[Symbol.iterator](), _step1; !(_iteratorNormalCompletion1 = (_step1 = _iterator1.next()).done); _iteratorNormalCompletion1 = true){
+                var replacement = _step1.value;
+                var local1 = plan.localNames.get(replacement.signalName);
+                if (local1) {
+                    fixes.push(fixer.replaceText(replacement.node, local1.name));
+                }
+            }
+        } catch (err) {
+            _didIteratorError1 = true;
+            _iteratorError1 = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion1 && _iterator1.return != null) {
+                    _iterator1.return();
+                }
+            } finally{
+                if (_didIteratorError1) {
+                    throw _iteratorError1;
+                }
+            }
+        }
+    } else {
+        // Expression body: rewrite `(arg) => <expr>` to
+        // `(arg) => { …hoists; return <expr-with-substitutions>; }`. The body
+        // replacement covers every flagged call site, so per-call replacements
+        // are baked into the substituted expression text rather than emitted as
+        // separate fixer operations (which would overlap the body replacement).
+        var baseIndent = getStatementIndent(plan.callback, sourceCode);
+        var innerIndent = "".concat(baseIndent, "  ");
+        var hoistText2 = hoistLines.map(function(line) {
+            return "".concat(innerIndent).concat(line);
+        }).join('\n');
+        var substitutedExpr = substituteInExpression(plan, sourceCode);
+        fixes.push(fixer.replaceText(plan.body, "{\n".concat(hoistText2, "\n").concat(innerIndent, "return ").concat(substitutedExpr, ";\n").concat(baseIndent, "}")));
+    }
+    return fixes;
+}
+/**
+ * Returns the leading-whitespace indent of the line that contains the start
+ * of `node`. Used to align the inserted block body with the surrounding
+ * statement (e.g. the `readonly fooSignal = computed(() => …)` line).
+ *
+ * Falls back to an empty string when the node has no detectable line indent.
+ *
+ * @param node - The AST node whose enclosing line indent is wanted.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns The indent string (spaces / tabs), or `''` when none can be derived.
+ */ function getStatementIndent(node, sourceCode) {
+    var _ref, _sourceCode_text;
+    var _sourceCode_getText;
+    var source = (_ref = (_sourceCode_text = sourceCode.text) !== null && _sourceCode_text !== void 0 ? _sourceCode_text : (_sourceCode_getText = sourceCode.getText) === null || _sourceCode_getText === void 0 ? void 0 : _sourceCode_getText.call(sourceCode)) !== null && _ref !== void 0 ? _ref : '';
+    var start = node.range[0];
+    var lineStart = start;
+    var result = '';
+    while(lineStart > 0 && source[lineStart - 1] !== '\n'){
+        lineStart -= 1;
+    }
+    var slice = source.slice(lineStart, start);
+    var match = /^[ \t]*/.exec(slice);
+    if (match) {
+        result = match[0];
+    }
+    return result;
+}
+/**
+ * Builds the substituted text for an expression-body callback by walking the
+ * raw source text and swapping each flagged call's source range for its
+ * hoisted local name. Replacements are applied right-to-left so earlier
+ * ranges stay valid as the string is mutated.
+ *
+ * @param plan - The fix plan whose body is an expression.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns The expression text with every flagged call site replaced.
+ */ function substituteInExpression(plan, sourceCode) {
+    var bodyStart = plan.body.range[0];
+    var ordered = _to_consumable_array(plan.replacements).sort(function(a, b) {
+        return b.node.range[0] - a.node.range[0];
+    });
+    var result = sourceCode.getText(plan.body);
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = ordered[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var replacement = _step.value;
+            var local = plan.localNames.get(replacement.signalName);
+            if (local) {
+                var start = replacement.node.range[0] - bodyStart;
+                var end = replacement.node.range[1] - bodyStart;
+                result = result.slice(0, start) + local.name + result.slice(end);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns the indent string (whitespace before the first statement) for a
+ * BlockStatement, falling back to a sensible default (`'  '`) when the
+ * block contains no statements or no leading whitespace can be located.
+ *
+ * @param block - The BlockStatement AST node.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns The indent string to use for inserted hoist lines.
+ */ function getBlockIndent(block, sourceCode) {
+    var _block_body;
+    var firstStatement = (_block_body = block.body) === null || _block_body === void 0 ? void 0 : _block_body[0];
+    var result = '  ';
+    if (firstStatement) {
+        var _ref, _sourceCode_text;
+        var _sourceCode_getText;
+        var source = (_ref = (_sourceCode_text = sourceCode.text) !== null && _sourceCode_text !== void 0 ? _sourceCode_text : (_sourceCode_getText = sourceCode.getText) === null || _sourceCode_getText === void 0 ? void 0 : _sourceCode_getText.call(sourceCode)) !== null && _ref !== void 0 ? _ref : '';
+        var textBefore = source.slice(block.range[0], firstStatement.range[0]);
+        var match = /(?:^|\n)([ \t]*)$/.exec(textBefore);
+        if (match) {
+            result = match[1];
+        }
+    }
+    return result;
+}
+/**
+ * Returns a short, human-readable textual preview of the call expression,
+ * suitable for inclusion in the diagnostic message. Falls back to `'signal'`
+ * when the source code is unavailable.
+ *
+ * @param node - The CallExpression AST node.
+ * @param context - The ESLint rule context (used to access `sourceCode`).
+ * @returns A truncated textual preview of the call.
+ */ function getCallPreview(node, context) {
+    var _context_sourceCode;
+    var _context_getSourceCode;
+    var sourceCode = (_context_sourceCode = context.sourceCode) !== null && _context_sourceCode !== void 0 ? _context_sourceCode : (_context_getSourceCode = context.getSourceCode) === null || _context_getSourceCode === void 0 ? void 0 : _context_getSourceCode.call(context);
+    var preview = 'signal';
+    if (sourceCode && node.callee) {
+        var calleeText = sourceCode.getText(node.callee);
+        preview = "".concat(calleeText, "()");
+        if (preview.length > CALL_PREVIEW_MAX_LENGTH) {
+            preview = "".concat(preview.slice(0, CALL_PREVIEW_MAX_LENGTH - 3), "...");
+        }
+    }
+    return preview;
+}
+
 /**
  * ESLint plugin for dbx-web rules.
  *
  * Register as a plugin in your flat ESLint config, then enable individual rules
  * under the chosen plugin prefix (e.g. 'dereekb-dbx-web/require-clean-subscription').
- */ var dbxWebEslintPlugin = {
+ */ var DBX_WEB_ESLINT_PLUGIN = {
     rules: {
-        'require-clean-subscription': dbxWebRequireCleanSubscriptionRule,
-        'require-complete-on-destroy': dbxWebRequireCompleteOnDestroyRule,
-        'no-redundant-on-destroy': dbxWebNoRedundantOnDestroyRule
+        'require-clean-subscription': DBX_WEB_REQUIRE_CLEAN_SUBSCRIPTION_RULE,
+        'require-complete-on-destroy': DBX_WEB_REQUIRE_COMPLETE_ON_DESTROY_RULE,
+        'no-redundant-on-destroy': DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE,
+        'require-computed-signal-suffix': DBX_WEB_REQUIRE_COMPUTED_SIGNAL_SUFFIX_RULE,
+        'require-component-config-input': DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE,
+        'require-top-level-computed-signals': DBX_WEB_REQUIRE_TOP_LEVEL_COMPUTED_SIGNALS_RULE
     }
 };
 
-export { dbxWebEslintPlugin, dbxWebNoRedundantOnDestroyRule, dbxWebRequireCleanSubscriptionRule, dbxWebRequireCompleteOnDestroyRule };
+export { DBX_WEB_ESLINT_PLUGIN, DBX_WEB_NO_REDUNDANT_ON_DESTROY_RULE, DBX_WEB_REQUIRE_CLEAN_SUBSCRIPTION_RULE, DBX_WEB_REQUIRE_COMPLETE_ON_DESTROY_RULE, DBX_WEB_REQUIRE_COMPONENT_CONFIG_INPUT_RULE, DBX_WEB_REQUIRE_COMPUTED_SIGNAL_SUFFIX_RULE, DBX_WEB_REQUIRE_TOP_LEVEL_COMPUTED_SIGNALS_RULE };