@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/linters/eslint-rules/require-method-template.mjs

@@ -0,0 +1,142 @@
+/*
+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 { getMandatoryNamedGroup } from "@mnaoumov/typescript-lib/reg-exp";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const TAG_NAME = "typeParam";
+const MESSAGE_ID_MISSING_TEMPLATE = "missingTemplate";
+const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = "missingTemplateDescription";
+const requireMethodTemplate = {
+  create(context) {
+    const settings = context.settings["jsdoc"];
+    const preferredTagName = settings?.tagNamePreference?.["template"] ?? TAG_NAME;
+    return {
+      "MethodDefinition"(node) {
+        const methodNode = toTSESTreeNode(node);
+        const functionExpression = methodNode.value;
+        const typeParams = functionExpression.typeParameters?.params;
+        if (!typeParams || typeParams.length === 0) {
+          return;
+        }
+        const sourceCode = context.sourceCode;
+        const comments = sourceCode.getCommentsBefore(node);
+        const jsdocComment = findJsdocComment(comments);
+        if (!jsdocComment) {
+          return;
+        }
+        const parsedTags = parseTypeParameterTags({
+          commentBody: jsdocComment.value,
+          tagName: preferredTagName
+        });
+        for (const typeParameter of typeParams) {
+          const parameterName = typeParameter.name.name;
+          const matchingTag = parsedTags.find((tag) => tag.name === parameterName);
+          if (!matchingTag) {
+            context.report({
+              data: {
+                // eslint-disable-next-line unicorn/name-replacements -- `paramName` is the placeholder this rule's own message template reads.
+                paramName: parameterName,
+                tagName: preferredTagName
+              },
+              messageId: MESSAGE_ID_MISSING_TEMPLATE,
+              node
+            });
+          } else if (!matchingTag.hasDescription) {
+            context.report({
+              data: {
+                // eslint-disable-next-line unicorn/name-replacements -- `paramName` is the placeholder this rule's own message template reads.
+                paramName: parameterName,
+                tagName: preferredTagName
+              },
+              messageId: MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+              node
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require `@typeParam` tags with descriptions for generic method type parameters"
+    },
+    messages: {
+      [MESSAGE_ID_MISSING_TEMPLATE]: "Missing @{{ tagName }} {{ paramName }}",
+      [MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION]: "@{{ tagName }} {{ paramName }} is missing a description"
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function findJsdocComment(comments) {
+  for (let index = comments.length - 1; index >= 0; index--) {
+    const comment = comments[index];
+    if (comment?.type === "Block" && comment.value.startsWith("*")) {
+      return comment;
+    }
+  }
+  return void 0;
+}
+function parseTypeParameterTags(params) {
+  const { commentBody, tagName } = params;
+  const tags = [];
+  const tagPattern = new RegExp(String.raw`@(?:${tagName}|template|typeParam)\s+(?<typeName>[\w$]+)(?<rest>.*)`, "g");
+  let match;
+  while ((match = tagPattern.exec(commentBody)) !== null) {
+    const name = getMandatoryNamedGroup(match, "typeName");
+    const rest = getMandatoryNamedGroup(match, "rest").trim();
+    const hasDescription = rest.length > 0 && rest !== "-";
+    tags.push({ hasDescription, name });
+  }
+  return tags;
+}
+export {
+  MESSAGE_ID_MISSING_TEMPLATE,
+  MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+  requireMethodTemplate
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/require-method-template.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-method-template\n *\n * Requires that generic methods (methods with type parameters) have\n * corresponding `@typeParam` (or `@template`) JSDoc tags for each type parameter.\n *\n * This fills a gap in `eslint-plugin-jsdoc`'s `require-template` rule, which\n * only checks top-level declarations (functions, classes, interfaces, type aliases)\n * but not methods within classes.\n *\n * @see {@link https://github.com/gajus/eslint-plugin-jsdoc/issues/1386}\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { Comment } from 'estree';\n\nimport { getMandatoryNamedGroup } from '@mnaoumov/typescript-lib/reg-exp';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\ninterface JsdocSettings {\n  tagNamePreference?: Record<string, string>;\n}\n\nconst TAG_NAME = 'typeParam';\n\n/**\nMessage ID reported when a method type parameter has no matching `@typeParam` tag.\n */\nexport const MESSAGE_ID_MISSING_TEMPLATE = 'missingTemplate';\n\n/**\nMessage ID reported when a method's `@typeParam` tag is missing a description.\n */\nexport const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = 'missingTemplateDescription';\n\n/**\n * ESLint rule requiring every generic method type parameter to carry a `@typeParam` tag with a description.\n */\nexport const requireMethodTemplate: Rule.RuleModule = {\n  create(context) {\n    const settings = context.settings['jsdoc'] as JsdocSettings | undefined;\n    const preferredTagName = settings?.tagNamePreference?.['template'] ?? TAG_NAME;\n\n    return {\n      'MethodDefinition'(node: Rule.Node): void {\n        const methodNode = toTSESTreeNode(node) as TSESTree.MethodDefinition;\n        const functionExpression = methodNode.value;\n\n        const typeParams = functionExpression.typeParameters?.params;\n        if (!typeParams || typeParams.length === 0) {\n          return;\n        }\n\n        const sourceCode = context.sourceCode;\n        const comments = sourceCode.getCommentsBefore(node);\n        const jsdocComment = findJsdocComment(comments);\n\n        if (!jsdocComment) {\n          return;\n        }\n\n        const parsedTags = parseTypeParameterTags({\n          commentBody: jsdocComment.value,\n          tagName: preferredTagName\n        });\n\n        for (const typeParameter of typeParams) {\n          const parameterName = typeParameter.name.name;\n          const matchingTag = parsedTags.find((tag) => tag.name === parameterName);\n\n          if (!matchingTag) {\n            context.report({\n              data: {\n                // eslint-disable-next-line unicorn/name-replacements -- `paramName` is the placeholder this rule's own message template reads.\n                paramName: parameterName,\n                tagName: preferredTagName\n              },\n              messageId: MESSAGE_ID_MISSING_TEMPLATE,\n              node\n            });\n          } else if (!matchingTag.hasDescription) {\n            context.report({\n              data: {\n                // eslint-disable-next-line unicorn/name-replacements -- `paramName` is the placeholder this rule's own message template reads.\n                paramName: parameterName,\n                tagName: preferredTagName\n              },\n              messageId: MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,\n              node\n            });\n          }\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require `@typeParam` tags with descriptions for generic method type parameters'\n    },\n    messages: {\n      [MESSAGE_ID_MISSING_TEMPLATE]: 'Missing @{{ tagName }} {{ paramName }}',\n      [MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION]: '@{{ tagName }} {{ paramName }} is missing a description'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\ninterface ParsedTag {\n  hasDescription: boolean;\n  name: string;\n}\n\n/**\n * Parameters for {@link parseTypeParameterTags}.\n */\ninterface ParseTypeParameterTagsParams {\n  /**\n   * The raw comment body (without the leading and trailing comment delimiters).\n   */\n  readonly commentBody: string;\n\n  /**\n   * The preferred tag name (`typeParam` or `template`).\n   */\n  readonly tagName: string;\n}\n\n/**\n * Finds the JSDoc block comment from a list of comments.\n *\n * @param comments - The comments before the node.\n * @returns The JSDoc block comment, or `undefined` if none found.\n */\nfunction findJsdocComment(comments: readonly Comment[]): Comment | undefined {\n  for (let index = comments.length - 1; index >= 0; index--) {\n    const comment = comments[index];\n    if (comment?.type === 'Block' && comment.value.startsWith('*')) {\n      return comment;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Parses `@typeParam` / `@template` tags from a JSDoc comment body.\n *\n * @param params - The parameters for the parse.\n * @returns An array of parsed tag entries.\n */\nfunction parseTypeParameterTags(params: ParseTypeParameterTagsParams): ParsedTag[] {\n  const { commentBody, tagName } = params;\n  const tags: ParsedTag[] = [];\n  /*\n   * The `$` character is a legal identifier character that `\\w` excludes, so a tag like `@typeParam $Object`\n   * would fail to match at all and the type parameter would be reported as undocumented despite having a tag.\n   */\n  const tagPattern = new RegExp(String.raw`@(?:${tagName}|template|typeParam)\\s+(?<typeName>[\\w$]+)(?<rest>.*)`, 'g');\n\n  let match;\n  while ((match = tagPattern.exec(commentBody)) !== null) {\n    const name = getMandatoryNamedGroup(match, 'typeName');\n    const rest = getMandatoryNamedGroup(match, 'rest').trim();\n    const hasDescription = rest.length > 0 && rest !== '-';\n    tags.push({ hasDescription, name });\n  }\n\n  return tags;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,SAAS,8BAA8B;AAEvC,SAAS,sBAAsB;AAM/B,MAAM,WAAW;AAKV,MAAM,8BAA8B;AAKpC,MAAM,0CAA0C;AAKhD,MAAM,wBAAyC;AAAA,EACpD,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,SAAS,OAAO;AACzC,UAAM,mBAAmB,UAAU,oBAAoB,UAAU,KAAK;AAEtE,WAAO;AAAA,MACL,mBAAmB,MAAuB;AACxC,cAAM,aAAa,eAAe,IAAI;AACtC,cAAM,qBAAqB,WAAW;AAEtC,cAAM,aAAa,mBAAmB,gBAAgB;AACtD,YAAI,CAAC,cAAc,WAAW,WAAW,GAAG;AAC1C;AAAA,QACF;AAEA,cAAM,aAAa,QAAQ;AAC3B,cAAM,WAAW,WAAW,kBAAkB,IAAI;AAClD,cAAM,eAAe,iBAAiB,QAAQ;AAE9C,YAAI,CAAC,cAAc;AACjB;AAAA,QACF;AAEA,cAAM,aAAa,uBAAuB;AAAA,UACxC,aAAa,aAAa;AAAA,UAC1B,SAAS;AAAA,QACX,CAAC;AAED,mBAAW,iBAAiB,YAAY;AACtC,gBAAM,gBAAgB,cAAc,KAAK;AACzC,gBAAM,cAAc,WAAW,KAAK,CAAC,QAAQ,IAAI,SAAS,aAAa;AAEvE,cAAI,CAAC,aAAa;AAChB,oBAAQ,OAAO;AAAA,cACb,MAAM;AAAA;AAAA,gBAEJ,WAAW;AAAA,gBACX,SAAS;AAAA,cACX;AAAA,cACA,WAAW;AAAA,cACX;AAAA,YACF,CAAC;AAAA,UACH,WAAW,CAAC,YAAY,gBAAgB;AACtC,oBAAQ,OAAO;AAAA,cACb,MAAM;AAAA;AAAA,gBAEJ,WAAW;AAAA,gBACX,SAAS;AAAA,cACX;AAAA,cACA,WAAW;AAAA,cACX;AAAA,YACF,CAAC;AAAA,UACH;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,2BAA2B,GAAG;AAAA,MAC/B,CAAC,uCAAuC,GAAG;AAAA,IAC7C;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AA4BA,SAAS,iBAAiB,UAAmD;AAC3E,WAAS,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS;AACzD,UAAM,UAAU,SAAS,KAAK;AAC9B,QAAI,SAAS,SAAS,WAAW,QAAQ,MAAM,WAAW,GAAG,GAAG;AAC9D,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;AAQA,SAAS,uBAAuB,QAAmD;AACjF,QAAM,EAAE,aAAa,QAAQ,IAAI;AACjC,QAAM,OAAoB,CAAC;AAK3B,QAAM,aAAa,IAAI,OAAO,OAAO,UAAU,OAAO,yDAAyD,GAAG;AAElH,MAAI;AACJ,UAAQ,QAAQ,WAAW,KAAK,WAAW,OAAO,MAAM;AACtD,UAAM,OAAO,uBAAuB,OAAO,UAAU;AACrD,UAAM,OAAO,uBAAuB,OAAO,MAAM,EAAE,KAAK;AACxD,UAAM,iBAAiB,KAAK,SAAS,KAAK,SAAS;AACnD,SAAK,KAAK,EAAE,gBAAgB,KAAK,CAAC;AAAA,EACpC;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/require-super-call.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when an `override` method does not access its `super` counterpart.
+ */
+export declare const MESSAGE_ID = "requireSuperCall";
+/**
+ * ESLint rule requiring `override` methods to call `super.methodName()`, so the base implementation is not silently skipped.
+ */
+export declare const requireSuperCall: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/require-super-call.mjs

@@ -0,0 +1,183 @@
+/*
+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 { assert } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  canHaveModifiers,
+  getModifiers,
+  SyntaxKind
+} from "typescript";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const MESSAGE_ID = "requireSuperCall";
+const requireSuperCall = {
+  create(context) {
+    const methodStack = [];
+    return {
+      "AssignmentExpression"(node) {
+        const current = methodStack.at(-1);
+        if (current?.kind !== "set") {
+          return;
+        }
+        const assignNode = toTSESTreeNode(node);
+        if (isSuperPropertyAccess(assignNode.left, current.methodName)) {
+          current.hasSuperCall = true;
+        }
+      },
+      "CallExpression"(node) {
+        const current = methodStack.at(-1);
+        if (current?.kind !== "method") {
+          return;
+        }
+        const callNode = toTSESTreeNode(node);
+        if (isSuperMethodCall(callNode, current.methodName)) {
+          current.hasSuperCall = true;
+        }
+      },
+      "MemberExpression"(node) {
+        const current = methodStack.at(-1);
+        if (current?.kind !== "get") {
+          return;
+        }
+        const memberNode = toTSESTreeNode(node);
+        if (isSuperPropertyAccess(memberNode, current.methodName)) {
+          current.hasSuperCall = true;
+        }
+      },
+      "MethodDefinition"(node) {
+        const methodNode = toTSESTreeNode(node);
+        if (!methodNode.override || methodNode.key.type !== "Identifier") {
+          return;
+        }
+        const kind = methodNode.kind === "get" || methodNode.kind === "set" ? methodNode.kind : "method";
+        methodStack.push({
+          hasSuperCall: false,
+          kind,
+          methodName: methodNode.key.name,
+          node: methodNode,
+          reportNode: node
+        });
+      },
+      "MethodDefinition:exit"() {
+        const info = methodStack.at(-1);
+        if (!info) {
+          return;
+        }
+        methodStack.pop();
+        if (info.hasSuperCall || isParentMethodAbstract({
+          context,
+          methodName: info.methodName,
+          methodNode: info.node
+        })) {
+          return;
+        }
+        context.report({
+          data: { kind: info.kind, methodName: info.methodName },
+          messageId: MESSAGE_ID,
+          node: info.reportNode
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require `override` methods to call `super.methodName()`"
+    },
+    messages: {
+      [MESSAGE_ID]: "Override {{ kind }} `{{ methodName }}` must access `super.{{ methodName }}`."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function isAbstract(declaration) {
+  assert(canHaveModifiers(declaration), "Expected method declaration to support modifiers");
+  const modifiers = getModifiers(declaration);
+  return modifiers?.some(($module) => $module.kind === SyntaxKind.AbstractKeyword) ?? false;
+}
+function isParentMethodAbstract(params) {
+  const { context, methodName, methodNode } = params;
+  const services = context.sourceCode.parserServices;
+  if (!services.program || !services.esTreeNodeToTSNodeMap) {
+    return false;
+  }
+  const checker = services.program.getTypeChecker();
+  const classDeclaration = methodNode.parent.parent;
+  const tsClassNode = services.esTreeNodeToTSNodeMap.get(classDeclaration);
+  const classType = checker.getTypeAtLocation(tsClassNode);
+  const baseTypes = classType.getBaseTypes();
+  if (!baseTypes) {
+    return false;
+  }
+  for (const baseType of baseTypes) {
+    const property = baseType.getProperty(methodName);
+    if (!property) {
+      continue;
+    }
+    const declarations = property.getDeclarations();
+    if (!declarations) {
+      continue;
+    }
+    for (const declaration of declarations) {
+      if (isAbstract(declaration)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isSuperMethodCall(node, methodName) {
+  const callee = node.callee;
+  return callee.type === "MemberExpression" && callee.object.type === "Super" && callee.property.type === "Identifier" && callee.property.name === methodName;
+}
+function isSuperPropertyAccess(node, propertyName) {
+  return node.type === "MemberExpression" && node.object.type === "Super" && node.property.type === "Identifier" && node.property.name === propertyName;
+}
+export {
+  MESSAGE_ID,
+  requireSuperCall
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/require-super-call.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-super-call\n *\n * Reports an error when an `override` method does not call `super.methodName()`\n * anywhere in its body. Overriding a method without calling `super` is almost\n * always a mistake that silently breaks parent-class behavior (lifecycle hooks,\n * initialization, event wiring, etc.).\n *\n * The super call can appear anywhere in the method body \u2014 as a standalone\n * statement, awaited, assigned to a variable, or nested in any expression.\n *\n * The rule automatically skips methods where the parent implementation is\n * `abstract`, since there is no concrete `super` to call.\n *\n * If the override intentionally replaces the parent implementation, disable the\n * rule on that line with an explanatory comment.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { Declaration } from 'typescript';\n\nimport { assert } from '@mnaoumov/typescript-lib/type-guards';\nimport {\n  canHaveModifiers,\n  getModifiers,\n  SyntaxKind\n} from 'typescript';\n\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\n/**\nMessage ID reported when an `override` method does not access its `super` counterpart.\n */\nexport const MESSAGE_ID = 'requireSuperCall';\n\ntype MethodKind = 'get' | 'method' | 'set';\n\ninterface OverrideMethodInfo {\n  hasSuperCall: boolean;\n  kind: MethodKind;\n  methodName: string;\n  node: TSESTree.MethodDefinition;\n  reportNode: Rule.Node;\n}\n\n/**\n * ESLint rule requiring `override` methods to call `super.methodName()`, so the base implementation is not silently skipped.\n */\nexport const requireSuperCall: Rule.RuleModule = {\n  create(context) {\n    const methodStack: OverrideMethodInfo[] = [];\n\n    return {\n      'AssignmentExpression'(node: Rule.Node): void {\n        const current = methodStack.at(-1);\n        if (current?.kind !== 'set') {\n          return;\n        }\n\n        const assignNode = toTSESTreeNode(node) as TSESTree.AssignmentExpression;\n        if (isSuperPropertyAccess(assignNode.left, current.methodName)) {\n          current.hasSuperCall = true;\n        }\n      },\n      'CallExpression'(node: Rule.Node): void {\n        const current = methodStack.at(-1);\n        if (current?.kind !== 'method') {\n          return;\n        }\n\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n        if (isSuperMethodCall(callNode, current.methodName)) {\n          current.hasSuperCall = true;\n        }\n      },\n      'MemberExpression'(node: Rule.Node): void {\n        const current = methodStack.at(-1);\n        if (current?.kind !== 'get') {\n          return;\n        }\n\n        const memberNode = toTSESTreeNode(node) as TSESTree.MemberExpression;\n        if (isSuperPropertyAccess(memberNode, current.methodName)) {\n          current.hasSuperCall = true;\n        }\n      },\n      'MethodDefinition'(node: Rule.Node): void {\n        const methodNode = toTSESTreeNode(node) as TSESTree.MethodDefinition;\n\n        // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n        if (!methodNode.override || methodNode.key.type !== 'Identifier') {\n          return;\n        }\n\n        const kind = methodNode.kind === 'get' || methodNode.kind === 'set' ? methodNode.kind : 'method';\n\n        methodStack.push({\n          hasSuperCall: false,\n          kind,\n          methodName: methodNode.key.name,\n          node: methodNode,\n          reportNode: node\n        });\n      },\n      'MethodDefinition:exit'(): void {\n        const info = methodStack.at(-1);\n        if (!info) {\n          return;\n        }\n\n        methodStack.pop();\n\n        if (\n          info.hasSuperCall || isParentMethodAbstract({\n            context,\n            methodName: info.methodName,\n            methodNode: info.node\n          })\n        ) {\n          return;\n        }\n\n        context.report({\n          data: { kind: info.kind, methodName: info.methodName },\n          messageId: MESSAGE_ID,\n          node: info.reportNode\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require `override` methods to call `super.methodName()`'\n    },\n    messages: {\n      [MESSAGE_ID]: 'Override {{ kind }} `{{ methodName }}` must access `super.{{ methodName }}`.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Parameters for {@link isParentMethodAbstract}.\n */\ninterface CheckIsParentMethodAbstractParams {\n  /**\n   * The ESLint rule context.\n   */\n  readonly context: Rule.RuleContext;\n\n  /**\n   * The method name to look up in the parent class.\n   */\n  readonly methodName: string;\n\n  /**\n   * The override method definition AST node.\n   */\n  readonly methodNode: TSESTree.MethodDefinition;\n}\n\n/**\n * Checks whether a declaration has the `abstract` modifier.\n *\n * @param declaration - The TypeScript declaration to inspect.\n * @returns `true` if the declaration is abstract.\n */\nfunction isAbstract(declaration: Declaration): boolean {\n  assert(canHaveModifiers(declaration), 'Expected method declaration to support modifiers');\n\n  const modifiers = getModifiers(declaration);\n  return modifiers?.some(($module) => $module.kind === SyntaxKind.AbstractKeyword) ?? false;\n}\n\n/**\n * Checks whether the parent class's version of the method is `abstract`.\n *\n * When type information is not available (e.g., parser configured without\n * `projectService`), returns `false` so the rule conservatively reports.\n *\n * @param params - The parameters for the check.\n * @returns `true` if the parent method is abstract.\n */\nfunction isParentMethodAbstract(params: CheckIsParentMethodAbstractParams): boolean {\n  const { context, methodName, methodNode } = params;\n  const services = context.sourceCode.parserServices as Partial<ParserServicesWithTypeInformation>;\n\n  if (!services.program || !services.esTreeNodeToTSNodeMap) {\n    return false;\n  }\n\n  const checker = services.program.getTypeChecker();\n  const classDeclaration = methodNode.parent.parent;\n  const tsClassNode = services.esTreeNodeToTSNodeMap.get(classDeclaration);\n  const classType = checker.getTypeAtLocation(tsClassNode);\n  const baseTypes = classType.getBaseTypes();\n\n  if (!baseTypes) {\n    return false;\n  }\n\n  for (const baseType of baseTypes) {\n    const property = baseType.getProperty(methodName);\n\n    if (!property) {\n      continue;\n    }\n\n    const declarations = property.getDeclarations();\n\n    if (!declarations) {\n      continue;\n    }\n\n    for (const declaration of declarations) {\n      if (isAbstract(declaration)) {\n        return true;\n      }\n    }\n  }\n\n  return false;\n}\n\n/**\n * Checks whether a call expression is `super.methodName(...)`.\n *\n * @param node - The call expression node.\n * @param methodName - The expected method name.\n * @returns `true` if the node is a matching super method call.\n */\nfunction isSuperMethodCall(node: TSESTree.CallExpression, methodName: string): boolean {\n  const callee = node.callee;\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values. */\n  return callee.type === 'MemberExpression'\n    && callee.object.type === 'Super'\n    && callee.property.type === 'Identifier'\n    && callee.property.name === methodName;\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison -- Re-enable after multi-line string comparison block. */\n}\n\n/**\n * Checks whether a node is a `super.propertyName` member expression.\n *\n * @param node - The AST node to check (MemberExpression or AssignmentExpression left-hand side).\n * @param propertyName - The expected property name.\n * @returns `true` if the node is a matching super property access.\n */\nfunction isSuperPropertyAccess(node: TSESTree.Node, propertyName: string): boolean {\n  /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values. */\n  return node.type === 'MemberExpression'\n    && node.object.type === 'Super'\n    && node.property.type === 'Identifier'\n    && node.property.name === propertyName;\n  /* eslint-enable @typescript-eslint/no-unsafe-enum-comparison -- Re-enable after multi-line string comparison block. */\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAS,cAAc;AACvB;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAEP,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAenB,MAAM,mBAAoC;AAAA,EAC/C,OAAO,SAAS;AACd,UAAM,cAAoC,CAAC;AAE3C,WAAO;AAAA,MACL,uBAAuB,MAAuB;AAC5C,cAAM,UAAU,YAAY,GAAG,EAAE;AACjC,YAAI,SAAS,SAAS,OAAO;AAC3B;AAAA,QACF;AAEA,cAAM,aAAa,eAAe,IAAI;AACtC,YAAI,sBAAsB,WAAW,MAAM,QAAQ,UAAU,GAAG;AAC9D,kBAAQ,eAAe;AAAA,QACzB;AAAA,MACF;AAAA,MACA,iBAAiB,MAAuB;AACtC,cAAM,UAAU,YAAY,GAAG,EAAE;AACjC,YAAI,SAAS,SAAS,UAAU;AAC9B;AAAA,QACF;AAEA,cAAM,WAAW,eAAe,IAAI;AACpC,YAAI,kBAAkB,UAAU,QAAQ,UAAU,GAAG;AACnD,kBAAQ,eAAe;AAAA,QACzB;AAAA,MACF;AAAA,MACA,mBAAmB,MAAuB;AACxC,cAAM,UAAU,YAAY,GAAG,EAAE;AACjC,YAAI,SAAS,SAAS,OAAO;AAC3B;AAAA,QACF;AAEA,cAAM,aAAa,eAAe,IAAI;AACtC,YAAI,sBAAsB,YAAY,QAAQ,UAAU,GAAG;AACzD,kBAAQ,eAAe;AAAA,QACzB;AAAA,MACF;AAAA,MACA,mBAAmB,MAAuB;AACxC,cAAM,aAAa,eAAe,IAAI;AAGtC,YAAI,CAAC,WAAW,YAAY,WAAW,IAAI,SAAS,cAAc;AAChE;AAAA,QACF;AAEA,cAAM,OAAO,WAAW,SAAS,SAAS,WAAW,SAAS,QAAQ,WAAW,OAAO;AAExF,oBAAY,KAAK;AAAA,UACf,cAAc;AAAA,UACd;AAAA,UACA,YAAY,WAAW,IAAI;AAAA,UAC3B,MAAM;AAAA,UACN,YAAY;AAAA,QACd,CAAC;AAAA,MACH;AAAA,MACA,0BAAgC;AAC9B,cAAM,OAAO,YAAY,GAAG,EAAE;AAC9B,YAAI,CAAC,MAAM;AACT;AAAA,QACF;AAEA,oBAAY,IAAI;AAEhB,YACE,KAAK,gBAAgB,uBAAuB;AAAA,UAC1C;AAAA,UACA,YAAY,KAAK;AAAA,UACjB,YAAY,KAAK;AAAA,QACnB,CAAC,GACD;AACA;AAAA,QACF;AAEA,gBAAQ,OAAO;AAAA,UACb,MAAM,EAAE,MAAM,KAAK,MAAM,YAAY,KAAK,WAAW;AAAA,UACrD,WAAW;AAAA,UACX,MAAM,KAAK;AAAA,QACb,CAAC;AAAA,MACH;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;AA4BA,SAAS,WAAW,aAAmC;AACrD,SAAO,iBAAiB,WAAW,GAAG,kDAAkD;AAExF,QAAM,YAAY,aAAa,WAAW;AAC1C,SAAO,WAAW,KAAK,CAAC,YAAY,QAAQ,SAAS,WAAW,eAAe,KAAK;AACtF;AAWA,SAAS,uBAAuB,QAAoD;AAClF,QAAM,EAAE,SAAS,YAAY,WAAW,IAAI;AAC5C,QAAM,WAAW,QAAQ,WAAW;AAEpC,MAAI,CAAC,SAAS,WAAW,CAAC,SAAS,uBAAuB;AACxD,WAAO;AAAA,EACT;AAEA,QAAM,UAAU,SAAS,QAAQ,eAAe;AAChD,QAAM,mBAAmB,WAAW,OAAO;AAC3C,QAAM,cAAc,SAAS,sBAAsB,IAAI,gBAAgB;AACvE,QAAM,YAAY,QAAQ,kBAAkB,WAAW;AACvD,QAAM,YAAY,UAAU,aAAa;AAEzC,MAAI,CAAC,WAAW;AACd,WAAO;AAAA,EACT;AAEA,aAAW,YAAY,WAAW;AAChC,UAAM,WAAW,SAAS,YAAY,UAAU;AAEhD,QAAI,CAAC,UAAU;AACb;AAAA,IACF;AAEA,UAAM,eAAe,SAAS,gBAAgB;AAE9C,QAAI,CAAC,cAAc;AACjB;AAAA,IACF;AAEA,eAAW,eAAe,cAAc;AACtC,UAAI,WAAW,WAAW,GAAG;AAC3B,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;AASA,SAAS,kBAAkB,MAA+B,YAA6B;AACrF,QAAM,SAAS,KAAK;AAEpB,SAAO,OAAO,SAAS,sBAClB,OAAO,OAAO,SAAS,WACvB,OAAO,SAAS,SAAS,gBACzB,OAAO,SAAS,SAAS;AAEhC;AASA,SAAS,sBAAsB,MAAqB,cAA+B;AAEjF,SAAO,KAAK,SAAS,sBAChB,KAAK,OAAO,SAAS,WACrB,KAAK,SAAS,SAAS,gBACvB,KAAK,SAAS,SAAS;AAE9B;",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/rule-tester-helper.d.mts

@@ -0,0 +1,18 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * Helper for bridging ESLint v10 rule types with `@typescript-eslint/rule-tester`.
+ */
+import type { RuleTester } from '@typescript-eslint/rule-tester';
+import type { Rule } from 'eslint';
+/**
+ * Casts an ESLint v10 `Rule.RuleModule` to the type expected by
+ * `@typescript-eslint/rule-tester`. The types are incompatible at the type
+ * level because typescript-eslint hasn't updated for ESLint v10 yet, but
+ * they are compatible at runtime.
+ *
+ * @param rule - The ESLint rule module.
+ * @returns The same rule, typed for the rule tester.
+ */
+export declare function toRuleTesterModule(rule: Rule.RuleModule): Parameters<RuleTester['run']>[1];

package/dist/lib/esm/linters/eslint-rules/rule-tester-helper.mjs

@@ -0,0 +1,55 @@
+/*
+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();
+})();
+})();
+
+function toRuleTesterModule(rule) {
+  const bridged = rule;
+  return bridged;
+}
+export {
+  toRuleTesterModule
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LXJ1bGVzL3J1bGUtdGVzdGVyLWhlbHBlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEhlbHBlciBmb3IgYnJpZGdpbmcgRVNMaW50IHYxMCBydWxlIHR5cGVzIHdpdGggYEB0eXBlc2NyaXB0LWVzbGludC9ydWxlLXRlc3RlcmAuXG4gKi9cbmltcG9ydCB0eXBlIHsgUnVsZVRlc3RlciB9IGZyb20gJ0B0eXBlc2NyaXB0LWVzbGludC9ydWxlLXRlc3Rlcic7XG5pbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tICdlc2xpbnQnO1xuXG4vKipcbiAqIENhc3RzIGFuIEVTTGludCB2MTAgYFJ1bGUuUnVsZU1vZHVsZWAgdG8gdGhlIHR5cGUgZXhwZWN0ZWQgYnlcbiAqIGBAdHlwZXNjcmlwdC1lc2xpbnQvcnVsZS10ZXN0ZXJgLiBUaGUgdHlwZXMgYXJlIGluY29tcGF0aWJsZSBhdCB0aGUgdHlwZVxuICogbGV2ZWwgYmVjYXVzZSB0eXBlc2NyaXB0LWVzbGludCBoYXNuJ3QgdXBkYXRlZCBmb3IgRVNMaW50IHYxMCB5ZXQsIGJ1dFxuICogdGhleSBhcmUgY29tcGF0aWJsZSBhdCBydW50aW1lLlxuICpcbiAqIEBwYXJhbSBydWxlIC0gVGhlIEVTTGludCBydWxlIG1vZHVsZS5cbiAqIEByZXR1cm5zIFRoZSBzYW1lIHJ1bGUsIHR5cGVkIGZvciB0aGUgcnVsZSB0ZXN0ZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b1J1bGVUZXN0ZXJNb2R1bGUocnVsZTogUnVsZS5SdWxlTW9kdWxlKTogUGFyYW1ldGVyczxSdWxlVGVzdGVyWydydW4nXT5bMV0ge1xuICAvLyBCcmlkZ2UgRVNMaW50IHYxMCBSdWxlLlJ1bGVNb2R1bGUgdG8gQHR5cGVzY3JpcHQtZXNsaW50L3J1bGUtdGVzdGVyJ3MgUnVsZU1vZHVsZS5cbiAgLy8gU3RydWN0dXJhbGx5IGNvbXBhdGlibGUgYnV0IG5vbWluYWxseSBpbmNvbXBhdGlibGUgdW50aWwgdHlwZXNjcmlwdC1lc2xpbnQgdXBkYXRlcy5cbiAgY29uc3QgYnJpZGdlZDogdW5rbm93biA9IHJ1bGU7XG5cbiAgcmV0dXJuIGJyaWRnZWQgYXMgUGFyYW1ldGVyczxSdWxlVGVzdGVyWydydW4nXT5bMV07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQWlCTyxTQUFTLG1CQUFtQixNQUF5RDtBQUcxRixRQUFNLFVBQW1CO0FBRXpCLFNBQU87QUFDVDsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/linters/eslint-rules/ts-estree-node.d.mts

@@ -0,0 +1,23 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * Views a node ESLint hands a rule as the TSESTree node it is.
+ *
+ * Under `@typescript-eslint/parser` every node a rule receives is a TSESTree node, but ESLint's own types describe
+ * it as an ESTree one. The two shapes disagree on how `type` is typed: ESTree uses string literals, TSESTree uses
+ * `AST_NODE_TYPES` enum members. So asserting straight from one to the other is an unsafe enum assignment
+ * (`@typescript-eslint/no-unsafe-enum-assignment`, since typescript-eslint 8.71). This module is the one place that
+ * crossing is made; a caller narrows the result within TSESTree, which is an ordinary downcast.
+ */
+import type { TSESTree } from '@typescript-eslint/utils';
+import type { Node as EstreeNode } from 'estree';
+/**
+ * Views an ESLint (ESTree-typed) node as a TSESTree node.
+ *
+ * The node is returned unchanged: only its static type moves.
+ *
+ * @param node - The node ESLint passed to the rule.
+ * @returns The same node, typed as a TSESTree node.
+ */
+export declare function toTSESTreeNode(node: EstreeNode): TSESTree.Node;

package/dist/lib/esm/linters/eslint-rules/ts-estree-node.mjs

@@ -0,0 +1,55 @@
+/*
+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 { castTo } from "@mnaoumov/typescript-lib/object-utils";
+function toTSESTreeNode(node) {
+  return castTo(node);
+}
+export {
+  toTSESTreeNode
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LXJ1bGVzL3RzLWVzdHJlZS1ub2RlLnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogVmlld3MgYSBub2RlIEVTTGludCBoYW5kcyBhIHJ1bGUgYXMgdGhlIFRTRVNUcmVlIG5vZGUgaXQgaXMuXG4gKlxuICogVW5kZXIgYEB0eXBlc2NyaXB0LWVzbGludC9wYXJzZXJgIGV2ZXJ5IG5vZGUgYSBydWxlIHJlY2VpdmVzIGlzIGEgVFNFU1RyZWUgbm9kZSwgYnV0IEVTTGludCdzIG93biB0eXBlcyBkZXNjcmliZVxuICogaXQgYXMgYW4gRVNUcmVlIG9uZS4gVGhlIHR3byBzaGFwZXMgZGlzYWdyZWUgb24gaG93IGB0eXBlYCBpcyB0eXBlZDogRVNUcmVlIHVzZXMgc3RyaW5nIGxpdGVyYWxzLCBUU0VTVHJlZSB1c2VzXG4gKiBgQVNUX05PREVfVFlQRVNgIGVudW0gbWVtYmVycy4gU28gYXNzZXJ0aW5nIHN0cmFpZ2h0IGZyb20gb25lIHRvIHRoZSBvdGhlciBpcyBhbiB1bnNhZmUgZW51bSBhc3NpZ25tZW50XG4gKiAoYEB0eXBlc2NyaXB0LWVzbGludC9uby11bnNhZmUtZW51bS1hc3NpZ25tZW50YCwgc2luY2UgdHlwZXNjcmlwdC1lc2xpbnQgOC43MSkuIFRoaXMgbW9kdWxlIGlzIHRoZSBvbmUgcGxhY2UgdGhhdFxuICogY3Jvc3NpbmcgaXMgbWFkZTsgYSBjYWxsZXIgbmFycm93cyB0aGUgcmVzdWx0IHdpdGhpbiBUU0VTVHJlZSwgd2hpY2ggaXMgYW4gb3JkaW5hcnkgZG93bmNhc3QuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBUU0VTVHJlZSB9IGZyb20gJ0B0eXBlc2NyaXB0LWVzbGludC91dGlscyc7XG5pbXBvcnQgdHlwZSB7IE5vZGUgYXMgRXN0cmVlTm9kZSB9IGZyb20gJ2VzdHJlZSc7XG5cbmltcG9ydCB7IGNhc3RUbyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi9vYmplY3QtdXRpbHMnO1xuXG4vKipcbiAqIFZpZXdzIGFuIEVTTGludCAoRVNUcmVlLXR5cGVkKSBub2RlIGFzIGEgVFNFU1RyZWUgbm9kZS5cbiAqXG4gKiBUaGUgbm9kZSBpcyByZXR1cm5lZCB1bmNoYW5nZWQ6IG9ubHkgaXRzIHN0YXRpYyB0eXBlIG1vdmVzLlxuICpcbiAqIEBwYXJhbSBub2RlIC0gVGhlIG5vZGUgRVNMaW50IHBhc3NlZCB0byB0aGUgcnVsZS5cbiAqIEByZXR1cm5zIFRoZSBzYW1lIG5vZGUsIHR5cGVkIGFzIGEgVFNFU1RyZWUgbm9kZS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRvVFNFU1RyZWVOb2RlKG5vZGU6IEVzdHJlZU5vZGUpOiBUU0VTVHJlZS5Ob2RlIHtcbiAgcmV0dXJuIGNhc3RUbzxUU0VTVHJlZS5Ob2RlPihub2RlKTtcbn1cbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBZUEsU0FBUyxjQUFjO0FBVWhCLFNBQVMsZUFBZSxNQUFpQztBQUM5RCxTQUFPLE9BQXNCLElBQUk7QUFDbkM7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/linters/eslint-types/@types/@eslint-community__eslint-plugin-eslint-comments__configs.d.mts

@@ -0,0 +1,20 @@
+/// <reference path="../../../index.d.mts" />
+/**
+ * @file
+ *
+ * Fixed typings for the `@eslint-community/eslint-plugin-eslint-comments/configs` package.
+ *
+ * @see {@link https://www.npmjs.com/package/@eslint-community/eslint-plugin-eslint-comments} for more information.
+ */
+
+declare module '@eslint-community/eslint-plugin-eslint-comments/configs' {
+  import type { Linter } from 'eslint';
+
+  interface EslintCommentsConfigs {
+    recommended: Linter.Config;
+  }
+
+  const configs: EslintCommentsConfigs;
+  // eslint-disable-next-line import-x/no-default-export -- That is the way library exports.
+  export default configs;
+}

package/dist/lib/esm/linters/eslint-types/@types/eslint-plugin-verify-tsdoc.d.mts

@@ -0,0 +1,17 @@
+/// <reference path="../../../index.d.mts" />
+/**
+ * @file
+ *
+ * Fixed typings for the `eslint-plugin-verify-tsdoc` package.
+ *
+ * @see {@link https://www.npmjs.com/package/eslint-plugin-verify-tsdoc} for more information.
+ */
+
+declare module 'eslint-plugin-verify-tsdoc' {
+  import type { ESLint } from 'eslint';
+
+  const plugin: ESLint.Plugin;
+
+  // eslint-disable-next-line import-x/no-default-export -- That is the way library exports.
+  export default plugin;
+}

package/dist/lib/esm/linters/eslint.d.mts

@@ -0,0 +1,35 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Linting utility for ESLint configuration with support for automatic fixing.
+ *
+ * This module provides a function to lint files based on the ESLint configuration defined in `eslint.config.ts`.
+ * It can automatically fix linting issues if specified, and logs results to the console.
+ */
+/**
+ * Parameters for the {@link lint} function.
+ */
+export interface LintOptions {
+    /**
+     * The configuration file copied to the project root when the project has none. Without it, ESLint runs
+     * against whatever it finds, and reports a missing configuration itself.
+     */
+    readonly defaultConfigFilePath?: string | undefined;
+    /**
+     * Optional file paths to lint. If omitted, lints the entire project.
+     */
+    readonly paths?: string[] | undefined;
+    /**
+     * Whether to fix linting issues automatically.
+     *
+     * @default `false`
+     */
+    readonly shouldFix?: boolean | undefined;
+}
+/**
+ * Lint the project with ESLint.
+ *
+ * @param options - The {@link LintOptions}.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;