@dereekb/dbx-web 13.10.6 → 13.10.8

package/eslint/index.esm.js

@@ -0,0 +1,1091 @@
+/**
+ * Module that holds Angular component decorators.
+ */ var ANGULAR_CORE_MODULE = '@angular/core';
+/**
+ * Decorators that mark a class with a component-scoped DestroyRef lifecycle.
+ *
+ * `@Injectable` is intentionally excluded — services often expose long-lived
+ * Subjects as part of their public API and cleaning them on destroy is wrong.
+ */ var ANGULAR_COMPONENT_DECORATORS = new Set([
+    'Component',
+    'Directive',
+    'Pipe'
+]);
+/**
+ * Module that holds the dbx-components RxJS extras (SubscriptionObject).
+ */ var DEREEKB_RXJS_MODULE = '@dereekb/rxjs';
+/**
+ * Module that holds Subject/BehaviorSubject/etc.
+ */ var RXJS_MODULE = 'rxjs';
+/**
+ * Module that holds the cleanup helpers (cleanSubscription, completeOnDestroy, clean).
+ */ var DEREEKB_DBX_CORE_MODULE = '@dereekb/dbx-core';
+/**
+ * Identifier name for the `SubscriptionObject` class.
+ */ var SUBSCRIPTION_OBJECT_NAME = 'SubscriptionObject';
+/**
+ * Identifier names for RxJS Subject classes that should be wrapped with `completeOnDestroy`.
+ */ var SUBJECT_NAMES = new Set([
+    'Subject',
+    'BehaviorSubject',
+    'ReplaySubject',
+    'AsyncSubject'
+]);
+/**
+ * Helper imported from `@dereekb/dbx-core` that replaces a manual SubscriptionObject creation.
+ */ var CLEAN_SUBSCRIPTION_HELPER = 'cleanSubscription';
+/**
+ * Helper imported from `@dereekb/dbx-core` that wraps a Subject so it completes on destroy.
+ */ var COMPLETE_ON_DESTROY_HELPER = 'completeOnDestroy';
+/**
+ * Underlying Destroyable/DestroyFunction primitive helper from `@dereekb/dbx-core`.
+ *
+ * Accepted as a wrapper for `new SubscriptionObject(...)` since `SubscriptionObject`
+ * is `Destroyable`. Not accepted for raw Subjects since those are neither
+ * `Destroyable` nor `DestroyFunction` and would not actually call `.complete()`.
+ */ var CLEAN_HELPER = 'clean';
+/**
+ * Creates an empty {@link ImportRegistry}.
+ *
+ * @returns A fresh empty registry.
+ */ function createImportRegistry() {
+    return {
+        bySource: new Map(),
+        localToSource: new Map(),
+        sourceToDeclaration: new Map(),
+        lastImportDeclaration: null
+    };
+}
+/**
+ * Records an `ImportDeclaration` node in the registry. Call from the rule's
+ * `ImportDeclaration` visitor for every import in the file.
+ *
+ * @param registry - The registry to mutate.
+ * @param node - The ImportDeclaration AST node.
+ */ function trackImportDeclaration(registry, node) {
+    var _registry_bySource_get, _node_specifiers;
+    var _node_source;
+    var source = (_node_source = node.source) === null || _node_source === void 0 ? void 0 : _node_source.value;
+    if (!source) {
+        return;
+    }
+    registry.lastImportDeclaration = node;
+    registry.sourceToDeclaration.set(source, node);
+    var localNames = (_registry_bySource_get = registry.bySource.get(source)) !== null && _registry_bySource_get !== void 0 ? _registry_bySource_get : new Set();
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for(var _iterator = ((_node_specifiers = node.specifiers) !== null && _node_specifiers !== void 0 ? _node_specifiers : [])[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+            var specifier = _step.value;
+            if (specifier.type === 'ImportSpecifier' || specifier.type === 'ImportDefaultSpecifier' || specifier.type === 'ImportNamespaceSpecifier') {
+                var _specifier_local;
+                var localName = (_specifier_local = specifier.local) === null || _specifier_local === void 0 ? void 0 : _specifier_local.name;
+                if (localName) {
+                    localNames.add(localName);
+                    registry.localToSource.set(localName, source);
+                }
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    registry.bySource.set(source, localNames);
+}
+/**
+ * Returns true when the given local identifier name was imported from the given module.
+ *
+ * @param registry - The import registry built from the file's import declarations.
+ * @param localName - The local identifier (as it appears in code).
+ * @param fromSource - The expected source-module string.
+ * @returns True when the local name maps to the given source.
+ */ function isImportedFrom(registry, localName, fromSource) {
+    return registry.localToSource.get(localName) === fromSource;
+}
+/**
+ * Extracts the decorator name from a decorator AST node.
+ *
+ * Handles `@Foo()` (CallExpression) and `@Foo` (Identifier). Returns the empty
+ * string for anything else.
+ *
+ * @param decorator - The decorator AST node.
+ * @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;
+        }
+    }
+    if (expression.type === 'Identifier') {
+        return expression.name;
+    }
+    return '';
+}
+/**
+ * Returns the first decorator on the class that names a component-tier
+ * Angular decorator (`@Component`, `@Directive`, `@Pipe`) imported from
+ * `@angular/core`, or null when none match.
+ *
+ * @param classNode - The ClassDeclaration / ClassExpression AST node.
+ * @param registry - The file's import registry, used to verify the decorator
+ *   identifier really came from `@angular/core` (and not a local alias).
+ * @returns The matching decorator and its name, or null.
+ */ function findAngularComponentDecorator(classNode, registry) {
+    var decorators = classNode === null || classNode === void 0 ? void 0 : classNode.decorators;
+    var result = null;
+    if (decorators && decorators.length > 0) {
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            for(var _iterator = decorators[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var decorator = _step.value;
+                var name = getDecoratorName(decorator);
+                if (ANGULAR_COMPONENT_DECORATORS.has(name) && isImportedFrom(registry, name, ANGULAR_CORE_MODULE)) {
+                    result = {
+                        decorator: decorator,
+                        name: name
+                    };
+                    break;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns the property name of a class member when its key is a simple Identifier or string Literal.
+ *
+ * Returns null for computed/symbol/private keys.
+ *
+ * @param member - A ClassBody member AST node.
+ * @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;
+    }
+    return null;
+}
+/**
+ * Finds the `ngOnDestroy` method declaration on the given class, if any.
+ *
+ * @param classNode - The ClassDeclaration / ClassExpression AST node.
+ * @returns The MethodDefinition AST node for `ngOnDestroy`, or null.
+ */ function findNgOnDestroyMethod(classNode) {
+    var _classNode_body;
+    var members = classNode === null || classNode === void 0 ? void 0 : (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body;
+    var result = null;
+    if (members) {
+        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 === 'MethodDefinition' && member.kind === 'method' && getClassMemberName(member) === 'ngOnDestroy') {
+                    result = member;
+                    break;
+                }
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * If the given expression is a `CallExpression` whose callee is one of the
+ * accepted identifier names, returns the matching name. Otherwise 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;
+    }
+    return null;
+}
+/**
+ * Returns true when the given AST node is a `this.<propName>` MemberExpression.
+ *
+ * @param node - The AST node to check.
+ * @param propName - The expected property name.
+ * @returns True when the node is `this.<propName>`.
+ */ function isThisMemberAccess(node, propName) {
+    var _node_object, _node_property;
+    return (node === null || node === void 0 ? void 0 : node.type) === 'MemberExpression' && ((_node_object = node.object) === null || _node_object === void 0 ? void 0 : _node_object.type) === 'ThisExpression' && !node.computed && ((_node_property = node.property) === null || _node_property === void 0 ? void 0 : _node_property.type) === 'Identifier' && node.property.name === propName;
+}
+/**
+ * Builds a fix operation that ensures `importName` is imported from
+ * `fromSource` in the file. Returns null when the import is already present.
+ *
+ * Side effect: mutates the registry to mark the import as present, so two
+ * separate report fixes in the same lint pass don't both insert the same import.
+ *
+ * @param input - The fixer, registry, and import names.
+ * @returns A fix operation, or null when the import is already present.
+ */ 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);
+            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(registry.lastImportDeclaration, "\nimport { ".concat(importName, " } from '").concat(fromSource, "';"));
+    }
+    return result;
+}
+/**
+ * Returns true when the given PropertyDefinition declares a `static` member.
+ *
+ * @param node - The PropertyDefinition AST node.
+ * @returns True when the node has `static` modifier.
+ */ function isStaticProperty(node) {
+    return (node === null || node === void 0 ? void 0 : node.static) === true;
+}
+/**
+ * Returns true when the given PropertyDefinition uses `declare`
+ * (`declare readonly foo: T`) — i.e. has no runtime initializer.
+ *
+ * @param node - The PropertyDefinition AST node.
+ * @returns True when the property is declared abstractly.
+ */ function isDeclareProperty(node) {
+    return (node === null || node === void 0 ? void 0 : node.declare) === true;
+}
+/**
+ * The Angular `OnDestroy` lifecycle interface name.
+ */ var ON_DESTROY_INTERFACE_NAME = 'OnDestroy';
+/**
+ * Locates an `implements OnDestroy` clause on the class whose `OnDestroy`
+ * identifier resolves to the import from `@angular/core`. Returns null when
+ * no matching clause exists.
+ *
+ * @param classNode - The ClassDeclaration / ClassExpression AST node.
+ * @param registry - The file's import registry.
+ * @returns The match details, or null.
+ */ function findOnDestroyImplementsClause(classNode, registry) {
+    var _ref;
+    var allImplements = (_ref = classNode === null || classNode === void 0 ? void 0 : classNode.implements) !== null && _ref !== void 0 ? _ref : [];
+    var result = null;
+    for(var index = 0; index < allImplements.length; index += 1){
+        var clauseSpecifier = allImplements[index];
+        var expression = clauseSpecifier === null || clauseSpecifier === void 0 ? void 0 : clauseSpecifier.expression;
+        if ((expression === null || expression === void 0 ? void 0 : expression.type) === 'Identifier' && expression.name === ON_DESTROY_INTERFACE_NAME && isImportedFrom(registry, ON_DESTROY_INTERFACE_NAME, ANGULAR_CORE_MODULE)) {
+            result = {
+                allImplements: allImplements,
+                clauseSpecifier: clauseSpecifier,
+                index: index
+            };
+            break;
+        }
+    }
+    return result;
+}
+/**
+ * Computes the source range to remove for the given `implements` specifier so
+ * that the surrounding `implements` clause stays well-formed.
+ *
+ * Behavior:
+ * - When the specifier is the only entry, the entire `implements <X>` clause
+ *   is removed, including the leading whitespace before the `implements`
+ *   keyword (so `class Foo implements OnDestroy {` becomes `class Foo {`).
+ * - When the specifier is the first of several, the specifier and the
+ *   following comma+whitespace are removed.
+ * - Otherwise, the preceding comma+whitespace and the specifier are removed.
+ *
+ * @param match - The `implements OnDestroy` match details.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns A `[start, end]` range tuple suitable for `fixer.removeRange`.
+ */ function getImplementsSpecifierRemovalRange(match, sourceCode) {
+    var allImplements = match.allImplements, clauseSpecifier = match.clauseSpecifier, index = match.index;
+    var result;
+    if (allImplements.length === 1) {
+        var implementsKeyword = sourceCode.getTokenBefore(clauseSpecifier, {
+            filter: function filter(token) {
+                return token.type === 'Keyword' && token.value === 'implements';
+            }
+        });
+        var tokenBeforeImplements = implementsKeyword ? sourceCode.getTokenBefore(implementsKeyword) : null;
+        var startPos = tokenBeforeImplements ? tokenBeforeImplements.range[1] : implementsKeyword ? implementsKeyword.range[0] : clauseSpecifier.range[0];
+        result = [
+            startPos,
+            clauseSpecifier.range[1]
+        ];
+    } else if (index === 0) {
+        result = [
+            clauseSpecifier.range[0],
+            allImplements[1].range[0]
+        ];
+    } else {
+        result = [
+            allImplements[index - 1].range[1],
+            clauseSpecifier.range[1]
+        ];
+    }
+    return result;
+}
+
+/**
+ * Identifier names accepted as the wrapper around a manual `new SubscriptionObject(...)`.
+ */ var ACCEPTED_WRAPPERS$1 = new Set([
+    CLEAN_SUBSCRIPTION_HELPER,
+    CLEAN_HELPER
+]);
+/**
+ * ESLint rule that requires class-field initializers of `new SubscriptionObject(...)`
+ * to be replaced with `cleanSubscription(...)` (which auto-registers cleanup with
+ * Angular's DestroyRef) on `@Component` / `@Directive` / `@Pipe` classes.
+ *
+ * Fires only when `SubscriptionObject` is imported from `@dereekb/rxjs`.
+ *
+ * Auto-fix:
+ * - 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 = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require cleanSubscription() instead of new SubscriptionObject() in Angular component, directive, or pipe classes',
+            recommended: true
+        },
+        messages: {
+            missingCleanSubscription: 'Replace `new SubscriptionObject(...)` with `cleanSubscription(...)` from @dereekb/dbx-core. cleanSubscription registers cleanup with Angular DestroyRef automatically, removing the need for manual destroy() in ngOnDestroy.'
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var registry = createImportRegistry();
+        var sourceCode = context.sourceCode;
+        var visitClass = function visitClass(classNode) {
+            var _ref;
+            var _classNode_body;
+            var matchedDecorator = findAngularComponentDecorator(classNode, registry);
+            if (!matchedDecorator) {
+                return;
+            }
+            var members = (_ref = (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body) !== null && _ref !== void 0 ? _ref : [];
+            var ngOnDestroy = findNgOnDestroyMethod(classNode);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                var _loop = function() {
+                    var member = _step.value;
+                    if (member.type !== 'PropertyDefinition' || isStaticProperty(member) || isDeclareProperty(member)) {
+                        return "continue";
+                    }
+                    var propName = getClassMemberName(member);
+                    var initializer = member.value;
+                    if (!propName || !initializer) {
+                        return "continue";
+                    }
+                    if (!isUnwrappedSubscriptionObjectNew(initializer, registry)) {
+                        return "continue";
+                    }
+                    context.report({
+                        node: initializer,
+                        messageId: 'missingCleanSubscription',
+                        fix: function fix(fixer) {
+                            return buildSubscriptionObjectFix({
+                                fixer: fixer,
+                                newExpr: initializer,
+                                propName: propName,
+                                ngOnDestroy: ngOnDestroy,
+                                registry: registry,
+                                sourceCode: sourceCode
+                            });
+                        }
+                    });
+                };
+                for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+            } 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);
+            }
+        };
+    }
+};
+/**
+ * Returns true when the given initializer is a bare `new SubscriptionObject(...)`
+ * expression where `SubscriptionObject` resolves to the import from `@dereekb/rxjs`.
+ *
+ * Returns false when the expression is wrapped (e.g. `cleanSubscription(...)` or
+ * `clean(new SubscriptionObject(...))`).
+ *
+ * @param expression - The initializer expression AST node.
+ * @param registry - The file's import registry.
+ * @returns True when the expression is a flagged unwrapped `new SubscriptionObject(...)`.
+ */ function isUnwrappedSubscriptionObjectNew(expression, registry) {
+    var result = false;
+    if (!isCalledIdentifier(expression, ACCEPTED_WRAPPERS$1) && expression.type === 'NewExpression') {
+        var callee = expression.callee;
+        if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier' && callee.name === SUBSCRIPTION_OBJECT_NAME && isImportedFrom(registry, SUBSCRIPTION_OBJECT_NAME, DEREEKB_RXJS_MODULE)) {
+            result = true;
+        }
+    }
+    return result;
+}
+/**
+ * Builds the composite fix for one violating property.
+ *
+ * @param input - The flagged expression, its property name, the class's ngOnDestroy node, the import registry, and source-code services.
+ * @returns A list of fix operations, or null when no fix is producible.
+ */ function buildSubscriptionObjectFix(input) {
+    var _newExpr_callee;
+    var fixer = input.fixer, newExpr = input.newExpr, propName = input.propName, ngOnDestroy = input.ngOnDestroy, registry = input.registry, sourceCode = input.sourceCode;
+    var calleeRange = (_newExpr_callee = newExpr.callee) === null || _newExpr_callee === void 0 ? void 0 : _newExpr_callee.range;
+    var fixes = null;
+    if (calleeRange) {
+        var collected = [];
+        collected.push(fixer.replaceTextRange([
+            newExpr.range[0],
+            calleeRange[1]
+        ], CLEAN_SUBSCRIPTION_HELPER));
+        var importFix = ensureNamedImportFix({
+            fixer: fixer,
+            registry: registry,
+            importName: CLEAN_SUBSCRIPTION_HELPER,
+            fromSource: DEREEKB_DBX_CORE_MODULE
+        });
+        if (importFix) {
+            collected.push(importFix);
+        }
+        if (ANGULAR_COMPONENT_DECORATORS.size > 0 && ngOnDestroy) {
+            collectNgOnDestroyRemovalFixes({
+                fixer: fixer,
+                ngOnDestroy: ngOnDestroy,
+                propName: propName,
+                methodName: 'destroy',
+                sourceCode: sourceCode,
+                fixes: collected
+            });
+        }
+        fixes = collected;
+    }
+    return fixes;
+}
+/**
+ * Pushes fixes that remove `this.<propName>.<methodName>()` ExpressionStatements
+ * from `ngOnDestroy`'s body. Removes the statement node and any preceding
+ * indentation on the same line so a blank line isn't left behind.
+ *
+ * @param input - The fixer, ngOnDestroy method, target property/method names, source-code service, and fix collector.
+ */ function collectNgOnDestroyRemovalFixes(input) {
+    var _ngOnDestroy_value_body, _ngOnDestroy_value;
+    var fixer = input.fixer, ngOnDestroy = input.ngOnDestroy, propName = input.propName, methodName = input.methodName, sourceCode = input.sourceCode, fixes = input.fixes;
+    var body = (_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 (!body) {
+        return;
+    }
+    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 _call_callee, _member_property;
+            if (statement.type !== 'ExpressionStatement') {
+                continue;
+            }
+            var call = statement.expression;
+            if ((call === null || call === void 0 ? void 0 : call.type) !== 'CallExpression' || ((_call_callee = call.callee) === null || _call_callee === void 0 ? void 0 : _call_callee.type) !== 'MemberExpression') {
+                continue;
+            }
+            var member = call.callee;
+            if (member.computed || ((_member_property = member.property) === null || _member_property === void 0 ? void 0 : _member_property.type) !== 'Identifier' || member.property.name !== methodName) {
+                continue;
+            }
+            if (!isThisMemberAccess(member.object, propName)) {
+                continue;
+            }
+            fixes.push(fixer.removeRange(getStatementRangeWithLeadingWhitespace(statement, sourceCode)));
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+}
+/**
+ * Returns the range to remove for a statement, expanded to include any
+ * leading whitespace on the same line and the trailing newline. This avoids
+ * leaving a blank line after fix application.
+ *
+ * @param statement - The ExpressionStatement AST node.
+ * @param sourceCode - The ESLint sourceCode service.
+ * @returns A range tuple `[start, end]` to pass to `fixer.removeRange`.
+ */ function getStatementRangeWithLeadingWhitespace(statement, sourceCode) {
+    var sourceText = sourceCode.text;
+    var start = statement.range[0];
+    var end = statement.range[1];
+    var lineStart = start;
+    while(lineStart > 0 && sourceText[lineStart - 1] !== '\n'){
+        lineStart -= 1;
+    }
+    var lineEnd = end;
+    if (lineEnd < sourceText.length && sourceText[lineEnd] === '\n') {
+        lineEnd += 1;
+    }
+    return [
+        lineStart,
+        lineEnd
+    ];
+}
+
+/**
+ * Identifier names accepted as the wrapper around a manual `new <Subject>(...)`.
+ *
+ * Only `completeOnDestroy` is accepted — `clean()` does not call `.complete()`
+ * on a Subject (Subjects are neither `Destroyable` nor `DestroyFunction`).
+ */ var ACCEPTED_WRAPPERS = new Set([
+    COMPLETE_ON_DESTROY_HELPER
+]);
+/**
+ * ESLint rule that requires class-field initializers of `new Subject(...)`,
+ * `new BehaviorSubject(...)`, `new ReplaySubject(...)`, and `new AsyncSubject(...)`
+ * to be wrapped with `completeOnDestroy(...)` from `@dereekb/dbx-core` on
+ * `@Component` / `@Directive` / `@Pipe` classes.
+ *
+ * Fires only when the Subject identifier is imported from `rxjs`.
+ *
+ * Auto-fix:
+ * - 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 = {
+    meta: {
+        type: 'problem',
+        fixable: 'code',
+        docs: {
+            description: 'Require completeOnDestroy() wrapping new Subject/BehaviorSubject/ReplaySubject/AsyncSubject in Angular component, directive, or pipe classes',
+            recommended: true
+        },
+        messages: {
+            missingCompleteOnDestroy: 'Wrap `new {{subjectName}}(...)` with `completeOnDestroy(...)` from @dereekb/dbx-core. completeOnDestroy registers cleanup with Angular DestroyRef automatically, removing the need for manual complete() in ngOnDestroy.'
+        },
+        schema: []
+    },
+    create: function create(context) {
+        var registry = createImportRegistry();
+        var sourceCode = context.sourceCode;
+        var visitClass = function visitClass(classNode) {
+            var _ref;
+            var _classNode_body;
+            var matchedDecorator = findAngularComponentDecorator(classNode, registry);
+            if (!matchedDecorator) {
+                return;
+            }
+            var members = (_ref = (_classNode_body = classNode.body) === null || _classNode_body === void 0 ? void 0 : _classNode_body.body) !== null && _ref !== void 0 ? _ref : [];
+            var ngOnDestroy = findNgOnDestroyMethod(classNode);
+            var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+            try {
+                var _loop = function() {
+                    var member = _step.value;
+                    if (member.type !== 'PropertyDefinition' || isStaticProperty(member) || isDeclareProperty(member)) {
+                        return "continue";
+                    }
+                    var propName = getClassMemberName(member);
+                    var initializer = member.value;
+                    if (!propName || !initializer) {
+                        return "continue";
+                    }
+                    var subjectName = unwrappedSubjectNewName(initializer, registry);
+                    if (!subjectName) {
+                        return "continue";
+                    }
+                    context.report({
+                        node: initializer,
+                        messageId: 'missingCompleteOnDestroy',
+                        data: {
+                            subjectName: subjectName
+                        },
+                        fix: function fix(fixer) {
+                            return buildSubjectFix({
+                                fixer: fixer,
+                                newExpr: initializer,
+                                propName: propName,
+                                ngOnDestroy: ngOnDestroy,
+                                registry: registry,
+                                sourceCode: sourceCode
+                            });
+                        }
+                    });
+                };
+                for(var _iterator = members[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true)_loop();
+            } 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);
+            }
+        };
+    }
+};
+/**
+ * Returns the Subject class name when the given initializer is a bare
+ * `new Subject/BehaviorSubject/ReplaySubject/AsyncSubject(...)` whose
+ * identifier resolves to the import from `rxjs`. Returns null otherwise
+ * (including when the expression is already wrapped).
+ *
+ * @param expression - The initializer expression AST node.
+ * @param registry - The file's import registry.
+ * @returns The matched Subject identifier name, or null.
+ */ function unwrappedSubjectNewName(expression, registry) {
+    var result = null;
+    if (!isCalledIdentifier(expression, ACCEPTED_WRAPPERS) && expression.type === 'NewExpression') {
+        var callee = expression.callee;
+        if ((callee === null || callee === void 0 ? void 0 : callee.type) === 'Identifier' && SUBJECT_NAMES.has(callee.name) && isImportedFrom(registry, callee.name, RXJS_MODULE)) {
+            result = callee.name;
+        }
+    }
+    return result;
+}
+/**
+ * Builds the composite fix for one violating property.
+ *
+ * @param input - The flagged expression, its property name, the class's ngOnDestroy node, the import registry, and source-code services.
+ * @returns A list of fix operations.
+ */ function buildSubjectFix(input) {
+    var fixer = input.fixer, newExpr = input.newExpr, propName = input.propName, ngOnDestroy = input.ngOnDestroy, registry = input.registry, sourceCode = input.sourceCode;
+    var fixes = [];
+    fixes.push(fixer.insertTextBefore(newExpr, "".concat(COMPLETE_ON_DESTROY_HELPER, "(")));
+    fixes.push(fixer.insertTextAfter(newExpr, ')'));
+    var importFix = ensureNamedImportFix({
+        fixer: fixer,
+        registry: registry,
+        importName: COMPLETE_ON_DESTROY_HELPER,
+        fromSource: DEREEKB_DBX_CORE_MODULE
+    });
+    if (importFix) {
+        fixes.push(importFix);
+    }
+    if (ngOnDestroy) {
+        collectNgOnDestroyRemovalFixes({
+            fixer: fixer,
+            ngOnDestroy: ngOnDestroy,
+            propName: propName,
+            methodName: 'complete',
+            sourceCode: sourceCode,
+            fixes: fixes
+        });
+    }
+    return fixes;
+}
+
+/**
+ * Identifier names that, when used to wrap a class field initializer, mean the
+ * field's cleanup is registered with Angular DestroyRef and a manual
+ * `.destroy()` / `.complete()` call in ngOnDestroy is redundant.
+ */ var HELPER_NAMES = new Set([
+    CLEAN_SUBSCRIPTION_HELPER,
+    COMPLETE_ON_DESTROY_HELPER,
+    CLEAN_HELPER
+]);
+/**
+ * Method names on a wrapped field whose call inside ngOnDestroy is redundant.
+ */ var REDUNDANT_METHODS = new Set([
+    'destroy',
+    'complete'
+]);
+/**
+ * ESLint rule that flags `ngOnDestroy()` bodies whose statements are entirely
+ * redundant `this.<field>.destroy()` / `this.<field>.complete()` calls on
+ * fields whose initializer is wrapped with `cleanSubscription`,
+ * `completeOnDestroy`, or `clean`.
+ *
+ * Auto-fix:
+ * - Removes each redundant statement, plus its leading whitespace and trailing newline.
+ * - Removes the `ngOnDestroy` method declaration when its body becomes empty.
+ * - When the `ngOnDestroy` method is removed entirely, also removes the
+ *   `implements OnDestroy` clause from the class (verified against the
+ *   `@angular/core` import). The now-unused `OnDestroy` import is left for
+ *   `eslint-plugin-unused-imports` to clean up.
+ * - 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 = {
+    meta: {
+        type: 'suggestion',
+        fixable: 'code',
+        docs: {
+            description: 'Disallow redundant ngOnDestroy calls when fields are already wrapped with cleanSubscription/completeOnDestroy/clean',
+            recommended: true
+        },
+        messages: {
+            redundantCleanupCall: 'Redundant `this.{{name}}.{{method}}()` — `{{name}}` is initialized via `{{wrapper}}(...)` which already registers cleanup with Angular DestroyRef.',
+            redundantNgOnDestroy: '`ngOnDestroy()` only contains redundant cleanup calls for fields wrapped with cleanSubscription/completeOnDestroy/clean. Remove the method.',
+            emptyNgOnDestroy: '`ngOnDestroy()` has an empty body. Remove the method.',
+            orphanedImplementsOnDestroy: 'Class declares `implements OnDestroy` but has no `ngOnDestroy()` method. Remove the implements clause.'
+        },
+        schema: []
+    },
+    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) {
+                context.report({
+                    node: ngOnDestroy,
+                    messageId: 'emptyNgOnDestroy',
+                    fix: function fix(fixer) {
+                        return buildRemoveNgOnDestroyFixes({
+                            fixer: fixer,
+                            ngOnDestroy: ngOnDestroy,
+                            classNode: classNode,
+                            registry: registry,
+                            sourceCode: sourceCode
+                        });
+                    }
+                });
+                return;
+            }
+            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;
+                    }
+                }
+            }
+            if (redundantStatements.length === 0) {
+                return;
+            }
+            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;
+                        }
+                    }
+                }
+            } else {
+                context.report({
+                    node: ngOnDestroy,
+                    messageId: 'redundantNgOnDestroy',
+                    fix: function fix(fixer) {
+                        return buildRemoveNgOnDestroyFixes({
+                            fixer: fixer,
+                            ngOnDestroy: ngOnDestroy,
+                            classNode: classNode,
+                            registry: registry,
+                            sourceCode: sourceCode
+                        });
+                    }
+                });
+            }
+        };
+        return {
+            ImportDeclaration: function ImportDeclaration(node) {
+                trackImportDeclaration(registry, node);
+            },
+            ClassDeclaration: function ClassDeclaration(classNode) {
+                visitClass(classNode);
+            },
+            ClassExpression: function ClassExpression(classNode) {
+                visitClass(classNode);
+            }
+        };
+    }
+};
+/**
+ * Walks the class members and returns a map of property name to the wrapper
+ * helper used in its initializer (`cleanSubscription`, `completeOnDestroy`, or
+ * `clean`). Properties whose initializer is not a recognized wrapper are
+ * omitted.
+ *
+ * @param classNode - The ClassDeclaration / ClassExpression AST node.
+ * @returns Map of field name to wrapper helper name.
+ */ function collectWrappedFieldNames(classNode) {
+    var _ref;
+    var _classNode_body;
+    var result = new Map();
+    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 wrapper = propName ? wrapperNameFromInitializer(member.value) : null;
+            if (propName && wrapper) {
+                result.set(propName, wrapper);
+            }
+        }
+    } catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    } finally{
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        } finally{
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Returns the name of the cleanup helper wrapping the given initializer
+ * expression, or null when the expression is not wrapped.
+ *
+ * @param expression - The initializer expression, or null/undefined.
+ * @returns The wrapper helper name (`cleanSubscription` etc.) or null.
+ */ function wrapperNameFromInitializer(expression) {
+    return expression ? isCalledIdentifier(expression, HELPER_NAMES) : null;
+}
+/**
+ * Returns details for a redundant cleanup statement, or null when the
+ * statement is anything other than a redundant `this.<field>.<destroy|complete>()` call.
+ *
+ * @param statement - The body statement AST node.
+ * @param wrappedFields - Map of class field names to their wrapper helper names.
+ * @returns Match details, or null.
+ */ 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
+                    };
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Builds the fix list for removing the entire `ngOnDestroy` method along with
+ * any matching `implements OnDestroy` clause from the class declaration.
+ *
+ * @param input - The fixer, method node, class node, registry, and source-code service.
+ * @returns The fix operations to apply.
+ */ function buildRemoveNgOnDestroyFixes(input) {
+    var fixer = input.fixer, ngOnDestroy = input.ngOnDestroy, classNode = input.classNode, registry = input.registry, sourceCode = input.sourceCode;
+    var fixes = [
+        fixer.removeRange(getStatementRangeWithLeadingWhitespace(ngOnDestroy, sourceCode))
+    ];
+    var implementsMatch = findOnDestroyImplementsClause(classNode, registry);
+    if (implementsMatch) {
+        fixes.push(fixer.removeRange(getImplementsSpecifierRemovalRange(implementsMatch, sourceCode)));
+    }
+    return fixes;
+}
+
+/**
+ * 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 = {
+    rules: {
+        'require-clean-subscription': dbxWebRequireCleanSubscriptionRule,
+        'require-complete-on-destroy': dbxWebRequireCompleteOnDestroyRule,
+        'no-redundant-on-destroy': dbxWebNoRedundantOnDestroyRule
+    }
+};
+
+export { dbxWebEslintPlugin, dbxWebNoRedundantOnDestroyRule, dbxWebRequireCleanSubscriptionRule, dbxWebRequireCompleteOnDestroyRule };