@simbiat/eslint-plugin-simbiat 1.0.0

package/dist/rules/PreferFieldInitializer.mjs

@@ -0,0 +1,289 @@
+/**
+ * @file Rule: simbiat/prefer-field-initializer.
+ * Flags `this.x = expr` assignments in a class `constructor` where all the following hold:
+ * 1. `x` already has a class field declaration (PropertyDefinition).
+ * 2. The RHS does NOT reference a constructor parameter by name because those values are unavailable at a declaration site.
+ * 3. The RHS does NOT reference a local variable declared inside the constructor body because those values are also unavailable at the declaration site.
+ * 4. The RHS does NOT contain `this.anything` – field-initializer ordering versus constructor-assignment ordering can differ subtly, so those are left for the developer to evaluate.
+ * Only top-level assignment statements in the constructor body are checked.
+ * Assignments inside if / else / for / for-of / for-in / while / do-while / switch / try-catch blocks, or inside nested functions / arrow functions, are intentionally ignored – they are conditional or deferred and cannot be safely lifted to a field initializer.
+ * No auto-fix is provided: the change involves removing the assignment AND updating the field declaration simultaneously; doing that incorrectly could silently break the program.
+ */
+import { adaptNodeHandler, adaptStateHandler } from '../utils/Adapters.mjs';
+import { collectFieldNames, collectParamNames, collectLocalNames, containsThisAccess, containsIdentifierRef, } from '../utils/ASTHelpers.mjs';
+// Stack helpers
+/**
+ * `True` only when the top of the stack is a constructor-method entry with no
+ * intervening 'block' or 'fn' markers.
+ * @param stack - Current stack array.
+ * @returns True when the top stack entry is a constructor method.
+ */
+function isDirectlyInMethod(stack) {
+    return stack[stack.length - 1]?.kind === 'method';
+}
+/**
+ * Returns the field-name set of the class that owns the current method.
+ * @param stack - Current stack array.
+ * @returns Set of field names from the nearest enclosing class entry.
+ */
+function currentFieldNames(stack) {
+    for (let i = stack.length - 1; i >= 0; i--) {
+        // eslint-disable-next-line security/detect-object-injection
+        const entry = stack[i];
+        if (entry?.kind === 'class') {
+            return entry.fieldNames;
+        }
+    }
+    return new Set();
+}
+// Visitor handlers
+/**
+ * Pushes a 'class' entry when entering a class.
+ * @param state - Rule state.
+ * @param node - Class declaration or expression node (as unknown from ESLint).
+ */
+function onClass(state, node) {
+    state.stack.push({
+        kind: 'class',
+        fieldNames: collectFieldNames(node),
+        node,
+    });
+}
+/**
+ * Pops the 'class' entry when leaving a class.
+ * @param state - Rule state.
+ */
+function onClassExit(state) {
+    if (state.stack[state.stack.length - 1]?.kind === 'class') {
+        state.stack.pop();
+    }
+}
+/**
+ * Pushes a 'method' entry when entering a constructor MethodDefinition.
+ * @param state - Rule state.
+ * @param node - MethodDefinition node (as unknown from ESLint).
+ */
+function onMethodDefinition(state, node) {
+    const method = node;
+    const top = state.stack[state.stack.length - 1];
+    if (top?.kind !== 'class') {
+        return;
+    }
+    if (top.node !== method.parent?.parent) {
+        return;
+    }
+    if (method.kind !== 'constructor') {
+        return;
+    }
+    // Collect constructor parameter names.
+    const param_names = new Set();
+    for (const param of method.value.params) {
+        collectParamNames(param, param_names);
+    }
+    // Pre-scan the entire constructor body for local variable names.
+    const local_names = new Set();
+    collectLocalNames(method.value.body, local_names);
+    state.stack.push({
+        kind: 'method',
+        methodName: 'constructor',
+        paramNames: param_names,
+        localNames: local_names,
+    });
+}
+/**
+ * Pops the 'method' entry when leaving a MethodDefinition.
+ * @param state - Rule state.
+ */
+function onMethodDefinitionExit(state) {
+    if (state.stack[state.stack.length - 1]?.kind === 'method') {
+        state.stack.pop();
+    }
+}
+/**
+ * Pushes a 'block' marker when entering any control-flow statement.
+ * @param state - Rule state.
+ */
+function onControlFlowEnter(state) {
+    const top = state.stack[state.stack.length - 1];
+    if (top?.kind === 'method' || top?.kind === 'block') {
+        state.stack.push({ kind: 'block' });
+    }
+}
+/**
+ * Pops the 'block' marker when leaving a control-flow statement.
+ * @param state - Rule state.
+ */
+function onControlFlowExit(state) {
+    if (state.stack[state.stack.length - 1]?.kind === 'block') {
+        state.stack.pop();
+    }
+}
+/**
+ * Pushes "fn" marker when entering a FunctionExpression that is not a method.
+ * @param state - Rule state.
+ * @param node - FunctionExpression node (as unknown from ESLint).
+ */
+function onFunctionExpression(state, node) {
+    const fn = node;
+    if (fn.parent?.type === 'MethodDefinition') {
+        return;
+    }
+    const top = state.stack[state.stack.length - 1];
+    if (top?.kind === 'method' || top?.kind === 'fn' || top?.kind === 'block') {
+        state.stack.push({ kind: 'fn' });
+    }
+}
+/**
+ * Pops the 'fn' marker when leaving a FunctionExpression.
+ * @param state - Rule state.
+ * @param node - FunctionExpression node (as unknown from ESLint).
+ */
+function onFunctionExpressionExit(state, node) {
+    const fn = node;
+    if (fn.parent?.type === 'MethodDefinition') {
+        return;
+    }
+    if (state.stack[state.stack.length - 1]?.kind === 'fn') {
+        state.stack.pop();
+    }
+}
+/**
+ * Pushes "fn" marker when entering an ArrowFunctionExpression inside a method.
+ * @param state - Rule state.
+ */
+function onArrowFunctionExpression(state) {
+    const top = state.stack[state.stack.length - 1];
+    if (top?.kind === 'method' || top?.kind === 'fn' || top?.kind === 'block') {
+        state.stack.push({ kind: 'fn' });
+    }
+}
+/**
+ * Pops the 'fn' marker when leaving an ArrowFunctionExpression.
+ * @param state - Rule state.
+ */
+function onArrowFunctionExpressionExit(state) {
+    if (state.stack[state.stack.length - 1]?.kind === 'fn') {
+        state.stack.pop();
+    }
+}
+/**
+ * Reports `this.x = expr` assignments where x is a declared field
+ * whose initializer could be moved to the field declaration.
+ * @param state - Rule state.
+ * @param node - AssignmentExpression node to inspect (as unknown from ESLint).
+ */
+function onAssignmentExpression(state, node) {
+    if (!isDirectlyInMethod(state.stack)) {
+        return;
+    }
+    const assign = node;
+    if (assign.operator !== '=') {
+        return;
+    }
+    const { left, right, } = assign;
+    if (left.type !== 'MemberExpression') {
+        return;
+    }
+    if (left.object.type !== 'ThisExpression') {
+        return;
+    }
+    if (left.property.type !== 'Identifier') {
+        return;
+    }
+    if (left.computed) {
+        return;
+    }
+    const prop_name = left.property.name;
+    if (!currentFieldNames(state.stack)
+        .has(prop_name)) {
+        return;
+    }
+    if (containsThisAccess(right)) {
+        return;
+    }
+    const method_state = state.stack[state.stack.length - 1];
+    if (method_state?.kind !== 'method') {
+        return;
+    }
+    if (containsIdentifierRef(right, method_state.paramNames)) {
+        return;
+    }
+    if (containsIdentifierRef(right, method_state.localNames)) {
+        return;
+    }
+    state.context.report({
+        node: node,
+        messageId: 'preferInitializer',
+        data: {
+            name: prop_name,
+            method: method_state.methodName,
+        },
+    });
+}
+// Rule definition
+/**
+ * Stack entry shapes:
+ * { kind: 'class', fieldNames: Set<string>, node: ClassNode }
+ * { kind: 'method', methodName: string, paramNames: Set<string>, localNames: Set<string> }
+ * { kind: 'block' } ← inside a control-flow statement (if/for/while/switch/try)
+ * { kind: 'fn' } ← inside a nested function or arrow function.
+ */
+const preferFieldInitializer = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Suggest moving this.x = … assignments in constructor to class field initializers.',
+        },
+        messages: {
+            preferInitializer: '\'{{name}}\' is declared as a class field. Move its initializer to the field declaration instead of assigning it in {{method}}.',
+        },
+        schema: [],
+        hasSuggestions: false,
+    },
+    /**
+     * Create rule.
+     * @param context - Context to process.
+     */
+    create(context) {
+        const state = {
+            context,
+            stack: [],
+        };
+        // Control-flow statement types whose bodies must not be treated as
+        // top-level constructor statements.
+        const cf_enter = adaptStateHandler(state, onControlFlowEnter);
+        const cf_exit = adaptStateHandler(state, onControlFlowExit);
+        return {
+            'ClassDeclaration': adaptNodeHandler(state, onClass),
+            'ClassExpression': adaptNodeHandler(state, onClass),
+            'ClassDeclaration:exit': adaptStateHandler(state, onClassExit),
+            'ClassExpression:exit': adaptStateHandler(state, onClassExit),
+            'MethodDefinition': adaptNodeHandler(state, onMethodDefinition),
+            'MethodDefinition:exit': adaptStateHandler(state, onMethodDefinitionExit),
+            // Control-flow blocks – push 'block' so assignments inside are ignored.
+            'IfStatement': cf_enter,
+            'IfStatement:exit': cf_exit,
+            'ForStatement': cf_enter,
+            'ForStatement:exit': cf_exit,
+            'ForInStatement': cf_enter,
+            'ForInStatement:exit': cf_exit,
+            'ForOfStatement': cf_enter,
+            'ForOfStatement:exit': cf_exit,
+            'WhileStatement': cf_enter,
+            'WhileStatement:exit': cf_exit,
+            'DoWhileStatement': cf_enter,
+            'DoWhileStatement:exit': cf_exit,
+            'SwitchStatement': cf_enter,
+            'SwitchStatement:exit': cf_exit,
+            'TryStatement': cf_enter,
+            'TryStatement:exit': cf_exit,
+            // Nested functions / arrows – push 'fn' to suppress entirely.
+            'FunctionExpression': adaptNodeHandler(state, onFunctionExpression),
+            'FunctionExpression:exit': adaptNodeHandler(state, onFunctionExpressionExit),
+            'ArrowFunctionExpression': adaptStateHandler(state, onArrowFunctionExpression),
+            'ArrowFunctionExpression:exit': adaptStateHandler(state, onArrowFunctionExpressionExit),
+            'AssignmentExpression': adaptNodeHandler(state, onAssignmentExpression),
+        };
+    },
+};
+export default preferFieldInitializer;

package/dist/rules/RequireListenerCleanup.d.mts

@@ -0,0 +1,28 @@
+/**
+ * @file Rule: simbiat/require-listener-cleanup.
+ *
+ * Verifies that every `addEventListener` call on an external target inside
+ * `connectedCallback` of an HTMLElement subclass has a matching
+ * `removeEventListener` call in `disconnectedCallback`.
+ *
+ * "External targets" are: document, window, `document.body`,
+ * document.documentElement, document.head.
+ * (Self-listeners on `this` and shadow-root listeners are not checked.)
+ *
+ * Three problems are reported (five messageIds total):
+ *
+ * Inline handler (inlineHandler): An arrow function or function expression passed directly cannot be referenced in removeEventListener, so the listener will always leak.
+ *
+ * Bound handler on `add` (boundHandler): every .bind() call returns a fresh function object, so the reference stored by the browser can never be matched later.
+ *
+ * No matching removal (notRemoved): an addEventListener call whose combination of target + event-type + handler reference has no corresponding removeEventListener call in disconnectedCallback. Autofix is available when the handler is a class field reference (this.foo / this.#foo).
+ *
+ * Dynamic event type (dynamicType): a non-literal event type cannot be statically matched.
+ *
+ * Bound handler on removal (boundRemoval): `.bind()` in removeEventListener creates a new reference that will not match the originally registered listener.
+ *
+ * Options: baseClasses: string[] – additional class names to treat as HTMLElement. Defaults to ['HTMLElement'].
+ */
+import type { Rule } from 'eslint';
+declare const requireListenerCleanup: Rule.RuleModule;
+export default requireListenerCleanup;

package/dist/rules/RequireListenerCleanup.mjs

@@ -0,0 +1,361 @@
+/**
+ * @file Rule: simbiat/require-listener-cleanup.
+ *
+ * Verifies that every `addEventListener` call on an external target inside
+ * `connectedCallback` of an HTMLElement subclass has a matching
+ * `removeEventListener` call in `disconnectedCallback`.
+ *
+ * "External targets" are: document, window, `document.body`,
+ * document.documentElement, document.head.
+ * (Self-listeners on `this` and shadow-root listeners are not checked.)
+ *
+ * Three problems are reported (five messageIds total):
+ *
+ * Inline handler (inlineHandler): An arrow function or function expression passed directly cannot be referenced in removeEventListener, so the listener will always leak.
+ *
+ * Bound handler on `add` (boundHandler): every .bind() call returns a fresh function object, so the reference stored by the browser can never be matched later.
+ *
+ * No matching removal (notRemoved): an addEventListener call whose combination of target + event-type + handler reference has no corresponding removeEventListener call in disconnectedCallback. Autofix is available when the handler is a class field reference (this.foo / this.#foo).
+ *
+ * Dynamic event type (dynamicType): a non-literal event type cannot be statically matched.
+ *
+ * Bound handler on removal (boundRemoval): `.bind()` in removeEventListener creates a new reference that will not match the originally registered listener.
+ *
+ * Options: baseClasses: string[] – additional class names to treat as HTMLElement. Defaults to ['HTMLElement'].
+ */
+import { adaptNodeHandler } from '../utils/Adapters.mjs';
+import { isExternalTarget, targetName } from '../utils/ASTHelpers.mjs';
+import { baseClassesSchema } from '../utils/CustomElementsScope.mjs';
+// AST utilities
+const SKIP_KEYS = new Set(['type', 'parent', 'loc', 'range', 'start', 'end']);
+/**
+ * Walks an AST subtree, calling `visit` for every node, without descending
+ * into FunctionExpression / FunctionDeclaration / ArrowFunctionExpression
+ * boundaries. This is used to collect calls that execute directly (not
+ * inside a deferred callback).
+ * @param node - Root node to walk.
+ * @param visit - Callback invoked for every visited node.
+ */
+function walkNoFunctions(node, visit) {
+    if (node === null || typeof node !== 'object') {
+        return;
+    }
+    const n = node;
+    if (n.type === 'FunctionExpression'
+        || n.type === 'FunctionDeclaration'
+        || n.type === 'ArrowFunctionExpression') {
+        return;
+    }
+    visit(n);
+    for (const [key, val] of Object.entries(n)) {
+        if (SKIP_KEYS.has(key)) {
+            continue;
+        }
+        if (Array.isArray(val)) {
+            for (const child of val) {
+                walkNoFunctions(child, visit);
+            }
+        }
+        else if (val !== null && typeof val === 'object' && typeof val.type === 'string') {
+            walkNoFunctions(val, visit);
+        }
+    }
+}
+// Target helpers
+/**
+ * Returns true when the handler argument is an inline function that cannot be removed.
+ * @param node - Handler AST node to test.
+ * @returns True if the handler is an inline function or arrow function.
+ */
+function isInlineHandler(node) {
+    return (node.type === 'FunctionExpression'
+        || node.type === 'ArrowFunctionExpression');
+}
+/**
+ * Returns true when the handler argument is a `.bind(…)` call.
+ * Every call to `.bind()` returns a *new* function object, so the reference
+ * passed to addEventListener can never equal the one passed to
+ * removeEventListener – even when the source text looks identical.
+ * @param node - Handler AST node to test.
+ * @returns True if the handler is a .bind() call expression.
+ */
+function isBoundHandler(node) {
+    return (node.type === 'CallExpression'
+        && node.callee?.type === 'MemberExpression'
+        && node.callee.property?.type === 'Identifier'
+        && node.callee.property.name === 'bind');
+}
+/**
+ * Returns true when the handler is a member expression on `this` - i.e., a class
+ * field or method reference such as `this.onClick` or `this.#onClick`.
+ * These are stable references that can be passed identically to both
+ * addEventListener and removeEventListener, making autofix safe.
+ * @param node - Handler AST node to test.
+ * @returns True if the handler is a `this.foo` or `this.#foo` reference.
+ */
+function isClassFieldHandler(node) {
+    return (node.type === 'MemberExpression'
+        && node.object?.type === 'ThisExpression');
+}
+// Call collection
+/**
+ * Collects all addEventListener or removeEventListener calls on external
+ * targets from a list of statements, without descending into nested functions.
+ * @param statements - Array of statement nodes to scan.
+ * @param method_name - Either 'addEventListener' or 'removeEventListener'.
+ * @param source_code - ESLint SourceCode object for text retrieval.
+ * @returns Array of collected listener call descriptors.
+ */
+function collectListenerCalls(statements, method_name, source_code) {
+    const calls = [];
+    for (const stmt of statements) {
+        walkNoFunctions(stmt, (node) => {
+            if (node.type !== 'CallExpression') {
+                return;
+            }
+            const { callee } = node;
+            if (callee?.type !== 'MemberExpression'
+                || callee.property?.type !== 'Identifier'
+                || callee.property.name !== method_name) {
+                return;
+            }
+            if (!isExternalTarget(callee.object)) {
+                return;
+            }
+            // Require at least (type, handler) arguments.
+            const type_arg = node.arguments?.[0];
+            const handler_arg = node.arguments?.[1];
+            if (typeof type_arg === 'undefined' || typeof handler_arg === 'undefined') {
+                return;
+            }
+            calls.push({
+                node,
+                target: targetName(callee.object, '(unknown)'),
+                // eslint-disable-next-line @typescript-eslint/no-base-to-string -- Literal.value is always a primitive at runtime
+                event_type: type_arg.type === 'Literal' ? String(type_arg.value) : null,
+                handler_text: source_code.getText(handler_arg),
+                handler_node: handler_arg,
+                handler_inline: isInlineHandler(handler_arg),
+                handler_bound: isBoundHandler(handler_arg),
+                handler_is_field: isClassFieldHandler(handler_arg),
+            });
+        });
+    }
+    return calls;
+}
+// Class body inspection
+/**
+ * Finds a named instance method in a class body and returns its
+ * MethodDefinition node, or null if not found.
+ * @param class_node - The class declaration or expression node.
+ * @param name - Name of the method to find.
+ * @returns The MethodDefinition node if found, otherwise null.
+ */
+function findMethod(class_node, name) {
+    return (class_node.body?.body.find((member) => {
+        return member.type === 'MethodDefinition'
+            && member.kind === 'method'
+            && member.static !== true
+            && member.key?.type === 'Identifier'
+            && member.key.name === name;
+    }) ?? null);
+}
+/**
+ * Returns a fixer function that inserts the matching removeEventListener call
+ * into disconnectedCallback, creating the method if it does not yet exist.
+ * Only called when the handler is a class field reference (this.foo / this.#foo).
+ * @param add - Collected addEventListener call info.
+ * @param connected_method - MethodDefinition for connectedCallback.
+ * @param connected_stmts - Body statements of connectedCallback.
+ * @param disconnected_method - MethodDefinition for disconnectedCallback, or null.
+ * @param source_code - ESLint SourceCode object.
+ * @returns A fixer function to insert the removeEventListener call.
+ */
+function buildRemovalFix(add, connected_method, connected_stmts, disconnected_method, source_code) {
+    return (fixer) => {
+        // Detect the line ending convention used in this file.
+        const eol = source_code.getText()
+            .includes('\r\n')
+            ? '\r\n'
+            : '\n';
+        const method_indent = ' '.repeat(connected_method.loc?.start.column ?? 0);
+        // Quote the event type safely.
+        const event_type = add.event_type ?? '';
+        const quoted_type = event_type.includes('\'')
+            ? `"${event_type}"`
+            : `'${event_type}'`;
+        const remove_stmt = `${add.target}.removeEventListener(${quoted_type}, ${add.handler_text});`;
+        if (disconnected_method !== null) {
+            // Infer body indent from disconnectedCallback's own statements, falling
+            // back to connectedCallback's body indent if the method is currently empty.
+            const dis_stmts = disconnected_method.value?.body?.body ?? [];
+            const ref_stmt = dis_stmts[0] ?? connected_stmts[0];
+            const body_indent = typeof ref_stmt?.loc === 'undefined'
+                ? `${method_indent}  `
+                : ' '.repeat(ref_stmt.loc.start.column);
+            // Insert AFTER the previous token. Otherwise, steals the whitespace before curly brace.
+            const body_node = disconnected_method.value?.body;
+            const prev_token = source_code.getTokenBefore(source_code.getLastToken(body_node));
+            return fixer.insertTextAfter(prev_token, `${eol}${body_indent}${remove_stmt}`);
+        }
+        // No disconnectedCallback at all - infer body indent from connectedCallback
+        // and generate the entire method immediately after connectedCallback.
+        const body_indent = typeof connected_stmts[0]?.loc === 'undefined'
+            ? `${method_indent}  `
+            : ' '.repeat(connected_stmts[0].loc.start.column);
+        return fixer.insertTextAfter(connected_method, `${eol}${eol}${method_indent}disconnectedCallback() {${eol}${body_indent}${remove_stmt}${eol}${method_indent}}`);
+    };
+}
+/**
+ * Checks an HTMLElement subclass for external addEventListener calls that are
+ * not cleaned up in disconnectedCallback.
+ * @param node - Class declaration or expression node to inspect.
+ * @param base_classes - List of base class names considered as HTMLElement.
+ * @param source_code - ESLint SourceCode object.
+ * @param context - ESLint rule context.
+ */
+function checkClass(node, base_classes, source_code, context) {
+    // Only check classes that directly extend a known base class.
+    if (node.superClass?.type !== 'Identifier') {
+        return;
+    }
+    if (!base_classes.includes(node.superClass.name ?? '')) {
+        return;
+    }
+    const connected_method = findMethod(node, 'connectedCallback');
+    if (connected_method === null) {
+        return; // nothing in connectedCallback to check
+    }
+    const connected_stmts = connected_method.value?.body?.body ?? [];
+    const disconnected_method = findMethod(node, 'disconnectedCallback');
+    const disconnected_stmts = disconnected_method?.value?.body?.body ?? [];
+    const add_calls = collectListenerCalls(connected_stmts, 'addEventListener', source_code);
+    const rem_calls = collectListenerCalls(disconnected_stmts, 'removeEventListener', source_code);
+    for (const add of add_calls) {
+        // Inline handler: can never be removed
+        if (add.handler_inline) {
+            context.report({
+                node: add.node,
+                messageId: 'inlineHandler',
+                data: {
+                    eventType: add.event_type ?? '(dynamic)',
+                    target: add.target,
+                },
+            });
+            continue;
+        }
+        // Bound handler: .bind() always produces a new reference, so removal is impossible
+        if (add.handler_bound) {
+            context.report({
+                node: add.node,
+                messageId: 'boundHandler',
+                data: {
+                    eventType: add.event_type ?? '(dynamic)',
+                    target: add.target,
+                },
+            });
+            continue;
+        }
+        // Dynamic event type: cannot match statically
+        if (add.event_type === null) {
+            context.report({
+                node: add.node,
+                messageId: 'dynamicType',
+                data: { target: add.target },
+            });
+            continue;
+        }
+        // Check for matching removeEventListener.
+        // All three need to match: target, event type, and handler source text.
+        const matched_rem = rem_calls.find((rem) => {
+            return rem.target === add.target
+                && rem.event_type === add.event_type
+                && rem.handler_text === add.handler_text;
+        });
+        if (typeof matched_rem === 'undefined') {
+            context.report({
+                node: add.node,
+                messageId: 'notRemoved',
+                data: {
+                    eventType: add.event_type,
+                    target: add.target,
+                },
+                // Autofix is only safe when the handler is a stable `this.foo` /
+                // `this.#foo` reference.
+                fix: add.handler_is_field
+                    ? buildRemovalFix(add, connected_method, connected_stmts, disconnected_method, source_code)
+                    : null,
+            });
+        }
+        else if (matched_rem.handler_bound) {
+            // Text matched, but the removal uses .bind() – a new reference each time,
+            // so the original listener will never actually be removed.
+            context.report({
+                node: matched_rem.node,
+                messageId: 'boundRemoval',
+                data: {
+                    eventType: add.event_type,
+                    target: add.target,
+                },
+            });
+        }
+    }
+}
+// Rule visitor handler (top-level, adapted via adaptNodeHandler in `create`)
+/**
+ * Top-level ESLint visitor for ClassDeclaration / ClassExpression exit nodes.
+ * @param state - Class check state with base classes, source code, and context.
+ * @param node - Class node from ESLint.
+ */
+function onClassExit(state, node) {
+    checkClass(node, state.base_classes, state.source_code, state.context);
+}
+// Rule definition
+const requireListenerCleanup = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Require removeEventListener in disconnectedCallback for each addEventListener on external targets in connectedCallback.',
+        },
+        messages: {
+            inlineHandler: 'The \'{{eventType}}\' listener on {{target}} uses an inline function that can never be passed to removeEventListener – the listener will leak. '
+                + 'Store the handler as a class field (e.g. #handler = (e) => { … }) and remove it in disconnectedCallback.',
+            boundHandler: 'The \'{{eventType}}\' listener on {{target}} uses a .bind() call, which creates a new function reference each time – '
+                + 'it can never be matched by removeEventListener and will leak. '
+                + 'Store the bound handler as a class field (e.g. #handler = this.onEvent.bind(this)) and remove it in disconnectedCallback.',
+            boundRemoval: 'The \'{{eventType}}\' listener on {{target}} is removed with a .bind() call, which creates a new function reference and will not match '
+                + 'the originally added listener – the listener will leak. '
+                + 'Store the bound handler as a class field (e.g. #handler = this.onEvent.bind(this)) and pass that field to both addEventListener and removeEventListener.',
+            notRemoved: 'The \'{{eventType}}\' listener on {{target}} added in connectedCallback has no matching removeEventListener call in disconnectedCallback. '
+                + 'Add: {{target}}.removeEventListener(\'{{eventType}}\', <handler>) inside disconnectedCallback.',
+            dynamicType: 'A listener with a dynamic event type on {{target}} is added in connectedCallback. '
+                + 'Ensure a matching removeEventListener call with the same type and handler exists in disconnectedCallback.',
+        },
+        schema: baseClassesSchema,
+        fixable: 'code',
+        hasSuggestions: false,
+    },
+    /**
+     * Creates the rule listeners.
+     * @param context - ESLint rule context.
+     * @returns Rule listener object.
+     */
+    create(context) {
+        const options = context.options[0];
+        const base_classes = options?.baseClasses ?? ['HTMLElement'];
+        // `sourceCode` is the current API; fall back to the deprecated getter for
+        // older ESLint versions.
+        const legacy_context = context;
+        const source_code = context.sourceCode ?? legacy_context.getSourceCode();
+        const check_state = {
+            base_classes,
+            source_code,
+            context,
+        };
+        return {
+            'ClassDeclaration:exit': adaptNodeHandler(check_state, onClassExit),
+            'ClassExpression:exit': adaptNodeHandler(check_state, onClassExit),
+        };
+    },
+};
+export default requireListenerCleanup;