eslint-plugin-runtime-cleanup 1.2.8

package/dist/_internal/safe-type-operation.js

@@ -0,0 +1,147 @@
+/**
+ * @packageDocumentation
+ * Structured error handling for best-effort typed AST operations.
+ */
+/**
+ * Shared observer set for operation failures across rule modules.
+ *
+ * @remarks
+ * Observers are intentionally process-local and opt-in; they exist for
+ * diagnostics and test instrumentation only.
+ */
+const safeTypeOperationFailureObservers = new Set();
+/**
+ * Shared observer set for local/global observer failures.
+ */
+const safeTypeOperationObserverFailureObservers = new Set();
+/**
+ * Notify all registered observer-failure observers.
+ *
+ * @param failure - Observer-failure payload.
+ */
+const notifySafeTypeOperationObserverFailureObservers = (failure) => {
+    for (const observer of safeTypeOperationObserverFailureObservers) {
+        try {
+            observer(failure);
+        }
+        catch {
+            // Observer-failure observers are diagnostics only; never rethrow.
+        }
+    }
+};
+/**
+ * Notify all registered global failure observers.
+ *
+ * @param failure - Failure payload emitted by a typed operation.
+ */
+const notifySafeTypeOperationFailureObservers = (failure) => {
+    for (const observer of safeTypeOperationFailureObservers) {
+        try {
+            observer(failure);
+        }
+        catch (observerError) {
+            notifySafeTypeOperationObserverFailureObservers({
+                failure,
+                observerError,
+                observerKind: "global",
+            });
+        }
+    }
+};
+/**
+ * Register a process-local observer for observer failures.
+ *
+ * @param observer - Callback invoked when a local/global failure observer
+ *   throws.
+ *
+ * @returns Unsubscribe callback to remove the observer.
+ */
+export const registerSafeTypeOperationObserverFailureObserver = (observer) => {
+    safeTypeOperationObserverFailureObservers.add(observer);
+    return () => {
+        safeTypeOperationObserverFailureObservers.delete(observer);
+    };
+};
+/**
+ * Register a process-local failure observer for typed operations.
+ *
+ * @param observer - Callback invoked for each operation failure.
+ *
+ * @returns Unsubscribe callback to remove the observer.
+ */
+export const registerSafeTypeOperationFailureObserver = (observer) => {
+    safeTypeOperationFailureObservers.add(observer);
+    return () => {
+        safeTypeOperationFailureObservers.delete(observer);
+    };
+};
+/**
+ * Run one operation with a scoped failure observer that is always cleaned up.
+ *
+ * @param observer - Observer registered for the operation scope.
+ * @param operation - Synchronous operation to execute while observing failures.
+ *
+ * @returns Return value produced by `operation`.
+ */
+export const withSafeTypeOperationFailureObserver = (observer, operation) => {
+    const unsubscribe = registerSafeTypeOperationFailureObserver(observer);
+    try {
+        return operation();
+    }
+    finally {
+        unsubscribe();
+    }
+};
+/**
+ * Execute a typed operation with structured failure output instead of throws.
+ */
+export const safeTypeOperation = ({ onFailure, operation, reason, }) => {
+    try {
+        return {
+            ok: true,
+            value: operation(),
+        };
+    }
+    catch (error) {
+        const failure = {
+            error,
+            reason,
+        };
+        try {
+            onFailure?.(failure);
+        }
+        catch (observerError) {
+            notifySafeTypeOperationObserverFailureObservers({
+                failure,
+                observerError,
+                observerKind: "local",
+            });
+        }
+        notifySafeTypeOperationFailureObservers(failure);
+        return {
+            failure,
+            ok: false,
+        };
+    }
+};
+/**
+ * Build a lightweight reason counter for debugging operation failures in tests.
+ *
+ * @param reasonsForTypeInference - Optional typed reason literals used to infer
+ *   the `Reason` generic without requiring explicit type parameters.
+ */
+export const createSafeTypeOperationCounter = (reasonsForTypeInference = []) => {
+    const counts = new Map();
+    for (const reason of reasonsForTypeInference) {
+        counts.set(reason, counts.get(reason) ?? 0);
+    }
+    const onFailure = (failure) => {
+        const previousCount = counts.get(failure.reason) ?? 0;
+        counts.set(failure.reason, previousCount + 1);
+    };
+    return {
+        getSnapshot: () => new Map(counts),
+        onFailure,
+    };
+};
+//# sourceMappingURL=safe-type-operation.js.map

package/dist/_internal/safe-type-operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"safe-type-operation.js","sourceRoot":"","sources":["../../src/_internal/safe-type-operation.ts"],"names":[],"mappings":"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"}

package/dist/_internal/scope-variable.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @packageDocumentation
+ * Scope-chain helpers for reliable variable-resolution checks.
+ */
+import type { TSESLint } from "@typescript-eslint/utils";
+/**
+ * Resolve a variable binding by walking the current scope and all parent
+ * scopes.
+ *
+ * @param scope - Initial scope to inspect.
+ * @param variableName - Identifier name to resolve.
+ *
+ * @returns Matched variable binding from the nearest scope chain; otherwise
+ *   `null`.
+ */
+export declare const getVariableInScopeChain: (scope: Readonly<null | Readonly<TSESLint.Scope.Scope>>, variableName: string) => null | TSESLint.Scope.Variable;
+//# sourceMappingURL=scope-variable.d.ts.map

package/dist/_internal/scope-variable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-variable.d.ts","sourceRoot":"","sources":["../../src/_internal/scope-variable.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAIzD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAChC,OAAO,QAAQ,CAAC,IAAI,GAAG,QAAQ,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EACtD,cAAc,MAAM,KACrB,IAAI,GAAG,QAAQ,CAAC,KAAK,CAAC,QAwBxB,CAAC"}

package/dist/_internal/scope-variable.js

@@ -0,0 +1,30 @@
+import { resolveFirstValueInLinkedStructure } from "./cycle-safe-linked-search.js";
+/**
+ * Resolve a variable binding by walking the current scope and all parent
+ * scopes.
+ *
+ * @param scope - Initial scope to inspect.
+ * @param variableName - Identifier name to resolve.
+ *
+ * @returns Matched variable binding from the nearest scope chain; otherwise
+ *   `null`.
+ */
+export const getVariableInScopeChain = (scope, variableName) => {
+    const lookupResult = resolveFirstValueInLinkedStructure({
+        getNextNode: (currentScope) => currentScope.upper,
+        resolveValue: (currentScope) => {
+            const variable = currentScope.set.get(variableName);
+            return variable === undefined
+                ? {
+                    found: false,
+                }
+                : {
+                    found: true,
+                    value: variable,
+                };
+        },
+        startNode: scope,
+    });
+    return lookupResult.found ? lookupResult.value : null;
+};
+//# sourceMappingURL=scope-variable.js.map

package/dist/_internal/scope-variable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scope-variable.js","sourceRoot":"","sources":["../../src/_internal/scope-variable.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,kCAAkC,EAAE,MAAM,+BAA+B,CAAC;AAEnF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CACnC,KAAsD,EACtD,YAAoB,EACU,EAAE;IAChC,MAAM,YAAY,GAAG,kCAAkC,CAGrD;QACE,WAAW,EAAE,CACT,YAA4C,EACP,EAAE,CAAC,YAAY,CAAC,KAAK;QAC9D,YAAY,EAAE,CAAC,YAA4C,EAAE,EAAE;YAC3D,MAAM,QAAQ,GAAG,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAEpD,OAAO,QAAQ,KAAK,SAAS;gBACzB,CAAC,CAAC;oBACI,KAAK,EAAE,KAAK;iBACf;gBACH,CAAC,CAAC;oBACI,KAAK,EAAE,IAAI;oBACX,KAAK,EAAE,QAAQ;iBAClB,CAAC;QACZ,CAAC;QACD,SAAS,EAAE,KAAK;KACnB,CAAC,CAAC;IAEH,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;AAC1D,CAAC,CAAC"}

package/dist/_internal/type-checker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ * Shared TypeScript checker helpers for low-noise type-aware rules.
+ */
+import type ts from "typescript";
+/**
+ * Check whether a type or any type in its base hierarchy has a given symbol
+ * name.
+ */
+export declare const hasTypeNameInHierarchy: (checker: ts.TypeChecker, type: ts.Type, expectedTypeName: string, seenTypes?: ReadonlySet<ts.Type>) => boolean;
+//# sourceMappingURL=type-checker.d.ts.map

package/dist/_internal/type-checker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker.d.ts","sourceRoot":"","sources":["../../src/_internal/type-checker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAC/B,SAAS,EAAE,CAAC,WAAW,EACvB,MAAM,EAAE,CAAC,IAAI,EACb,kBAAkB,MAAM,EACxB,YAAW,WAAW,CAAC,EAAE,CAAC,IAAI,CAAa,KAC5C,OAwCF,CAAC"}

package/dist/_internal/type-checker.js

@@ -0,0 +1,25 @@
+/**
+ * Check whether a type or any type in its base hierarchy has a given symbol
+ * name.
+ */
+export const hasTypeNameInHierarchy = (checker, type, expectedTypeName, seenTypes = new Set()) => {
+    if (seenTypes.has(type)) {
+        return false;
+    }
+    const nextSeenTypes = new Set(seenTypes);
+    nextSeenTypes.add(type);
+    if (type.isUnionOrIntersection()) {
+        return type.types.some((entry) => hasTypeNameInHierarchy(checker, entry, expectedTypeName, nextSeenTypes));
+    }
+    const apparentType = checker.getApparentType(type);
+    const typeName = apparentType.symbol.getName();
+    if (typeName === expectedTypeName) {
+        return true;
+    }
+    if (!apparentType.isClassOrInterface()) {
+        return false;
+    }
+    const baseTypes = checker.getBaseTypes(apparentType);
+    return baseTypes.some((baseType) => hasTypeNameInHierarchy(checker, baseType, expectedTypeName, nextSeenTypes));
+};
+//# sourceMappingURL=type-checker.js.map

package/dist/_internal/type-checker.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-checker.js","sourceRoot":"","sources":["../../src/_internal/type-checker.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAClC,OAAuB,EACvB,IAAa,EACb,gBAAwB,EACxB,YAAkC,IAAI,GAAG,EAAE,EACpC,EAAE;IACT,IAAI,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACtB,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,aAAa,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC;IACzC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IAExB,IAAI,IAAI,CAAC,qBAAqB,EAAE,EAAE,CAAC;QAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAC7B,sBAAsB,CAClB,OAAO,EACP,KAAK,EACL,gBAAgB,EAChB,aAAa,CAChB,CACJ,CAAC;IACN,CAAC;IAED,MAAM,YAAY,GAAG,OAAO,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IACnD,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,OAAO,EAAE,CAAC;IAE/C,IAAI,QAAQ,KAAK,gBAAgB,EAAE,CAAC;QAChC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,IAAI,CAAC,YAAY,CAAC,kBAAkB,EAAE,EAAE,CAAC;QACrC,OAAO,KAAK,CAAC;IACjB,CAAC;IAED,MAAM,SAAS,GAAG,OAAO,CAAC,YAAY,CAAC,YAAY,CAAC,CAAC;IAErD,OAAO,SAAS,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC/B,sBAAsB,CAClB,OAAO,EACP,QAAQ,EACR,gBAAgB,EAChB,aAAa,CAChB,CACJ,CAAC;AACN,CAAC,CAAC"}

package/dist/_internal/type-predicate-autofix-safety.d.ts

@@ -0,0 +1,16 @@
+import type { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Determine whether a call-expression replacement to a type-predicate helper is
+ * safe to apply as an autofix.
+ *
+ * @remarks
+ * Type-predicate helpers (for example `setHas`) can change control-flow
+ * narrowing in boolean guard expressions. This check intentionally disables
+ * autofix in those contexts and leaves a diagnostic for manual review.
+ */
+export declare const isTypePredicateExpressionAutofixSafe: (node: Readonly<TSESTree.Expression>) => boolean;
+/**
+ * Backward-compatible alias for call-expression-based callers.
+ */
+export declare const isTypePredicateAutofixSafe: (node: Readonly<TSESTree.CallExpression>) => boolean;
+//# sourceMappingURL=type-predicate-autofix-safety.d.ts.map

package/dist/_internal/type-predicate-autofix-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-predicate-autofix-safety.d.ts","sourceRoot":"","sources":["../../src/_internal/type-predicate-autofix-safety.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AA4DzD;;;;;;;;GAQG;AACH,eAAO,MAAM,oCAAoC,GAC7C,MAAM,QAAQ,CAAC,QAAQ,CAAC,UAAU,CAAC,KACpC,OAiBF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,0BAA0B,GACnC,MAAM,QAAQ,CAAC,QAAQ,CAAC,cAAc,CAAC,KACxC,OAAqD,CAAC"}

package/dist/_internal/type-predicate-autofix-safety.js

@@ -0,0 +1,54 @@
+/**
+ * @packageDocumentation
+ * Conservative safety checks for autofixes that introduce type predicates.
+ */
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { getParentNode } from "./ast-node.js";
+import { isTransparentExpressionWrapper } from "./value-rewrite-autofix-safety.js";
+const isLogicalExpressionOperand = (parentNode, currentNode) => parentNode.type === AST_NODE_TYPES.LogicalExpression &&
+    (parentNode.left === currentNode || parentNode.right === currentNode);
+const isConditionalTest = (parentNode, currentNode) => parentNode.type === AST_NODE_TYPES.ConditionalExpression &&
+    parentNode.test === currentNode;
+const isLoopOrIfTest = (parentNode, currentNode) => (parentNode.type === AST_NODE_TYPES.DoWhileStatement ||
+    parentNode.type === AST_NODE_TYPES.ForStatement ||
+    parentNode.type === AST_NODE_TYPES.IfStatement ||
+    parentNode.type === AST_NODE_TYPES.WhileStatement) &&
+    parentNode.test === currentNode;
+const isSwitchCaseTest = (parentNode, currentNode) => parentNode.type === AST_NODE_TYPES.SwitchCase &&
+    parentNode.test === currentNode;
+const isUnaryNotArgument = (parentNode, currentNode) => parentNode.type === AST_NODE_TYPES.UnaryExpression &&
+    parentNode.operator === "!" &&
+    parentNode.argument === currentNode;
+const isBooleanGuardContext = (parentNode, currentNode) => isUnaryNotArgument(parentNode, currentNode) ||
+    isLogicalExpressionOperand(parentNode, currentNode) ||
+    isConditionalTest(parentNode, currentNode) ||
+    isLoopOrIfTest(parentNode, currentNode) ||
+    isSwitchCaseTest(parentNode, currentNode);
+/**
+ * Determine whether a call-expression replacement to a type-predicate helper is
+ * safe to apply as an autofix.
+ *
+ * @remarks
+ * Type-predicate helpers (for example `setHas`) can change control-flow
+ * narrowing in boolean guard expressions. This check intentionally disables
+ * autofix in those contexts and leaves a diagnostic for manual review.
+ */
+export const isTypePredicateExpressionAutofixSafe = (node) => {
+    let currentNode = node;
+    while (true) {
+        const parentNode = getParentNode(currentNode);
+        if (parentNode === undefined) {
+            return true;
+        }
+        if (isTransparentExpressionWrapper(parentNode, currentNode)) {
+            currentNode = parentNode;
+            continue;
+        }
+        return !isBooleanGuardContext(parentNode, currentNode);
+    }
+};
+/**
+ * Backward-compatible alias for call-expression-based callers.
+ */
+export const isTypePredicateAutofixSafe = (node) => isTypePredicateExpressionAutofixSafe(node);
+//# sourceMappingURL=type-predicate-autofix-safety.js.map

package/dist/_internal/type-predicate-autofix-safety.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-predicate-autofix-safety.js","sourceRoot":"","sources":["../../src/_internal/type-predicate-autofix-safety.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,8BAA8B,EAAE,MAAM,mCAAmC,CAAC;AAEnF,MAAM,0BAA0B,GAAG,CAC/B,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,iBAAiB;IACpD,CAAC,UAAU,CAAC,IAAI,KAAK,WAAW,IAAI,UAAU,CAAC,KAAK,KAAK,WAAW,CAAC,CAAC;AAE1E,MAAM,iBAAiB,GAAG,CACtB,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,qBAAqB;IACxD,UAAU,CAAC,IAAI,KAAK,WAAW,CAAC;AAEpC,MAAM,cAAc,GAAG,CACnB,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,CAAC,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,gBAAgB;IAChD,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,YAAY;IAC/C,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,WAAW;IAC9C,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,cAAc,CAAC;IACtD,UAAU,CAAC,IAAI,KAAK,WAAW,CAAC;AAEpC,MAAM,gBAAgB,GAAG,CACrB,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;IAC7C,UAAU,CAAC,IAAI,KAAK,WAAW,CAAC;AAEpC,MAAM,kBAAkB,GAAG,CACvB,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,UAAU,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe;IAClD,UAAU,CAAC,QAAQ,KAAK,GAAG;IAC3B,UAAU,CAAC,QAAQ,KAAK,WAAW,CAAC;AAExC,MAAM,qBAAqB,GAAG,CAC1B,UAAmC,EACnC,WAAoC,EAC7B,EAAE,CACT,kBAAkB,CAAC,UAAU,EAAE,WAAW,CAAC;IAC3C,0BAA0B,CAAC,UAAU,EAAE,WAAW,CAAC;IACnD,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC;IAC1C,cAAc,CAAC,UAAU,EAAE,WAAW,CAAC;IACvC,gBAAgB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;AAE9C;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,oCAAoC,GAAG,CAChD,IAAmC,EAC5B,EAAE;IACT,IAAI,WAAW,GAA4B,IAAI,CAAC;IAEhD,OAAO,IAAI,EAAE,CAAC;QACV,MAAM,UAAU,GAAG,aAAa,CAAC,WAAW,CAAC,CAAC;QAE9C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC;QAChB,CAAC;QAED,IAAI,8BAA8B,CAAC,UAAU,EAAE,WAAW,CAAC,EAAE,CAAC;YAC1D,WAAW,GAAG,UAAU,CAAC;YACzB,SAAS;QACb,CAAC;QAED,OAAO,CAAC,qBAAqB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;IAC3D,CAAC;AACL,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CACtC,IAAuC,EAChC,EAAE,CAAC,oCAAoC,CAAC,IAAI,CAAC,CAAC"}

package/dist/_internal/type-reference-node.d.ts

@@ -0,0 +1,23 @@
+import type { TSESTree } from "@typescript-eslint/utils";
+/**
+ * Checks whether a type node is an identifier-based type reference with a
+ * specific symbol name.
+ *
+ * @param node - Type node candidate.
+ * @param identifierName - Expected referenced identifier name.
+ *
+ * @returns `true` when the node is `TSTypeReference` and the referenced
+ *   `typeName` identifier matches exactly.
+ */
+export declare const isIdentifierTypeReference: (node: Readonly<TSESTree.TypeNode>, identifierName: string) => node is TSESTree.TSTypeReference & {
+    typeName: TSESTree.Identifier;
+};
+/**
+ * Unwrap transparent parenthesized type nodes.
+ *
+ * @param node - Type node to normalize.
+ *
+ * @returns The innermost non-parenthesized type node.
+ */
+export declare const unwrapParenthesizedTypeNode: (node: Readonly<TSESTree.TypeNode>) => Readonly<TSESTree.TypeNode>;
+//# sourceMappingURL=type-reference-node.d.ts.map

package/dist/_internal/type-reference-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-reference-node.d.ts","sourceRoot":"","sources":["../../src/_internal/type-reference-node.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAezD;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,GAClC,MAAM,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,EACjC,gBAAgB,MAAM,KACvB,IAAI,IAAI,QAAQ,CAAC,eAAe,GAAG;IAAE,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAA;CAG5B,CAAC;AAE1C;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACpC,MAAM,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAAC,KAClC,QAAQ,CAAC,QAAQ,CAAC,QAAQ,CAa5B,CAAC"}

package/dist/_internal/type-reference-node.js

@@ -0,0 +1,41 @@
+/**
+ * @packageDocumentation
+ * Predicate helpers for narrowing `TSTypeReference` nodes by identifier name.
+ */
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+const TS_PARENTHESIZED_TYPE = "TSParenthesizedType";
+const isTypeNodeLike = (value) => typeof value === "object" &&
+    value !== null &&
+    typeof Reflect.get(value, "type") === "string";
+/**
+ * Checks whether a type node is an identifier-based type reference with a
+ * specific symbol name.
+ *
+ * @param node - Type node candidate.
+ * @param identifierName - Expected referenced identifier name.
+ *
+ * @returns `true` when the node is `TSTypeReference` and the referenced
+ *   `typeName` identifier matches exactly.
+ */
+export const isIdentifierTypeReference = (node, identifierName) => node.type === AST_NODE_TYPES.TSTypeReference &&
+    node.typeName.type === AST_NODE_TYPES.Identifier &&
+    node.typeName.name === identifierName;
+/**
+ * Unwrap transparent parenthesized type nodes.
+ *
+ * @param node - Type node to normalize.
+ *
+ * @returns The innermost non-parenthesized type node.
+ */
+export const unwrapParenthesizedTypeNode = (node) => {
+    const nodeObject = node;
+    const nodeType = Reflect.get(nodeObject, "type");
+    if (nodeType !== TS_PARENTHESIZED_TYPE) {
+        return node;
+    }
+    const typeAnnotation = Reflect.get(nodeObject, "typeAnnotation");
+    return isTypeNodeLike(typeAnnotation)
+        ? unwrapParenthesizedTypeNode(typeAnnotation)
+        : node;
+};
+//# sourceMappingURL=type-reference-node.js.map

package/dist/_internal/type-reference-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-reference-node.js","sourceRoot":"","sources":["../../src/_internal/type-reference-node.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAE1D,MAAM,qBAAqB,GAAG,qBAAqB,CAAC;AAEpD,MAAM,cAAc,GAAG,CAAC,KAAc,EAAwC,EAAE,CAC5E,OAAO,KAAK,KAAK,QAAQ;IACzB,KAAK,KAAK,IAAI;IACd,OAAO,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,QAAQ,CAAC;AAEnD;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CACrC,IAAiC,EACjC,cAAsB,EAC8C,EAAE,CACtE,IAAI,CAAC,IAAI,KAAK,cAAc,CAAC,eAAe;IAC5C,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC,UAAU;IAChD,IAAI,CAAC,QAAQ,CAAC,IAAI,KAAK,cAAc,CAAC;AAE1C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,CACvC,IAAiC,EACN,EAAE;IAC7B,MAAM,UAAU,GAAW,IAAI,CAAC;IAChC,MAAM,QAAQ,GAAY,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;IAE1D,IAAI,QAAQ,KAAK,qBAAqB,EAAE,CAAC;QACrC,OAAO,IAAI,CAAC;IAChB,CAAC;IAED,MAAM,cAAc,GAAY,OAAO,CAAC,GAAG,CAAC,UAAU,EAAE,gBAAgB,CAAC,CAAC;IAE1E,OAAO,cAAc,CAAC,cAAc,CAAC;QACjC,CAAC,CAAC,2BAA2B,CAAC,cAAc,CAAC;QAC7C,CAAC,CAAC,IAAI,CAAC;AACf,CAAC,CAAC"}

package/dist/_internal/typed-rule.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @packageDocumentation
+ * Internal shared utilities used by eslint-plugin-runtime-cleanup rule modules
+ * and plugin wiring.
+ */
+import type ts from "typescript";
+import { ESLintUtils, type TSESLint } from "@typescript-eslint/utils";
+import type { RuntimeCleanupConfigReference } from "./runtime-cleanup-config-references.js";
+/**
+ * Parser services and type checker bundle used by typed rules.
+ */
+export interface TypedRuleServices {
+    checker: ts.TypeChecker;
+    parserServices: ReturnType<typeof ESLintUtils.getParserServices>;
+}
+type RuntimeCleanupRuleCreator = ReturnType<typeof ESLintUtils.RuleCreator<RuntimeCleanupRuleDocs>>;
+/**
+ * Plugin-specific metadata extensions for `meta.docs`.
+ *
+ * @remarks
+ * `eslint-plugin/require-meta-docs-recommended` expects
+ * `meta.docs.recommended` to be boolean. Preset membership is tracked
+ * separately via `meta.docs.runtimeCleanupConfigs`.
+ */
+interface RuntimeCleanupRuleDocs {
+    recommended?: boolean;
+    requiresTypeChecking?: boolean;
+    ruleId?: string;
+    ruleNumber?: number;
+    runtimeCleanupConfigs?: readonly RuntimeCleanupConfigReference[] | RuntimeCleanupConfigReference;
+}
+/** Shared typed-rule context contract used by helper utilities. */
+type TypedRuleContext = Readonly<TSESLint.RuleContext<string, readonly unknown[]>>;
+export type { TypedRuleContext };
+/**
+ * Rule-creator wrapper used by plugin rules.
+ *
+ * @remarks
+ * This wrapper automatically registers per-program plugin settings and injects
+ * canonical `meta.docs.ruleId` / `meta.docs.ruleNumber` values for cataloged
+ * public rules.
+ *
+ * @param ruleDefinition - Rule module definition passed to
+ *   `ESLintUtils.RuleCreator`.
+ *
+ * @returns Rule module factory output that auto-registers program settings and
+ *   preserves the authored rule contract.
+ */
+export declare const createTypedRule: RuntimeCleanupRuleCreator;
+/**
+ * Retrieve parser services and type checker for typed rules.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns Parser services and type checker references bound to the current
+ *   program.
+ *
+ * @throws Throws when `parserServices.program` is unavailable, which indicates
+ *   the current lint run is not configured for type-aware analysis.
+ */
+export declare const getTypedRuleServices: (context: TypedRuleContext) => TypedRuleServices;
+/**
+ * Determine whether the current lint context has full type information.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns `true` when parser services and `program` are available.
+ */
+export declare const hasTypeServices: (context: TypedRuleContext) => boolean;
+/**
+ * Retrieve typed services when available, otherwise return `undefined`.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns Typed services when parser services include a TypeScript program.
+ */
+export declare const getTypedRuleServicesOrUndefined: (context: TypedRuleContext) => TypedRuleServices | undefined;
+/**
+ * Resolve the type of a signature parameter by index.
+ *
+ * @param options - Signature parameter lookup options.
+ *
+ * @returns Parameter type when available; otherwise `undefined`.
+ */
+export declare const getSignatureParameterTypeAt: (options: Readonly<{
+    checker: ts.TypeChecker;
+    index: number;
+    location: ts.Node;
+    signature: null | ts.Signature | undefined;
+}>) => ts.Type | undefined;
+//# sourceMappingURL=typed-rule.d.ts.map

package/dist/_internal/typed-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-rule.d.ts","sourceRoot":"","sources":["../../src/_internal/typed-rule.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAC;AAEjC,OAAO,EAAE,WAAW,EAAE,KAAK,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEtE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AAO5F;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAC9B,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,cAAc,EAAE,UAAU,CAAC,OAAO,WAAW,CAAC,iBAAiB,CAAC,CAAC;CACpE;AAED,KAAK,yBAAyB,GAAG,UAAU,CACvC,OAAO,WAAW,CAAC,WAAW,CAAC,sBAAsB,CAAC,CACzD,CAAC;AAEF;;;;;;;GAOG;AACH,UAAU,sBAAsB;IAC5B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,qBAAqB,CAAC,EAChB,SAAS,6BAA6B,EAAE,GACxC,6BAA6B,CAAC;CACvC;AAED,mEAAmE;AACnE,KAAK,gBAAgB,GAAG,QAAQ,CAC5B,QAAQ,CAAC,WAAW,CAAC,MAAM,EAAE,SAAS,OAAO,EAAE,CAAC,CACnD,CAAC;AAEF,YAAY,EAAE,gBAAgB,EAAE,CAAC;AAEjC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe,EAAE,yBAyD7B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,GAC7B,SAAS,gBAAgB,KAC1B,iBAcF,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,gBAAgB,KAAG,OAS3D,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B,GACxC,SAAS,gBAAgB,KAC1B,iBAAiB,GAAG,SACiD,CAAC;AAEzE;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,GACpC,SAAS,QAAQ,CAAC;IACd,OAAO,EAAE,EAAE,CAAC,WAAW,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,EAAE,CAAC,IAAI,CAAC;IAClB,SAAS,EAAE,IAAI,GAAG,EAAE,CAAC,SAAS,GAAG,SAAS,CAAC;CAC9C,CAAC,KACH,EAAE,CAAC,IAAI,GAAG,SASZ,CAAC"}

package/dist/_internal/typed-rule.js

@@ -0,0 +1,121 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+import { registerProgramSettingsForContext } from "./plugin-settings.js";
+import { getRuleCatalogEntryForRuleNameOrNull } from "./rule-catalog.js";
+import { createRuleDocsUrl } from "./rule-docs-url.js";
+import { safeTypeOperation } from "./safe-type-operation.js";
+/**
+ * Rule-creator wrapper used by plugin rules.
+ *
+ * @remarks
+ * This wrapper automatically registers per-program plugin settings and injects
+ * canonical `meta.docs.ruleId` / `meta.docs.ruleNumber` values for cataloged
+ * public rules.
+ *
+ * @param ruleDefinition - Rule module definition passed to
+ *   `ESLintUtils.RuleCreator`.
+ *
+ * @returns Rule module factory output that auto-registers program settings and
+ *   preserves the authored rule contract.
+ */
+export const createTypedRule = (ruleDefinition) => {
+    const catalogEntry = getRuleCatalogEntryForRuleNameOrNull(ruleDefinition.name);
+    const createdRule = ESLintUtils.RuleCreator.withoutDocs(ruleDefinition);
+    const ruleDocs = createdRule.meta.docs;
+    if (ruleDocs === undefined) {
+        throw new TypeError(`Rule '${ruleDefinition.name}' must declare meta.docs.`);
+    }
+    const canonicalDocsUrl = createRuleDocsUrl(ruleDefinition.name);
+    if (typeof ruleDocs.url === "string" && ruleDocs.url !== canonicalDocsUrl) {
+        throw new TypeError(`Rule '${ruleDefinition.name}' has non-canonical docs.url '${ruleDocs.url}'. Expected '${canonicalDocsUrl}'.`);
+    }
+    if (catalogEntry === null && ruleDefinition.name.startsWith("require-")) {
+        throw new TypeError(`Rule '${ruleDefinition.name}' is missing from the stable rule catalog.`);
+    }
+    const docsWithCatalog = catalogEntry === null
+        ? {
+            ...ruleDocs,
+            url: canonicalDocsUrl,
+        }
+        : {
+            ...ruleDocs,
+            ruleId: catalogEntry.ruleId,
+            ruleNumber: catalogEntry.ruleNumber,
+            url: canonicalDocsUrl,
+        };
+    const metaDefaultOptions = createdRule.meta.defaultOptions;
+    return {
+        ...createdRule,
+        create(context) {
+            registerProgramSettingsForContext(context);
+            return createdRule.create(context);
+        },
+        meta: {
+            ...createdRule.meta,
+            ...(metaDefaultOptions === undefined
+                ? {}
+                : { defaultOptions: metaDefaultOptions }),
+            docs: docsWithCatalog,
+        },
+        name: ruleDefinition.name,
+    };
+};
+/**
+ * Retrieve parser services and type checker for typed rules.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns Parser services and type checker references bound to the current
+ *   program.
+ *
+ * @throws Throws when `parserServices.program` is unavailable, which indicates
+ *   the current lint run is not configured for type-aware analysis.
+ */
+export const getTypedRuleServices = (context) => {
+    const parserServices = ESLintUtils.getParserServices(context, true);
+    const program = parserServices.program;
+    if (program === null) {
+        throw new Error("Typed rule requires parserServices.program; ensure projectService is enabled for this lint run.");
+    }
+    return {
+        checker: program.getTypeChecker(),
+        parserServices,
+    };
+};
+/**
+ * Determine whether the current lint context has full type information.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns `true` when parser services and `program` are available.
+ */
+export const hasTypeServices = (context) => {
+    const parserServicesResult = safeTypeOperation({
+        operation: () => ESLintUtils.getParserServices(context, true),
+        reason: "typed-rule-services-check-failed",
+    });
+    return (parserServicesResult.ok && parserServicesResult.value.program !== null);
+};
+/**
+ * Retrieve typed services when available, otherwise return `undefined`.
+ *
+ * @param context - Rule context from the current lint evaluation.
+ *
+ * @returns Typed services when parser services include a TypeScript program.
+ */
+export const getTypedRuleServicesOrUndefined = (context) => hasTypeServices(context) ? getTypedRuleServices(context) : undefined;
+/**
+ * Resolve the type of a signature parameter by index.
+ *
+ * @param options - Signature parameter lookup options.
+ *
+ * @returns Parameter type when available; otherwise `undefined`.
+ */
+export const getSignatureParameterTypeAt = (options) => {
+    const { checker, index, location, signature } = options;
+    const symbol = signature?.parameters[index];
+    if (symbol === undefined) {
+        return undefined;
+    }
+    return checker.getTypeOfSymbolAtLocation(symbol, location);
+};
+//# sourceMappingURL=typed-rule.js.map

package/dist/_internal/typed-rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typed-rule.js","sourceRoot":"","sources":["../../src/_internal/typed-rule.ts"],"names":[],"mappings":"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"}