@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/linters/eslint-rules/no-unresolved-jsdoc-link.mjs

@@ -0,0 +1,277 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import {
+  escapeLeadingUnderscores,
+  forEachChild,
+  getJSDocCommentsAndTags,
+  isClassDeclaration,
+  isEnumDeclaration,
+  isFunctionDeclaration,
+  isGetAccessorDeclaration,
+  isIdentifier,
+  isInterfaceDeclaration,
+  isJSDocLink,
+  isJSDocLinkCode,
+  isJSDocLinkPlain,
+  isJSDocMemberName,
+  isMethodDeclaration,
+  isMethodSignature,
+  isModuleDeclaration,
+  isPropertyDeclaration,
+  isPropertySignature,
+  isSetAccessorDeclaration,
+  isTypeAliasDeclaration,
+  isVariableDeclaration,
+  resolveModuleName,
+  SymbolFlags,
+  sys
+} from "typescript";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const MESSAGE_ID = "noUnresolvedJsdocLink";
+const MODULE_PATH_REG_EXP = /^(?<modulePath>[^\s!|}]*)!(?<memberPath>[\w$.#]+)/;
+const IMPORT_TYPE_REG_EXP = /^import\(\s*(?<quote>['"])(?<modulePath>[^'"]+)\k<quote>\s*\)\.(?<memberPath>[\w$.#]+)/;
+const RELATIVE_PATH_PREFIX_REG_EXP = /^(?:\.\.?\/)+/;
+const MEMBER_SEPARATOR_REG_EXP = /[.#]/;
+const SOURCE_FILE_EXTENSION_REG_EXP = /(?:\.d)?\.[cm]?tsx?$/;
+const INDEX_SUFFIX = "/index";
+const programIndexCache = /* @__PURE__ */ new WeakMap();
+const noUnresolvedJsdocLink = {
+  create(context) {
+    const services = context.sourceCode.parserServices;
+    return {
+      Program(node) {
+        const program = services.program;
+        const checker = program.getTypeChecker();
+        const tsSourceFile = services.esTreeNodeToTSNodeMap.get(toTSESTreeNode(node));
+        const links = /* @__PURE__ */ new Set();
+        const localDeclarationNamesByName = /* @__PURE__ */ new Map();
+        function visitJsDocNode(jsDocNode) {
+          if (isJSDocLinkLike(jsDocNode)) {
+            links.add(jsDocNode);
+            return;
+          }
+          forEachChild(jsDocNode, visitJsDocNode);
+        }
+        function visitNode(tsNode) {
+          collectLocalDeclarationName(tsNode, localDeclarationNamesByName);
+          for (const jsDocNode of getJSDocCommentsAndTags(tsNode)) {
+            visitJsDocNode(jsDocNode);
+          }
+          forEachChild(tsNode, visitNode);
+        }
+        function reportIfUnresolved(link) {
+          if (!link.name || link.text.startsWith(":")) {
+            return;
+          }
+          const nameText = link.name.getText();
+          const fullTarget = nameText + link.text;
+          const moduleMatch = IMPORT_TYPE_REG_EXP.exec(fullTarget) ?? MODULE_PATH_REG_EXP.exec(fullTarget);
+          let reportedName = nameText;
+          let isResolved;
+          if (moduleMatch?.groups) {
+            const { memberPath, modulePath } = moduleMatch.groups;
+            reportedName = moduleMatch[0];
+            const moduleSymbol = findModule(program, checker, modulePath, tsSourceFile.fileName);
+            isResolved = !!resolveMemberPath(checker, moduleSymbol, memberPath.split(MEMBER_SEPARATOR_REG_EXP));
+          } else {
+            isResolved = isResolvedName({
+              checker,
+              containingFileName: tsSourceFile.fileName,
+              localDeclarationNamesByName,
+              name: link.name,
+              program
+            });
+          }
+          if (isResolved) {
+            return;
+          }
+          context.report({
+            data: {
+              name: reportedName
+            },
+            loc: {
+              end: context.sourceCode.getLocFromIndex(link.name.getEnd()),
+              start: context.sourceCode.getLocFromIndex(link.name.getStart())
+            },
+            messageId: MESSAGE_ID
+          });
+        }
+        visitNode(tsSourceFile);
+        for (const link of links) {
+          reportIfUnresolved(link);
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow JSDoc link tags whose target does not resolve to a symbol"
+    },
+    messages: {
+      [MESSAGE_ID]: "JSDoc link target `{{name}}` does not resolve. Was it renamed or removed?"
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function collectLocalDeclarationName(node, localDeclarationNamesByName) {
+  if (!isLocalDeclaration(node) || !node.name || !isIdentifier(node.name)) {
+    return;
+  }
+  const names = localDeclarationNamesByName.get(node.name.text) ?? [];
+  names.push(node.name);
+  localDeclarationNamesByName.set(node.name.text, names);
+}
+function findModule(program, checker, specifier, containingFileName) {
+  const ambientModule = getProgramIndex(program, checker).modulesByPath.get(specifier);
+  if (ambientModule) {
+    return ambientModule;
+  }
+  const resolvedFileName = resolveModuleName(specifier, containingFileName, program.getCompilerOptions(), sys).resolvedModule?.resolvedFileName;
+  const resolvedSourceFile = resolvedFileName === void 0 ? void 0 : program.getSourceFile(resolvedFileName);
+  const resolvedModule = resolvedSourceFile && checker.getSymbolAtLocation(resolvedSourceFile);
+  return resolvedModule ?? findModuleByPathSuffix(program, checker, specifier);
+}
+function findModuleByPathSuffix(program, checker, modulePath) {
+  const normalizedPath = modulePath.replace(RELATIVE_PATH_PREFIX_REG_EXP, "").replace(SOURCE_FILE_EXTENSION_REG_EXP, "");
+  const suffixes = [`/${normalizedPath}`, `/${normalizedPath}${INDEX_SUFFIX}`];
+  for (const sourceFile of program.getSourceFiles()) {
+    const pathWithoutExtension = sourceFile.fileName.replace(SOURCE_FILE_EXTENSION_REG_EXP, "");
+    if (suffixes.every((suffix) => !pathWithoutExtension.endsWith(suffix))) {
+      continue;
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (moduleSymbol) {
+      return moduleSymbol;
+    }
+  }
+  return void 0;
+}
+function flattenName(name) {
+  return isIdentifier(name) ? [name.text] : [...flattenName(name.left), name.right.text];
+}
+function getMember(checker, symbol, memberName) {
+  const escapedName = escapeLeadingUnderscores(memberName);
+  const target = resolveAlias(checker, symbol);
+  const moduleExport = (target.flags & SymbolFlags.Module) === 0 ? void 0 : checker.tryGetMemberInModuleExports(memberName, target);
+  return moduleExport ?? target.exports?.get(escapedName) ?? target.members?.get(escapedName) ?? checker.getPropertyOfType(checker.getDeclaredTypeOfSymbol(target), memberName) ?? checker.getPropertyOfType(checker.getTypeOfSymbol(target), memberName);
+}
+function getProgramIndex(program, checker) {
+  let index = programIndexCache.get(program);
+  if (index) {
+    return index;
+  }
+  index = {
+    exportsByName: /* @__PURE__ */ new Map(),
+    modulesByPath: /* @__PURE__ */ new Map()
+  };
+  const moduleSymbols = [];
+  for (const ambientModule of checker.getAmbientModules()) {
+    index.modulesByPath.set(ambientModule.name.replaceAll('"', ""), ambientModule);
+    moduleSymbols.push(ambientModule);
+  }
+  for (const sourceFile of program.getSourceFiles()) {
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (moduleSymbol) {
+      moduleSymbols.push(moduleSymbol);
+    }
+  }
+  for (const moduleSymbol of moduleSymbols) {
+    for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {
+      const symbols = index.exportsByName.get(exportSymbol.name) ?? [];
+      symbols.push(exportSymbol);
+      index.exportsByName.set(exportSymbol.name, symbols);
+    }
+  }
+  programIndexCache.set(program, index);
+  return index;
+}
+function isJSDocLinkLike(node) {
+  return isJSDocLink(node) || isJSDocLinkCode(node) || isJSDocLinkPlain(node);
+}
+function isLocalDeclaration(node) {
+  return isClassDeclaration(node) || isEnumDeclaration(node) || isFunctionDeclaration(node) || isGetAccessorDeclaration(node) || isInterfaceDeclaration(node) || isMethodDeclaration(node) || isMethodSignature(node) || isModuleDeclaration(node) || isPropertyDeclaration(node) || isPropertySignature(node) || isSetAccessorDeclaration(node) || isTypeAliasDeclaration(node) || isVariableDeclaration(node);
+}
+function isResolvedName(params) {
+  const {
+    checker,
+    containingFileName,
+    localDeclarationNamesByName,
+    name,
+    program
+  } = params;
+  if (checker.getSymbolAtLocation(name)) {
+    return true;
+  }
+  if (isJSDocMemberName(name) && checker.getSymbolAtLocation(name.right)) {
+    return true;
+  }
+  const [rootName = "", ...memberNames] = flattenName(name);
+  const index = getProgramIndex(program, checker);
+  const localRoots = (localDeclarationNamesByName.get(rootName) ?? []).map((declarationName) => checker.getSymbolAtLocation(declarationName));
+  const roots = [...localRoots, ...index.exportsByName.get(rootName) ?? [], findModule(program, checker, rootName, containingFileName)];
+  return roots.some((root) => !!resolveMemberPath(checker, root, memberNames));
+}
+function resolveAlias(checker, symbol) {
+  return (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);
+}
+function resolveMemberPath(checker, root, memberNames) {
+  let current = root;
+  for (const memberName of memberNames) {
+    if (!current) {
+      return void 0;
+    }
+    current = getMember(checker, current, memberName);
+  }
+  return current;
+}
+export {
+  MESSAGE_ID,
+  noUnresolvedJsdocLink
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-unresolved-jsdoc-link.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-unresolved-jsdoc-link\n *\n * Reports a JSDoc `link`, `linkcode` or `linkplain` inline tag whose target no longer resolves to a symbol.\n *\n * A rename leaves `{@link OldName}` behind and nothing else reports it: `jsdoc/no-undefined-types` does not resolve\n * link targets, TSDoc checks only the tag syntax, and `tsc` parses JSDoc links without ever diagnosing them. So a dead\n * link survives until somebody happens to click it.\n *\n * A target resolves when any of these finds it, tried in order:\n *\n * 1. The type checker, at the comment's own location, exactly as editor go-to-definition does \u2014 so everything in\n *    scope there resolves: type parameters, parameters, imports, and the DOM / ES globals.\n * 2. A declaration anywhere in the same file \u2014 a function nested in another, a private method \u2014 which is out of\n *    scope at a `*Params` interface naming it, yet is exactly what a rename of it would break.\n * 3. The exports of any module in the program, by name. A comment routinely names a type its file never imports (an\n *    integration test naming the class it drives through `evalInObsidian`, a remark naming an Obsidian API), and the\n *    API docs generator resolves such a name library-wide too. This keeps the rule about DEAD links rather than\n *    about imports: a renamed or removed declaration is exported by no module, so it is still reported.\n * 4. A module named by its specifier or its path, in both TSDoc forms: `obsidian#Events#on` (the package as the first\n *    segment) and `error!errorToString` / `obsidian/components/plugin-gate-component!PluginConflictSeverity.Warn`\n *    (a module path, ending with `!`) \u2014 plus TypeScript's own `import('./module.ts').Member`. A path matches any\n *    source file in the program whose path ends with it.\n *\n * After the first segment, each further `.` / `#` segment is looked up as a member: a namespace or module export, a\n * static or instance member, or a property of the previous member's type \u2014 so `App.vault.adapter` resolves.\n *\n * A link that is not a code reference is skipped: a URL (`{@link https://example.com}`) and a JSDoc namepath\n * (`{@link module:foo}`) both parse as a name followed by text starting with `:`, and a link with no name has\n * nothing to resolve.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type {\n  ClassDeclaration,\n  EntityName,\n  EnumDeclaration,\n  FunctionDeclaration,\n  GetAccessorDeclaration,\n  Identifier,\n  InterfaceDeclaration,\n  JSDocLink,\n  JSDocLinkCode,\n  JSDocLinkPlain,\n  JSDocMemberName,\n  MethodDeclaration,\n  MethodSignature,\n  ModuleDeclaration,\n  Node,\n  Program,\n  PropertyDeclaration,\n  PropertySignature,\n  SetAccessorDeclaration,\n  Symbol as TsSymbol,\n  TypeAliasDeclaration,\n  TypeChecker,\n  VariableDeclaration\n} from 'typescript';\n\nimport {\n  escapeLeadingUnderscores,\n  forEachChild,\n  getJSDocCommentsAndTags,\n  isClassDeclaration,\n  isEnumDeclaration,\n  isFunctionDeclaration,\n  isGetAccessorDeclaration,\n  isIdentifier,\n  isInterfaceDeclaration,\n  isJSDocLink,\n  isJSDocLinkCode,\n  isJSDocLinkPlain,\n  isJSDocMemberName,\n  isMethodDeclaration,\n  isMethodSignature,\n  isModuleDeclaration,\n  isPropertyDeclaration,\n  isPropertySignature,\n  isSetAccessorDeclaration,\n  isTypeAliasDeclaration,\n  isVariableDeclaration,\n  resolveModuleName,\n  SymbolFlags,\n  sys\n} from 'typescript';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\n/**\n * Message ID reported when a JSDoc link target does not resolve to a symbol.\n */\nexport const MESSAGE_ID = 'noUnresolvedJsdocLink';\n\ninterface IsResolvedNameParams {\n  readonly checker: TypeChecker;\n  readonly containingFileName: string;\n  readonly localDeclarationNamesByName: ReadonlyMap<string, readonly Identifier[]>;\n  readonly name: EntityName | JSDocMemberName;\n  readonly program: Program;\n}\n\ntype JSDocLinkLike = JSDocLink | JSDocLinkCode | JSDocLinkPlain;\n\ntype LocalDeclaration =\n  | ClassDeclaration\n  | EnumDeclaration\n  | FunctionDeclaration\n  | GetAccessorDeclaration\n  | InterfaceDeclaration\n  | MethodDeclaration\n  | MethodSignature\n  | ModuleDeclaration\n  | PropertyDeclaration\n  | PropertySignature\n  | SetAccessorDeclaration\n  | TypeAliasDeclaration\n  | VariableDeclaration;\n\ntype ModulePathMatchGroups = Readonly<Record<'memberPath' | 'modulePath', string>>;\n\ninterface ProgramIndex {\n  readonly exportsByName: Map<string, TsSymbol[]>;\n  readonly modulesByPath: Map<string, TsSymbol>;\n}\n\nconst MODULE_PATH_REG_EXP = /^(?<modulePath>[^\\s!|}]*)!(?<memberPath>[\\w$.#]+)/;\nconst IMPORT_TYPE_REG_EXP = /^import\\(\\s*(?<quote>['\"])(?<modulePath>[^'\"]+)\\k<quote>\\s*\\)\\.(?<memberPath>[\\w$.#]+)/;\nconst RELATIVE_PATH_PREFIX_REG_EXP = /^(?:\\.\\.?\\/)+/;\nconst MEMBER_SEPARATOR_REG_EXP = /[.#]/;\nconst SOURCE_FILE_EXTENSION_REG_EXP = /(?:\\.d)?\\.[cm]?tsx?$/;\nconst INDEX_SUFFIX = '/index';\n\nconst programIndexCache = new WeakMap<Program, ProgramIndex>();\n\n/**\n * The ESLint rule that reports JSDoc links whose target does not resolve.\n */\nexport const noUnresolvedJsdocLink: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n\n    return {\n      Program(node): void {\n        const program = services.program;\n        const checker = program.getTypeChecker();\n        const tsSourceFile = services.esTreeNodeToTSNodeMap.get(toTSESTreeNode(node) as TSESTree.Program);\n\n        /*\n         * The same link is reachable more than once: a parameter returns its own `@param` tag, which its function's\n         * JSDoc block also contains. So deduplicate on the link itself rather than on the JSDoc node.\n         */\n        const links = new Set<JSDocLinkLike>();\n\n        /*\n         * A link may name a declaration further down the file, so the whole file is walked before any link is\n         * resolved.\n         */\n        const localDeclarationNamesByName = new Map<string, Identifier[]>();\n\n        function visitJsDocNode(jsDocNode: Node): void {\n          if (isJSDocLinkLike(jsDocNode)) {\n            links.add(jsDocNode);\n            return;\n          }\n          forEachChild(jsDocNode, visitJsDocNode);\n        }\n\n        function visitNode(tsNode: Node): void {\n          collectLocalDeclarationName(tsNode, localDeclarationNamesByName);\n          for (const jsDocNode of getJSDocCommentsAndTags(tsNode)) {\n            visitJsDocNode(jsDocNode);\n          }\n          forEachChild(tsNode, visitNode);\n        }\n\n        function reportIfUnresolved(link: JSDocLinkLike): void {\n          if (!link.name || link.text.startsWith(':')) {\n            return;\n          }\n\n          const nameText = link.name.getText();\n          const fullTarget = nameText + link.text;\n          const moduleMatch = IMPORT_TYPE_REG_EXP.exec(fullTarget) ?? MODULE_PATH_REG_EXP.exec(fullTarget);\n          let reportedName = nameText;\n          let isResolved: boolean;\n\n          if (moduleMatch?.groups) {\n            const { memberPath, modulePath } = moduleMatch.groups as ModulePathMatchGroups;\n            reportedName = moduleMatch[0];\n            const moduleSymbol = findModule(program, checker, modulePath, tsSourceFile.fileName);\n            isResolved = !!resolveMemberPath(checker, moduleSymbol, memberPath.split(MEMBER_SEPARATOR_REG_EXP));\n          } else {\n            isResolved = isResolvedName({\n              checker,\n              containingFileName: tsSourceFile.fileName,\n              localDeclarationNamesByName,\n              name: link.name,\n              program\n            });\n          }\n\n          if (isResolved) {\n            return;\n          }\n\n          context.report({\n            data: {\n              name: reportedName\n            },\n            loc: {\n              end: context.sourceCode.getLocFromIndex(link.name.getEnd()),\n              start: context.sourceCode.getLocFromIndex(link.name.getStart())\n            },\n            messageId: MESSAGE_ID\n          });\n        }\n\n        visitNode(tsSourceFile);\n        for (const link of links) {\n          reportIfUnresolved(link);\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow JSDoc link tags whose target does not resolve to a symbol'\n    },\n    messages: {\n      [MESSAGE_ID]: 'JSDoc link target `{{name}}` does not resolve. Was it renamed or removed?'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\nfunction collectLocalDeclarationName(node: Node, localDeclarationNamesByName: Map<string, Identifier[]>): void {\n  if (!isLocalDeclaration(node) || !node.name || !isIdentifier(node.name)) {\n    return;\n  }\n  const names = localDeclarationNamesByName.get(node.name.text) ?? [];\n  names.push(node.name);\n  localDeclarationNamesByName.set(node.name.text, names);\n}\n\nfunction findModule(program: Program, checker: TypeChecker, specifier: string, containingFileName: string): TsSymbol | undefined {\n  const ambientModule = getProgramIndex(program, checker).modulesByPath.get(specifier);\n  if (ambientModule) {\n    return ambientModule;\n  }\n\n  const resolvedFileName = resolveModuleName(specifier, containingFileName, program.getCompilerOptions(), sys).resolvedModule?.resolvedFileName;\n  const resolvedSourceFile = resolvedFileName === undefined ? undefined : program.getSourceFile(resolvedFileName);\n  const resolvedModule = resolvedSourceFile && checker.getSymbolAtLocation(resolvedSourceFile);\n  return resolvedModule ?? findModuleByPathSuffix(program, checker, specifier);\n}\n\nfunction findModuleByPathSuffix(program: Program, checker: TypeChecker, modulePath: string): TsSymbol | undefined {\n  const normalizedPath = modulePath.replace(RELATIVE_PATH_PREFIX_REG_EXP, '').replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n  const suffixes = [`/${normalizedPath}`, `/${normalizedPath}${INDEX_SUFFIX}`];\n  for (const sourceFile of program.getSourceFiles()) {\n    const pathWithoutExtension = sourceFile.fileName.replace(SOURCE_FILE_EXTENSION_REG_EXP, '');\n    if (suffixes.every((suffix) => !pathWithoutExtension.endsWith(suffix))) {\n      continue;\n    }\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      return moduleSymbol;\n    }\n  }\n  return undefined;\n}\n\nfunction flattenName(name: EntityName | JSDocMemberName): string[] {\n  return isIdentifier(name) ? [name.text] : [...flattenName(name.left), name.right.text];\n}\n\nfunction getMember(checker: TypeChecker, symbol: TsSymbol, memberName: string): TsSymbol | undefined {\n  const escapedName = escapeLeadingUnderscores(memberName);\n  const target = resolveAlias(checker, symbol);\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  const moduleExport = (target.flags & SymbolFlags.Module) === 0 ? undefined : checker.tryGetMemberInModuleExports(memberName, target);\n  return moduleExport\n    ?? target.exports?.get(escapedName)\n    ?? target.members?.get(escapedName)\n    ?? checker.getPropertyOfType(checker.getDeclaredTypeOfSymbol(target), memberName)\n    ?? checker.getPropertyOfType(checker.getTypeOfSymbol(target), memberName);\n}\n\nfunction getProgramIndex(program: Program, checker: TypeChecker): ProgramIndex {\n  let index = programIndexCache.get(program);\n  if (index) {\n    return index;\n  }\n\n  index = {\n    exportsByName: new Map<string, TsSymbol[]>(),\n    modulesByPath: new Map<string, TsSymbol>()\n  };\n\n  const moduleSymbols: TsSymbol[] = [];\n  for (const ambientModule of checker.getAmbientModules()) {\n    index.modulesByPath.set(ambientModule.name.replaceAll('\"', ''), ambientModule);\n    moduleSymbols.push(ambientModule);\n  }\n  for (const sourceFile of program.getSourceFiles()) {\n    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);\n    if (moduleSymbol) {\n      moduleSymbols.push(moduleSymbol);\n    }\n  }\n\n  for (const moduleSymbol of moduleSymbols) {\n    for (const exportSymbol of checker.getExportsOfModule(moduleSymbol)) {\n      const symbols = index.exportsByName.get(exportSymbol.name) ?? [];\n      symbols.push(exportSymbol);\n      index.exportsByName.set(exportSymbol.name, symbols);\n    }\n  }\n\n  programIndexCache.set(program, index);\n  return index;\n}\n\nfunction isJSDocLinkLike(node: Node): node is JSDocLinkLike {\n  return isJSDocLink(node) || isJSDocLinkCode(node) || isJSDocLinkPlain(node);\n}\n\nfunction isLocalDeclaration(node: Node): node is LocalDeclaration {\n  return isClassDeclaration(node)\n    || isEnumDeclaration(node)\n    || isFunctionDeclaration(node)\n    || isGetAccessorDeclaration(node)\n    || isInterfaceDeclaration(node)\n    || isMethodDeclaration(node)\n    || isMethodSignature(node)\n    || isModuleDeclaration(node)\n    || isPropertyDeclaration(node)\n    || isPropertySignature(node)\n    || isSetAccessorDeclaration(node)\n    || isTypeAliasDeclaration(node)\n    || isVariableDeclaration(node);\n}\n\nfunction isResolvedName(params: IsResolvedNameParams): boolean {\n  const {\n    checker,\n    containingFileName,\n    localDeclarationNamesByName,\n    name,\n    program\n  } = params;\n\n  if (checker.getSymbolAtLocation(name)) {\n    return true;\n  }\n\n  // `Foo#bar` is a `JSDocMemberName`, which the checker resolves only through its right-hand member.\n  if (isJSDocMemberName(name) && checker.getSymbolAtLocation(name.right)) {\n    return true;\n  }\n\n  const [rootName = '', ...memberNames] = flattenName(name);\n  const index = getProgramIndex(program, checker);\n  const localRoots = (localDeclarationNamesByName.get(rootName) ?? []).map((declarationName) => checker.getSymbolAtLocation(declarationName));\n  const roots = [...localRoots, ...index.exportsByName.get(rootName) ?? [], findModule(program, checker, rootName, containingFileName)];\n\n  return roots.some((root) => !!resolveMemberPath(checker, root, memberNames));\n}\n\nfunction resolveAlias(checker: TypeChecker, symbol: TsSymbol): TsSymbol {\n  // eslint-disable-next-line no-bitwise -- Bitwise flag test is idiomatic for the TypeScript compiler API.\n  return (symbol.flags & SymbolFlags.Alias) === 0 ? symbol : checker.getAliasedSymbol(symbol);\n}\n\nfunction resolveMemberPath(checker: TypeChecker, root: TsSymbol | undefined, memberNames: readonly string[]): TsSymbol | undefined {\n  let current: TsSymbol | undefined = root;\n  for (const memberName of memberNames) {\n    if (!current) {\n      return undefined;\n    }\n    current = getMember(checker, current, memberName);\n  }\n  return current;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/no-unused-params-members.d.mts

@@ -0,0 +1,41 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @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';
+/**
+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/esm/linters/eslint-rules/no-unused-params-members.mjs

@@ -0,0 +1,227 @@
+/*
+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 initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { ensureNonNullable } from "@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 = 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;
+}
+export {
+  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/esm/linters/eslint-rules/no-used-underscore-variables.d.mts

@@ -0,0 +1,20 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @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';
+/**
+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;