@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/esm/linters/eslint-no-restricted-syntax.d.mts

@@ -0,0 +1,27 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * `no-restricted-syntax` rule entries for the shared ESLint config.
+ *
+ * Exported as a standalone constant so each selector can be unit-tested
+ * independently of the larger declarative config.
+ */
+/**
+ * A single `no-restricted-syntax` entry pairing an ESLint AST selector with a
+ * human-readable message explaining why the pattern is banned.
+ */
+export interface NoRestrictedSyntaxRuleEntry {
+    /**
+     * Human-readable message shown when the selector matches.
+     */
+    message: string;
+    /**
+     * ESLint AST selector identifying the banned pattern.
+     */
+    selector: string;
+}
+/**
+ * Restricted-syntax entries enforced by the shared ESLint config.
+ */
+export declare const noRestrictedSyntaxRuleEntries: readonly NoRestrictedSyntaxRuleEntry[];

package/dist/lib/esm/linters/eslint-no-restricted-syntax.mjs

@@ -0,0 +1,93 @@
+/*
+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();
+})();
+})();
+
+const noRestrictedSyntaxRuleEntries = [
+  {
+    message: "Do not use definite assignment assertions (!). Initialize the field or make it optional.",
+    selector: "PropertyDefinition[definite=true]"
+  },
+  {
+    message: "Do not use anonymous inline object types. Define a named interface or `type` alias instead.",
+    selector: "TSTypeLiteral:not(TSTypeAliasDeclaration > TSTypeLiteral)"
+  },
+  {
+    message: "Do not use anonymous inline mapped types. Define a named `type` alias instead.",
+    selector: "TSMappedType:not(TSTypeAliasDeclaration > TSMappedType)"
+  },
+  {
+    message: "Do not use double type assertions (as X as Y).",
+    selector: "TSAsExpression > TSAsExpression"
+  },
+  {
+    message: 'Do not use `as never`. It silently satisfies type constraints by claiming "this value is of every type" \u2014 almost always masks a real type mismatch. Fix the underlying types instead.',
+    selector: "TSAsExpression > TSNeverKeyword"
+  },
+  {
+    message: "Do not use `<never>` type assertions. Same reasoning as `as never`.",
+    selector: "TSTypeAssertion > TSNeverKeyword"
+  },
+  {
+    message: "Do not use _ prefix on methods or functions. The _ prefix is for unused parameters only.",
+    selector: "MethodDefinition[key.name=/^_/]:not([override=true])"
+  },
+  {
+    message: "Do not use _ prefix on methods or functions. The _ prefix is for unused parameters only.",
+    selector: "FunctionDeclaration[id.name=/^_/]"
+  },
+  {
+    message: 'Do not rename imports with "Mock" in the alias. Mock classes are the canonical types \u2014 use the original name.',
+    selector: "ImportSpecifier[local.name=/Mock/]:not([imported.name=/Mock/])"
+  },
+  {
+    message: "Do not use `declare` on class properties. Initialize the property or use a regular type annotation.",
+    selector: "PropertyDefinition[declare=true]"
+  }
+];
+export {
+  noRestrictedSyntaxRuleEntries
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/in-house-plugin.d.mts

@@ -0,0 +1,26 @@
+/// <reference path="../../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The generic in-house ESLint rules, and the plugin that registers them.
+ *
+ * Every in-house rule is registered under ONE namespace, {@link IN_HOUSE_ESLINT_PLUGIN_NAME}, whichever package
+ * defines it, so a disable comment naming `obsidian-dev-utils/<rule>` keeps working however the rules are split
+ * between packages. ESLint refuses two different plugin objects under one namespace in a single configuration, so a
+ * package adding rules of its own builds ONE plugin from {@link genericInHouseEslintRules} plus its own and hands
+ * that to the generic configuration, rather than registering a second plugin beside {@link inHouseEslintPlugin}.
+ */
+import type { ESLint } from 'eslint';
+/**
+ * The namespace every in-house rule is registered under. It keeps the name of the library the rules started in,
+ * because existing disable comments name it.
+ */
+export declare const IN_HOUSE_ESLINT_PLUGIN_NAME = "obsidian-dev-utils";
+/**
+ * The generic in-house rules, keyed by their name inside {@link IN_HOUSE_ESLINT_PLUGIN_NAME}.
+ */
+export declare const genericInHouseEslintRules: NonNullable<ESLint.Plugin['rules']>;
+/**
+ * The ESLint plugin registering the generic in-house rules alone, for a project that adds none of its own.
+ */
+export declare const inHouseEslintPlugin: ESLint.Plugin;

package/dist/lib/esm/linters/eslint-rules/in-house-plugin.mjs

@@ -0,0 +1,77 @@
+/*
+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 { noAsyncCallbackToUnsafeReturn } from "./no-async-callback-to-unsafe-return.mjs";
+import { noUnresolvedJsdocLink } from "./no-unresolved-jsdoc-link.mjs";
+import { noUnusedParamsMembers } from "./no-unused-params-members.mjs";
+import { noUsedUnderscoreVariables } from "./no-used-underscore-variables.mjs";
+import { paramsOptionsNameMatch } from "./params-options-name-match.mjs";
+import { preferNoopAsync } from "./prefer-noop-async.mjs";
+import { readonlyParamsOptionsResultMembers } from "./readonly-params-options-result-members.mjs";
+import { requireMethodTemplate } from "./require-method-template.mjs";
+import { requireSuperCall } from "./require-super-call.mjs";
+const IN_HOUSE_ESLINT_PLUGIN_NAME = "obsidian-dev-utils";
+const genericInHouseEslintRules = {
+  "no-async-callback-to-unsafe-return": noAsyncCallbackToUnsafeReturn,
+  "no-unresolved-jsdoc-link": noUnresolvedJsdocLink,
+  "no-unused-params-members": noUnusedParamsMembers,
+  "no-used-underscore-variables": noUsedUnderscoreVariables,
+  "params-options-name-match": paramsOptionsNameMatch,
+  "prefer-noop-async": preferNoopAsync,
+  "readonly-params-options-result-members": readonlyParamsOptionsResultMembers,
+  "require-method-template": requireMethodTemplate,
+  "require-super-call": requireSuperCall
+};
+const inHouseEslintPlugin = {
+  rules: genericInHouseEslintRules
+};
+export {
+  IN_HOUSE_ESLINT_PLUGIN_NAME,
+  genericInHouseEslintRules,
+  inHouseEslintPlugin
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/index.d.mts

@@ -0,0 +1,13 @@
+/// <reference path="../../library-references.d.mts" />
+export * as 'in-house-plugin' from './in-house-plugin.mjs';
+export * as 'no-async-callback-to-unsafe-return' from './no-async-callback-to-unsafe-return.mjs';
+export * as 'no-unresolved-jsdoc-link' from './no-unresolved-jsdoc-link.mjs';
+export * as 'no-unused-params-members' from './no-unused-params-members.mjs';
+export * as 'no-used-underscore-variables' from './no-used-underscore-variables.mjs';
+export * as 'params-options-name-match' from './params-options-name-match.mjs';
+export * as 'prefer-noop-async' from './prefer-noop-async.mjs';
+export * as 'readonly-params-options-result-members' from './readonly-params-options-result-members.mjs';
+export * as 'require-method-template' from './require-method-template.mjs';
+export * as 'require-super-call' from './require-super-call.mjs';
+export * as 'rule-tester-helper' from './rule-tester-helper.mjs';
+export * as 'ts-estree-node' from './ts-estree-node.mjs';

package/dist/lib/esm/linters/eslint-rules/index.mjs

@@ -0,0 +1,74 @@
+/*
+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 * as in_house_plugin from "./in-house-plugin.mjs";
+import * as no_async_callback_to_unsafe_return from "./no-async-callback-to-unsafe-return.mjs";
+import * as no_unresolved_jsdoc_link from "./no-unresolved-jsdoc-link.mjs";
+import * as no_unused_params_members from "./no-unused-params-members.mjs";
+import * as no_used_underscore_variables from "./no-used-underscore-variables.mjs";
+import * as params_options_name_match from "./params-options-name-match.mjs";
+import * as prefer_noop_async from "./prefer-noop-async.mjs";
+import * as readonly_params_options_result_members from "./readonly-params-options-result-members.mjs";
+import * as require_method_template from "./require-method-template.mjs";
+import * as require_super_call from "./require-super-call.mjs";
+import * as rule_tester_helper from "./rule-tester-helper.mjs";
+import * as ts_estree_node from "./ts-estree-node.mjs";
+export {
+  in_house_plugin as "in-house-plugin",
+  no_async_callback_to_unsafe_return as "no-async-callback-to-unsafe-return",
+  no_unresolved_jsdoc_link as "no-unresolved-jsdoc-link",
+  no_unused_params_members as "no-unused-params-members",
+  no_used_underscore_variables as "no-used-underscore-variables",
+  params_options_name_match as "params-options-name-match",
+  prefer_noop_async as "prefer-noop-async",
+  readonly_params_options_result_members as "readonly-params-options-result-members",
+  require_method_template as "require-method-template",
+  require_super_call as "require-super-call",
+  rule_tester_helper as "rule-tester-helper",
+  ts_estree_node as "ts-estree-node"
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/no-async-callback-to-unsafe-return.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../library-references.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when an async function is passed as a callback to a parameter whose return type is `any`/`unknown`, risking an unhandled promise rejection.
+ */
+export declare const MESSAGE_ID = "noAsyncCallbackToUnsafeReturn";
+/**
+ * ESLint rule disallowing async functions passed as callbacks to parameters with an `any` or `unknown` return type, where the returned promise is silently dropped.
+ */
+export declare const noAsyncCallbackToUnsafeReturn: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/no-async-callback-to-unsafe-return.mjs

@@ -0,0 +1,144 @@
+/*
+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 { assertNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  isIdentifier,
+  isTypeAliasDeclaration,
+  isTypeReferenceNode,
+  isUnionTypeNode,
+  SymbolFlags,
+  TypeFlags
+} from "typescript";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const MESSAGE_ID = "noAsyncCallbackToUnsafeReturn";
+function hasUnsafeReturnCallSignature(checker, type) {
+  return type.getCallSignatures().some((sig) => isUnsafeReturnSignature(checker, sig));
+}
+function isAsyncFunctionNode(node) {
+  return (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression") && node.async;
+}
+const UNSAFE_RETURN_FLAGS = TypeFlags.Any | TypeFlags.Unknown;
+const PROMISE_TYPE_NAMES = /* @__PURE__ */ new Set(["Promise", "PromiseLike"]);
+function containsPromiseReference(checker, node) {
+  if (isUnionTypeNode(node)) {
+    return node.types.some((member) => containsPromiseReference(checker, member));
+  }
+  if (isTypeReferenceNode(node)) {
+    const name = isIdentifier(node.typeName) ? node.typeName.text : "";
+    if (PROMISE_TYPE_NAMES.has(name)) {
+      return true;
+    }
+    let $symbol = checker.getSymbolAtLocation(node.typeName);
+    if ($symbol && $symbol.flags & SymbolFlags.Alias) {
+      $symbol = checker.getAliasedSymbol($symbol);
+    }
+    const declaration = $symbol?.declarations?.[0];
+    if (declaration && isTypeAliasDeclaration(declaration)) {
+      return containsPromiseReference(checker, declaration.type);
+    }
+  }
+  return false;
+}
+function isUnsafeReturnSignature(checker, sig) {
+  const returnType = checker.getReturnTypeOfSignature(sig);
+  if (!(returnType.flags & UNSAFE_RETURN_FLAGS)) {
+    return false;
+  }
+  const declaration = sig.getDeclaration();
+  const returnTypeNode = declaration.type;
+  assertNonNullable(returnTypeNode, "Signature declarations with any/unknown return always have a return type annotation");
+  return !containsPromiseReference(checker, returnTypeNode);
+}
+const noAsyncCallbackToUnsafeReturn = {
+  create(context) {
+    const services = context.sourceCode.parserServices;
+    const checker = services.program.getTypeChecker();
+    return {
+      CallExpression(node) {
+        const callNode = toTSESTreeNode(node);
+        for (let index = 0; index < callNode.arguments.length; index++) {
+          const argument = callNode.arguments[index];
+          if (!argument || !isAsyncFunctionNode(argument)) {
+            continue;
+          }
+          const tsCalleeNode = services.esTreeNodeToTSNodeMap.get(callNode.callee);
+          const calleeType = checker.getTypeAtLocation(tsCalleeNode);
+          for (const sig of calleeType.getCallSignatures()) {
+            const parameter = sig.getParameters()[index];
+            if (!parameter) {
+              continue;
+            }
+            const parameterType = checker.getTypeOfSymbol(parameter);
+            if (hasUnsafeReturnCallSignature(checker, parameterType)) {
+              context.report({
+                messageId: MESSAGE_ID,
+                node: argument
+              });
+              break;
+            }
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow passing async functions as callbacks to parameters with `any` or `unknown` return type"
+    },
+    messages: {
+      [MESSAGE_ID]: "Async function passed as callback to a parameter with `any`/`unknown` return type. This may cause unhandled promise rejections. Wrap the call: `(...args) => { yourAsyncFn(...args); }`."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+export {
+  MESSAGE_ID,
+  noAsyncCallbackToUnsafeReturn
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-async-callback-to-unsafe-return.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-async-callback-to-unsafe-return\n *\n * Reports an error when an async function is passed as a callback argument\n * to a function parameter whose return type is `any` or `unknown`. Because\n * these types silently accept `Promise<T>`, the caller won't await the\n * result, leading to unhandled promise rejections at runtime.\n *\n * Example:\n * ```typescript\n * // onClick(fn: (evt: MouseEvent) => any)\n * button.onClick(async () => {\n *   await someFn(); // Unhandled rejection if someFn throws\n * });\n * ```\n *\n * `@typescript-eslint/no-misused-promises` only catches `=> void` callbacks.\n * This rule closes the gap for `=> any` and `=> unknown` callbacks.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type {\n  Signature,\n  Type,\n  TypeChecker,\n  TypeNode\n} from 'typescript';\n\nimport { assertNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  isIdentifier,\n  isTypeAliasDeclaration,\n  isTypeReferenceNode,\n  isUnionTypeNode,\n  SymbolFlags,\n  TypeFlags\n} from 'typescript';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\n/**\nMessage ID reported when an async function is passed as a callback to a parameter whose return type is `any`/`unknown`, risking an unhandled promise rejection.\n */\nexport const MESSAGE_ID = 'noAsyncCallbackToUnsafeReturn';\n\n/**\n * Checks whether the given TypeScript type is a function type with an unsafe\n * return type for async callbacks.\n *\n * @param checker - TypeScript type checker.\n * @param type - The type to inspect.\n * @returns `true` if the type has at least one call signature with an unsafe return.\n */\nfunction hasUnsafeReturnCallSignature(checker: TypeChecker, type: Type): boolean {\n  return type.getCallSignatures().some((sig) => isUnsafeReturnSignature(checker, sig));\n}\n\n/**\n * Checks whether a node is an async function expression (arrow or regular).\n *\n * @param node - AST node to check.\n * @returns `true` if the node is an async arrow or function expression.\n */\nfunction isAsyncFunctionNode(node: TSESTree.Node): node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return (node.type === 'ArrowFunctionExpression' || node.type === 'FunctionExpression') && node.async;\n}\n\n// eslint-disable-next-line no-bitwise -- Bitwise flag mask is idiomatic for TypeScript compiler API.\nconst UNSAFE_RETURN_FLAGS = TypeFlags.Any | TypeFlags.Unknown;\n\nconst PROMISE_TYPE_NAMES = new Set(['Promise', 'PromiseLike']);\n\n/**\n * Checks whether a type node contains a reference to `Promise` or `PromiseLike`,\n * either directly or through a type alias. This indicates the caller explicitly\n * accounts for promise returns.\n *\n * @param checker - TypeScript type checker.\n * @param node - The type node to inspect.\n * @returns `true` if the node references `Promise` or `PromiseLike`.\n */\nfunction containsPromiseReference(checker: TypeChecker, node: TypeNode): boolean {\n  if (isUnionTypeNode(node)) {\n    return node.types.some((member) => containsPromiseReference(checker, member));\n  }\n\n  if (isTypeReferenceNode(node)) {\n    /* v8 ignore start -- Qualified names (e.g., ns.Promise) and import aliases require multi-file setup not available in RuleTester. */\n    const name = isIdentifier(node.typeName) ? node.typeName.text : '';\n    /* v8 ignore stop */\n    if (PROMISE_TYPE_NAMES.has(name)) {\n      return true;\n    }\n\n    // Resolve type alias (following imports) and check its definition body\n    let $symbol = checker.getSymbolAtLocation(node.typeName);\n    /* v8 ignore start -- Import aliases require multi-file setup not available in RuleTester. */\n    // eslint-disable-next-line no-bitwise -- Bitwise flag check is idiomatic for TypeScript compiler API.\n    if ($symbol && $symbol.flags & SymbolFlags.Alias) {\n      $symbol = checker.getAliasedSymbol($symbol);\n    }\n    /* v8 ignore stop */\n    const declaration = $symbol?.declarations?.[0];\n    if (declaration && isTypeAliasDeclaration(declaration)) {\n      // eslint-disable-next-line unicorn/no-useless-recursion -- This function recurses in two places: here, following a type alias, and above, fanning out over the members of a union. Only this one is a tail call, so turning it into a loop would leave the function half recursive and half iterative over the same tree.\n      return containsPromiseReference(checker, declaration.type);\n    }\n  }\n\n  return false;\n}\n\n/**\n * Checks whether a call signature has an unsafe return type (`any` or `unknown`)\n * without explicitly accounting for promises.\n *\n * Flags bare `any`, `unknown`, and unions like `any | string` that resolve to\n * `any`/`unknown` without including `Promise`/`PromiseLike`. Does NOT flag type\n * aliases like `Awaitable<T>` or unions like `any | Promise<any>` that explicitly\n * handle promise returns.\n *\n * @param checker - TypeScript type checker.\n * @param sig - The call signature to inspect.\n * @returns `true` if the return type is unsafe for async callbacks.\n */\nfunction isUnsafeReturnSignature(checker: TypeChecker, sig: Signature): boolean {\n  const returnType = checker.getReturnTypeOfSignature(sig);\n\n  // eslint-disable-next-line no-bitwise -- Bitwise flag check is idiomatic for TypeScript compiler API.\n  if (!(returnType.flags & UNSAFE_RETURN_FLAGS)) {\n    return false;\n  }\n\n  // Check the syntactic return type annotation. If it contains a reference to\n  // Promise/PromiseLike (directly or via a type alias), the caller explicitly\n  // handles async returns and should not be flagged.\n  const declaration = sig.getDeclaration();\n  const returnTypeNode = declaration.type;\n  assertNonNullable(returnTypeNode, 'Signature declarations with any/unknown return always have a return type annotation');\n\n  return !containsPromiseReference(checker, returnTypeNode);\n}\n\n/**\n * ESLint rule disallowing async functions passed as callbacks to parameters with an `any` or `unknown` return type, where the returned promise is silently dropped.\n */\nexport const noAsyncCallbackToUnsafeReturn: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n    const checker = services.program.getTypeChecker();\n\n    return {\n      CallExpression(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n\n        for (let index = 0; index < callNode.arguments.length; index++) {\n          const argument = callNode.arguments[index];\n          if (!argument || !isAsyncFunctionNode(argument)) {\n            continue;\n          }\n\n          const tsCalleeNode = services.esTreeNodeToTSNodeMap.get(callNode.callee);\n          const calleeType = checker.getTypeAtLocation(tsCalleeNode);\n\n          for (const sig of calleeType.getCallSignatures()) {\n            const parameter = sig.getParameters()[index];\n            if (!parameter) {\n              continue;\n            }\n\n            const parameterType = checker.getTypeOfSymbol(parameter);\n\n            if (hasUnsafeReturnCallSignature(checker, parameterType)) {\n              context.report({\n                messageId: MESSAGE_ID,\n                node: argument\n              });\n              break;\n            }\n          }\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow passing async functions as callbacks to parameters with `any` or `unknown` return type'\n    },\n    messages: {\n      [MESSAGE_ID]: 'Async function passed as callback to a parameter with `any`/`unknown` return type. This may cause unhandled promise rejections. Wrap the call: `(...args) => { yourAsyncFn(...args); }`.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,SAAS,yBAAyB;AAClC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAU1B,SAAS,6BAA6B,SAAsB,MAAqB;AAC/E,SAAO,KAAK,kBAAkB,EAAE,KAAK,CAAC,QAAQ,wBAAwB,SAAS,GAAG,CAAC;AACrF;AAQA,SAAS,oBAAoB,MAA6F;AAExH,UAAQ,KAAK,SAAS,6BAA6B,KAAK,SAAS,yBAAyB,KAAK;AACjG;AAGA,MAAM,sBAAsB,UAAU,MAAM,UAAU;AAEtD,MAAM,qBAAqB,oBAAI,IAAI,CAAC,WAAW,aAAa,CAAC;AAW7D,SAAS,yBAAyB,SAAsB,MAAyB;AAC/E,MAAI,gBAAgB,IAAI,GAAG;AACzB,WAAO,KAAK,MAAM,KAAK,CAAC,WAAW,yBAAyB,SAAS,MAAM,CAAC;AAAA,EAC9E;AAEA,MAAI,oBAAoB,IAAI,GAAG;AAE7B,UAAM,OAAO,aAAa,KAAK,QAAQ,IAAI,KAAK,SAAS,OAAO;AAEhE,QAAI,mBAAmB,IAAI,IAAI,GAAG;AAChC,aAAO;AAAA,IACT;AAGA,QAAI,UAAU,QAAQ,oBAAoB,KAAK,QAAQ;AAGvD,QAAI,WAAW,QAAQ,QAAQ,YAAY,OAAO;AAChD,gBAAU,QAAQ,iBAAiB,OAAO;AAAA,IAC5C;AAEA,UAAM,cAAc,SAAS,eAAe,CAAC;AAC7C,QAAI,eAAe,uBAAuB,WAAW,GAAG;AAEtD,aAAO,yBAAyB,SAAS,YAAY,IAAI;AAAA,IAC3D;AAAA,EACF;AAEA,SAAO;AACT;AAeA,SAAS,wBAAwB,SAAsB,KAAyB;AAC9E,QAAM,aAAa,QAAQ,yBAAyB,GAAG;AAGvD,MAAI,EAAE,WAAW,QAAQ,sBAAsB;AAC7C,WAAO;AAAA,EACT;AAKA,QAAM,cAAc,IAAI,eAAe;AACvC,QAAM,iBAAiB,YAAY;AACnC,oBAAkB,gBAAgB,qFAAqF;AAEvH,SAAO,CAAC,yBAAyB,SAAS,cAAc;AAC1D;AAKO,MAAM,gCAAiD;AAAA,EAC5D,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,WAAW;AACpC,UAAM,UAAU,SAAS,QAAQ,eAAe;AAEhD,WAAO;AAAA,MACL,eAAe,MAAuB;AACpC,cAAM,WAAW,eAAe,IAAI;AAEpC,iBAAS,QAAQ,GAAG,QAAQ,SAAS,UAAU,QAAQ,SAAS;AAC9D,gBAAM,WAAW,SAAS,UAAU,KAAK;AACzC,cAAI,CAAC,YAAY,CAAC,oBAAoB,QAAQ,GAAG;AAC/C;AAAA,UACF;AAEA,gBAAM,eAAe,SAAS,sBAAsB,IAAI,SAAS,MAAM;AACvE,gBAAM,aAAa,QAAQ,kBAAkB,YAAY;AAEzD,qBAAW,OAAO,WAAW,kBAAkB,GAAG;AAChD,kBAAM,YAAY,IAAI,cAAc,EAAE,KAAK;AAC3C,gBAAI,CAAC,WAAW;AACd;AAAA,YACF;AAEA,kBAAM,gBAAgB,QAAQ,gBAAgB,SAAS;AAEvD,gBAAI,6BAA6B,SAAS,aAAa,GAAG;AACxD,sBAAQ,OAAO;AAAA,gBACb,WAAW;AAAA,gBACX,MAAM;AAAA,cACR,CAAC;AACD;AAAA,YACF;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,UAAU,GAAG;AAAA,IAChB;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;",
  "names": []
}


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

@@ -0,0 +1,10 @@
+/// <reference path="../../library-references.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * Message ID reported when a JSDoc link target does not resolve to a symbol.
+ */
+export declare const MESSAGE_ID = "noUnresolvedJsdocLink";
+/**
+ * The ESLint rule that reports JSDoc links whose target does not resolve.
+ */
+export declare const noUnresolvedJsdocLink: Rule.RuleModule;