@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/cjs/linters/eslint-rules/no-unused-params-members.cjs

@@ -0,0 +1,265 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var no_unused_params_members_exports = {};
+__export(no_unused_params_members_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  noUnusedParamsMembers: () => noUnusedParamsMembers
+});
+module.exports = __toCommonJS(no_unused_params_members_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+const PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;
+const MESSAGE_ID = "unusedParamsMember";
+const noUnusedParamsMembers = {
+  create(context) {
+    const interfaceKeyNodes = /* @__PURE__ */ new Map();
+    const usageByInterface = /* @__PURE__ */ new Map();
+    return {
+      ":function"(node) {
+        for (const parameter of record(node)["params"]) {
+          const info = getParameterInfo(parameter);
+          if (!info) {
+            continue;
+          }
+          const usage = getOrCreateUsage(info.typeName);
+          if (info.binding.type === "pattern") {
+            collectPatternMembers(info.binding.pattern, usage);
+          } else {
+            collectReferenceMembers({
+              parameterName: info.binding.name,
+              scope: context.sourceCode.getScope(node),
+              usage
+            });
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [typeName, keyNodes] of interfaceKeyNodes) {
+          const usage = usageByInterface.get(typeName);
+          if (!usage || usage.usesAll) {
+            continue;
+          }
+          for (const [memberName, keyNode] of keyNodes) {
+            if (!usage.used.has(memberName)) {
+              context.report({
+                data: {
+                  interfaceName: typeName,
+                  member: memberName
+                },
+                messageId: MESSAGE_ID,
+                node: keyNode
+              });
+            }
+          }
+        }
+      },
+      TSInterfaceDeclaration(node) {
+        const name = getInterfaceName(node);
+        if (!PARAMS_OPTIONS_SUFFIX_PATTERN.test(name)) {
+          return;
+        }
+        interfaceKeyNodes.set(name, getInterfaceMembers(node));
+      }
+    };
+    function getOrCreateUsage(typeName) {
+      let usage = usageByInterface.get(typeName);
+      if (!usage) {
+        usage = { used: /* @__PURE__ */ new Set(), usesAll: false };
+        usageByInterface.set(typeName, usage);
+      }
+      return usage;
+    }
+  },
+  meta: {
+    docs: {
+      description: "Flag `*Params`/`*Options` interface members never accessed by the function that receives them"
+    },
+    messages: {
+      [MESSAGE_ID]: 'Member "{{ member }}" of "{{ interfaceName }}" is never accessed by the function that receives it. Remove it (the compiler will catch it if it is still needed elsewhere).'
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function classifyReference(reference, usage) {
+  const parent = record(reference)["parent"];
+  if (parent.type === "MemberExpression" && record(parent)["object"] === reference) {
+    collectMemberAccess(parent, usage);
+    return;
+  }
+  if (parent.type === "VariableDeclarator" && record(parent)["init"] === reference && record(parent)["id"].type === "ObjectPattern") {
+    collectPatternMembers(record(parent)["id"], usage);
+    return;
+  }
+  usage.usesAll = true;
+}
+function collectMemberAccess(node, usage) {
+  const isComputed = record(node)["computed"] === true;
+  const property = record(node)["property"];
+  if (property.type === "Identifier") {
+    if (!isComputed) {
+      usage.used.add(record(property)["name"]);
+    }
+    return;
+  }
+  if (property.type !== "Literal") {
+    return;
+  }
+  const value = record(property)["value"];
+  if (typeof value === "string") {
+    usage.used.add(value);
+  }
+}
+function collectPatternMembers(pattern, usage) {
+  for (const property of record(pattern)["properties"]) {
+    if (property.type !== "Property") {
+      usage.usesAll = true;
+      continue;
+    }
+    if (record(property)["computed"] === true) {
+      continue;
+    }
+    const key = record(property)["key"];
+    if (key.type === "Identifier") {
+      usage.used.add(record(key)["name"]);
+    }
+  }
+}
+function collectReferenceMembers(params) {
+  const { parameterName, scope, usage } = params;
+  const variable = (0, import_type_guards.ensureNonNullable)(scope.set.get(parameterName));
+  for (const reference of variable.references) {
+    classifyReference(reference.identifier, usage);
+  }
+}
+function getInterfaceMembers(node) {
+  const members = /* @__PURE__ */ new Map();
+  const interfaceBody = record(node)["body"];
+  for (const signature of record(interfaceBody)["body"]) {
+    if (nodeType(signature) !== "TSPropertySignature" && nodeType(signature) !== "TSMethodSignature" || record(signature)["computed"] === true) {
+      continue;
+    }
+    const key = record(signature)["key"];
+    if (key.type === "Identifier") {
+      members.set(record(key)["name"], key);
+    }
+  }
+  return members;
+}
+function getInterfaceName(node) {
+  const id = record(node)["id"];
+  return record(id)["name"];
+}
+function getParameterInfo(parameter) {
+  const actualParameter = nodeType(parameter) === "TSParameterProperty" ? record(parameter)["parameter"] : parameter;
+  const typeName = getTypeReferenceName(actualParameter);
+  if (!typeName || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeName)) {
+    return void 0;
+  }
+  if (actualParameter.type === "Identifier") {
+    return { binding: { name: record(actualParameter)["name"], type: "identifier" }, typeName };
+  }
+  return actualParameter.type === "ObjectPattern" ? { binding: { pattern: actualParameter, type: "pattern" }, typeName } : void 0;
+}
+function getTypeReferenceName(parameter) {
+  const annotation = record(parameter)["typeAnnotation"];
+  if (!isNode(annotation)) {
+    return void 0;
+  }
+  const typeNode = record(annotation)["typeAnnotation"];
+  if (nodeType(typeNode) !== "TSTypeReference") {
+    return void 0;
+  }
+  const typeName = record(typeNode)["typeName"];
+  return typeName.type === "Identifier" ? record(typeName)["name"] : void 0;
+}
+function isNode(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function nodeType(node) {
+  return record(node)["type"];
+}
+function record(node) {
+  return node;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  noUnusedParamsMembers
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-unused-params-members.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-unused-params-members\n *\n * Flags members of a `*Params` / `*Options` parameter-bag interface that are\n * never accessed within the function/method/constructor that receives the\n * interface as a parameter.\n *\n * Detection is per-function, using scope analysis to find the real references\n * to the parameter (not unrelated same-named identifiers). A member counts as\n * used when it is referenced by name \u2014 `params.member`, `params['member']`, or\n * `const { member } = params` (plus a destructured signature\n * `fn({ member }: FooParams)`).\n *\n * Crucially, if the object ever ESCAPES whole \u2014 spread (`{ ...params }`), rest\n * (`const { ...rest } = params`), passed as an argument (`f(params)`), returned,\n * or stored (`this.params = params`) \u2014 every member is treated as used and\n * nothing is reported for that interface. Such an escape either reads every\n * member (spread/rest) or hands the object to code this rule cannot see, so\n * member deadness cannot be decided locally.\n *\n * A member is therefore flagged only when it is never referenced by name AND\n * the object never escapes \u2014 i.e. the \"a `params.x` usage was deleted but `x`\n * was left on the interface\" case. A member that is actually still needed (read\n * via an escape) is never wrongly flagged; a member that is escaped but dead\n * downstream is a tolerated false negative (its deadness is not local).\n *\n * Only interfaces declared in the same file are checked; an imported parameter\n * type is skipped. Only identifier-named members are tracked.\n */\n\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nconst PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;\n\n/**\nMessage ID reported when a `*Params`/`*Options` interface member is never accessed by the function that receives it.\n */\nexport const MESSAGE_ID = 'unusedParamsMember';\n\ninterface IdentifierBinding {\n  name: string;\n  type: 'identifier';\n}\n\ninterface InterfaceUsage {\n  readonly used: Set<string>;\n  usesAll: boolean;\n}\n\ninterface MaybeTypedNode {\n  type?: unknown;\n}\n\ntype ParameterBinding = IdentifierBinding | PatternBinding;\n\ninterface ParameterInfo {\n  readonly binding: ParameterBinding;\n  readonly typeName: string;\n}\n\ninterface PatternBinding {\n  pattern: Rule.Node;\n  type: 'pattern';\n}\n\n/**\n * ESLint rule flagging `*Params`/`*Options` interface members that the function receiving them never accesses.\n */\nexport const noUnusedParamsMembers: Rule.RuleModule = {\n  create(context) {\n    const interfaceKeyNodes = new Map<string, Map<string, Rule.Node>>();\n    const usageByInterface = new Map<string, InterfaceUsage>();\n\n    return {\n      ':function'(node: Rule.Node): void {\n        for (const parameter of record(node)['params'] as Rule.Node[]) {\n          const info = getParameterInfo(parameter);\n          if (!info) {\n            continue;\n          }\n\n          const usage = getOrCreateUsage(info.typeName);\n          if (info.binding.type === 'pattern') {\n            collectPatternMembers(info.binding.pattern, usage);\n          } else {\n            collectReferenceMembers({\n              parameterName: info.binding.name,\n              scope: context.sourceCode.getScope(node),\n              usage\n            });\n          }\n        }\n      },\n      'Program:exit'(): void {\n        for (const [typeName, keyNodes] of interfaceKeyNodes) {\n          const usage = usageByInterface.get(typeName);\n          if (!usage || usage.usesAll) {\n            continue;\n          }\n\n          for (const [memberName, keyNode] of keyNodes) {\n            if (!usage.used.has(memberName)) {\n              context.report({\n                data: {\n                  interfaceName: typeName,\n                  member: memberName\n                },\n                messageId: MESSAGE_ID,\n                node: keyNode\n              });\n            }\n          }\n        }\n      },\n      TSInterfaceDeclaration(node: Rule.Node): void {\n        const name = getInterfaceName(node);\n        if (!PARAMS_OPTIONS_SUFFIX_PATTERN.test(name)) {\n          return;\n        }\n        interfaceKeyNodes.set(name, getInterfaceMembers(node));\n      }\n    };\n\n    function getOrCreateUsage(typeName: string): InterfaceUsage {\n      let usage = usageByInterface.get(typeName);\n      if (!usage) {\n        usage = { used: new Set<string>(), usesAll: false };\n        usageByInterface.set(typeName, usage);\n      }\n      return usage;\n    }\n  },\n  meta: {\n    docs: {\n      description: 'Flag `*Params`/`*Options` interface members never accessed by the function that receives them'\n    },\n    messages: {\n      [MESSAGE_ID]: 'Member \"{{ member }}\" of \"{{ interfaceName }}\" is never accessed by the function that receives it. Remove it (the compiler will catch it if it is still needed elsewhere).'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\n/**\n * Parameters for {@link collectReferenceMembers}.\n */\ninterface CollectReferenceMembersParams {\n  /**\n   * The name of the parameter whose references are inspected.\n   */\n  readonly parameterName: string;\n\n  /**\n   * The scope in which the parameter is bound.\n   */\n  readonly scope: Scope.Scope;\n\n  /**\n   * The usage accumulator to record accessed members into.\n   */\n  readonly usage: InterfaceUsage;\n}\n\nfunction classifyReference(reference: object, usage: InterfaceUsage): void {\n  const parent = record(reference)['parent'] as Rule.Node;\n  if (parent.type === 'MemberExpression' && record(parent)['object'] === reference) {\n    collectMemberAccess(parent, usage);\n    return;\n  }\n\n  if (parent.type === 'VariableDeclarator' && record(parent)['init'] === reference && (record(parent)['id'] as Rule.Node).type === 'ObjectPattern') {\n    collectPatternMembers(record(parent)['id'] as Rule.Node, usage);\n    return;\n  }\n\n  // The object escapes whole (passed as an argument, returned, stored, spread, ...): every member may be read elsewhere.\n  usage.usesAll = true;\n}\n\nfunction collectMemberAccess(node: Rule.Node, usage: InterfaceUsage): void {\n  const isComputed = record(node)['computed'] === true;\n  const property = record(node)['property'] as Rule.Node;\n  if (property.type === 'Identifier') {\n    if (!isComputed) {\n      usage.used.add(record(property)['name'] as string);\n    }\n    return;\n  }\n\n  if (property.type !== 'Literal') {\n    return;\n  }\n\n  const value = record(property)['value'];\n  if (typeof value === 'string') {\n    usage.used.add(value);\n  }\n}\n\nfunction collectPatternMembers(pattern: Rule.Node, usage: InterfaceUsage): void {\n  for (const property of record(pattern)['properties'] as Rule.Node[]) {\n    if (property.type !== 'Property') {\n      // `const { ...rest } = params` reads every remaining member.\n      usage.usesAll = true;\n      continue;\n    }\n    if (record(property)['computed'] === true) {\n      continue;\n    }\n    const key = record(property)['key'] as Rule.Node;\n    if (key.type === 'Identifier') {\n      usage.used.add(record(key)['name'] as string);\n    }\n  }\n}\n\nfunction collectReferenceMembers(params: CollectReferenceMembersParams): void {\n  const { parameterName, scope, usage } = params;\n  const variable = ensureNonNullable(scope.set.get(parameterName));\n  for (const reference of variable.references) {\n    classifyReference(reference.identifier, usage);\n  }\n}\n\nfunction getInterfaceMembers(node: Rule.Node): Map<string, Rule.Node> {\n  const members = new Map<string, Rule.Node>();\n  const interfaceBody = record(node)['body'] as Rule.Node;\n  for (const signature of record(interfaceBody)['body'] as Rule.Node[]) {\n    if ((nodeType(signature) !== 'TSPropertySignature' && nodeType(signature) !== 'TSMethodSignature') || (record(signature)['computed'] === true)) {\n      continue;\n    }\n    const key = record(signature)['key'] as Rule.Node;\n    if (key.type === 'Identifier') {\n      members.set(record(key)['name'] as string, key);\n    }\n  }\n  return members;\n}\n\nfunction getInterfaceName(node: Rule.Node): string {\n  const id = record(node)['id'] as Rule.Node;\n  return record(id)['name'] as string;\n}\n\nfunction getParameterInfo(parameter: Rule.Node): ParameterInfo | undefined {\n  const actualParameter = nodeType(parameter) === 'TSParameterProperty' ? record(parameter)['parameter'] as Rule.Node : parameter;\n\n  const typeName = getTypeReferenceName(actualParameter);\n  if (!typeName || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeName)) {\n    return undefined;\n  }\n\n  if (actualParameter.type === 'Identifier') {\n    return { binding: { name: record(actualParameter)['name'] as string, type: 'identifier' }, typeName };\n  }\n\n  return actualParameter.type === 'ObjectPattern' ? { binding: { pattern: actualParameter, type: 'pattern' }, typeName } : undefined;\n}\n\nfunction getTypeReferenceName(parameter: Rule.Node): string | undefined {\n  const annotation = record(parameter)['typeAnnotation'];\n  if (!isNode(annotation)) {\n    return undefined;\n  }\n\n  const typeNode = record(annotation)['typeAnnotation'] as Rule.Node;\n  if (nodeType(typeNode) !== 'TSTypeReference') {\n    return undefined;\n  }\n\n  const typeName = record(typeNode)['typeName'] as Rule.Node;\n  return typeName.type === 'Identifier' ? (record(typeName)['name'] as string) : undefined;\n}\n\nfunction isNode(value: unknown): value is Rule.Node {\n  return typeof value === 'object' && value !== null && typeof (value as MaybeTypedNode).type === 'string';\n}\n\nfunction nodeType(node: Rule.Node): string {\n  return record(node)['type'] as string;\n}\n\nfunction record(node: object): Record<string, unknown> {\n  return node as Record<string, unknown>;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/linters/eslint-rules/no-unused-params-members.d.cts

@@ -0,0 +1,41 @@
+/// <reference path="../../index.d.cts" />
+/**
+ * @file
+ *
+ * ESLint rule: no-unused-params-members
+ *
+ * Flags members of a `*Params` / `*Options` parameter-bag interface that are
+ * never accessed within the function/method/constructor that receives the
+ * interface as a parameter.
+ *
+ * Detection is per-function, using scope analysis to find the real references
+ * to the parameter (not unrelated same-named identifiers). A member counts as
+ * used when it is referenced by name — `params.member`, `params['member']`, or
+ * `const { member } = params` (plus a destructured signature
+ * `fn({ member }: FooParams)`).
+ *
+ * Crucially, if the object ever ESCAPES whole — spread (`{ ...params }`), rest
+ * (`const { ...rest } = params`), passed as an argument (`f(params)`), returned,
+ * or stored (`this.params = params`) — every member is treated as used and
+ * nothing is reported for that interface. Such an escape either reads every
+ * member (spread/rest) or hands the object to code this rule cannot see, so
+ * member deadness cannot be decided locally.
+ *
+ * A member is therefore flagged only when it is never referenced by name AND
+ * the object never escapes — i.e. the "a `params.x` usage was deleted but `x`
+ * was left on the interface" case. A member that is actually still needed (read
+ * via an escape) is never wrongly flagged; a member that is escaped but dead
+ * downstream is a tolerated false negative (its deadness is not local).
+ *
+ * Only interfaces declared in the same file are checked; an imported parameter
+ * type is skipped. Only identifier-named members are tracked.
+ */
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+Message ID reported when a `*Params`/`*Options` interface member is never accessed by the function that receives it.
+ */
+export declare const MESSAGE_ID = "unusedParamsMember";
+/**
+ * ESLint rule flagging `*Params`/`*Options` interface members that the function receiving them never accesses.
+ */
+export declare const noUnusedParamsMembers: Rule.RuleModule;

package/dist/lib/cjs/linters/eslint-rules/no-used-underscore-variables.cjs

@@ -0,0 +1,134 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var no_used_underscore_variables_exports = {};
+__export(no_used_underscore_variables_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  noUsedUnderscoreVariables: () => noUsedUnderscoreVariables
+});
+module.exports = __toCommonJS(no_used_underscore_variables_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+const MESSAGE_ID = "noUsedUnderscoreVariables";
+const noUsedUnderscoreVariables = {
+  create(context) {
+    return {
+      ":function"(node) {
+        const scope = context.sourceCode.getScope(node);
+        for (const variable of scope.variables) {
+          if (!variable.name.startsWith("_")) {
+            continue;
+          }
+          const definitionNode = variable.defs[0];
+          (0, import_type_guards.assertNonNullable)(definitionNode, "User-declared _-prefixed variables always have at least one definition");
+          const functionBody = node.body;
+          const bodyRange = functionBody?.range;
+          const isParameter = definitionNode.type === "Parameter";
+          const hasBodyReferences = variable.references.some((reference) => {
+            if (!reference.isRead()) {
+              return false;
+            }
+            return !isParameter || !bodyRange || !reference.identifier.range || reference.identifier.range[0] >= bodyRange[0] && reference.identifier.range[1] <= bodyRange[1];
+          });
+          if (hasBodyReferences) {
+            context.report({
+              data: { name: variable.name },
+              messageId: MESSAGE_ID,
+              node: definitionNode.name
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow `_`-prefixed parameters and local variables that are actually used"
+    },
+    messages: {
+      [MESSAGE_ID]: '"{{ name }}" has a `_` prefix but is used. Remove the `_` prefix since it is not unused.'
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  noUsedUnderscoreVariables
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/eslint-rules/no-used-underscore-variables.d.cts

@@ -0,0 +1,20 @@
+/// <reference path="../../index.d.cts" />
+/**
+ * @file
+ *
+ * ESLint rule: no-used-underscore-variables
+ *
+ * Reports an error when a parameter or local variable with a `_` prefix is
+ * actually referenced in the function body. The `_` prefix convention signals
+ * "this identifier is intentionally unused" — if it IS used, the prefix is
+ * misleading and should be removed.
+ */
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+Message ID reported when a variable carries a `_` prefix (signalling unused) but is actually used.
+ */
+export declare const MESSAGE_ID = "noUsedUnderscoreVariables";
+/**
+ * ESLint rule disallowing `_`-prefixed parameters and local variables that are actually used, since the prefix advertises them as unused.
+ */
+export declare const noUsedUnderscoreVariables: Rule.RuleModule;