@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

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

@@ -0,0 +1,181 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var require_method_template_exports = {};
+__export(require_method_template_exports, {
+  MESSAGE_ID_MISSING_TEMPLATE: () => MESSAGE_ID_MISSING_TEMPLATE,
+  MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION: () => MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION,
+  requireMethodTemplate: () => requireMethodTemplate
+});
+module.exports = __toCommonJS(require_method_template_exports);
+var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
+var import_ts_estree_node = require('./ts-estree-node.cjs');
+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 = (0, import_ts_estree_node.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 = (0, import_reg_exp.getMandatoryNamedGroup)(match, "typeName");
+    const rest = (0, import_reg_exp.getMandatoryNamedGroup)(match, "rest").trim();
+    const hasDescription = rest.length > 0 && rest !== "-";
+    tags.push({ hasDescription, name });
+  }
+  return tags;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAkBA,qBAAuC;AAEvC,4BAA+B;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,iBAAa,sCAAe,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,WAAO,uCAAuB,OAAO,UAAU;AACrD,UAAM,WAAO,uCAAuB,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/cjs/linters/eslint-rules/require-method-template.d.cts

@@ -0,0 +1,14 @@
+/// <reference path="../../library-references.d.cts" />
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+Message ID reported when a method type parameter has no matching `@typeParam` tag.
+ */
+export declare const MESSAGE_ID_MISSING_TEMPLATE = "missingTemplate";
+/**
+Message ID reported when a method's `@typeParam` tag is missing a description.
+ */
+export declare const MESSAGE_ID_MISSING_TEMPLATE_DESCRIPTION = "missingTemplateDescription";
+/**
+ * ESLint rule requiring every generic method type parameter to carry a `@typeParam` tag with a description.
+ */
+export declare const requireMethodTemplate: Rule.RuleModule;

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

@@ -0,0 +1,217 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var require_super_call_exports = {};
+__export(require_super_call_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  requireSuperCall: () => requireSuperCall
+});
+module.exports = __toCommonJS(require_super_call_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_typescript = require('typescript');
+var import_ts_estree_node = require('./ts-estree-node.cjs');
+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 = (0, import_ts_estree_node.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 = (0, import_ts_estree_node.toTSESTreeNode)(node);
+        if (isSuperMethodCall(callNode, current.methodName)) {
+          current.hasSuperCall = true;
+        }
+      },
+      "MemberExpression"(node) {
+        const current = methodStack.at(-1);
+        if (current?.kind !== "get") {
+          return;
+        }
+        const memberNode = (0, import_ts_estree_node.toTSESTreeNode)(node);
+        if (isSuperPropertyAccess(memberNode, current.methodName)) {
+          current.hasSuperCall = true;
+        }
+      },
+      "MethodDefinition"(node) {
+        const methodNode = (0, import_ts_estree_node.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) {
+  (0, import_type_guards.assert)((0, import_typescript.canHaveModifiers)(declaration), "Expected method declaration to support modifiers");
+  const modifiers = (0, import_typescript.getModifiers)(declaration);
+  return modifiers?.some(($module) => $module.kind === import_typescript.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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": "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",
  "names": []
}


package/dist/lib/cjs/linters/eslint-rules/require-super-call.d.cts

@@ -0,0 +1,10 @@
+/// <reference path="../../library-references.d.cts" />
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+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/cjs/linters/eslint-rules/rule-tester-helper.cjs

@@ -0,0 +1,92 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rule_tester_helper_exports = {};
+__export(rule_tester_helper_exports, {
+  toRuleTesterModule: () => toRuleTesterModule
+});
+module.exports = __toCommonJS(rule_tester_helper_exports);
+function toRuleTesterModule(rule) {
+  const bridged = rule;
+  return bridged;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toRuleTesterModule
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LXJ1bGVzL3J1bGUtdGVzdGVyLWhlbHBlci50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIEhlbHBlciBmb3IgYnJpZGdpbmcgRVNMaW50IHYxMCBydWxlIHR5cGVzIHdpdGggYEB0eXBlc2NyaXB0LWVzbGludC9ydWxlLXRlc3RlcmAuXG4gKi9cbmltcG9ydCB0eXBlIHsgUnVsZVRlc3RlciB9IGZyb20gJ0B0eXBlc2NyaXB0LWVzbGludC9ydWxlLXRlc3Rlcic7XG5pbXBvcnQgdHlwZSB7IFJ1bGUgfSBmcm9tICdlc2xpbnQnO1xuXG4vKipcbiAqIENhc3RzIGFuIEVTTGludCB2MTAgYFJ1bGUuUnVsZU1vZHVsZWAgdG8gdGhlIHR5cGUgZXhwZWN0ZWQgYnlcbiAqIGBAdHlwZXNjcmlwdC1lc2xpbnQvcnVsZS10ZXN0ZXJgLiBUaGUgdHlwZXMgYXJlIGluY29tcGF0aWJsZSBhdCB0aGUgdHlwZVxuICogbGV2ZWwgYmVjYXVzZSB0eXBlc2NyaXB0LWVzbGludCBoYXNuJ3QgdXBkYXRlZCBmb3IgRVNMaW50IHYxMCB5ZXQsIGJ1dFxuICogdGhleSBhcmUgY29tcGF0aWJsZSBhdCBydW50aW1lLlxuICpcbiAqIEBwYXJhbSBydWxlIC0gVGhlIEVTTGludCBydWxlIG1vZHVsZS5cbiAqIEByZXR1cm5zIFRoZSBzYW1lIHJ1bGUsIHR5cGVkIGZvciB0aGUgcnVsZSB0ZXN0ZXIuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiB0b1J1bGVUZXN0ZXJNb2R1bGUocnVsZTogUnVsZS5SdWxlTW9kdWxlKTogUGFyYW1ldGVyczxSdWxlVGVzdGVyWydydW4nXT5bMV0ge1xuICAvLyBCcmlkZ2UgRVNMaW50IHYxMCBSdWxlLlJ1bGVNb2R1bGUgdG8gQHR5cGVzY3JpcHQtZXNsaW50L3J1bGUtdGVzdGVyJ3MgUnVsZU1vZHVsZS5cbiAgLy8gU3RydWN0dXJhbGx5IGNvbXBhdGlibGUgYnV0IG5vbWluYWxseSBpbmNvbXBhdGlibGUgdW50aWwgdHlwZXNjcmlwdC1lc2xpbnQgdXBkYXRlcy5cbiAgY29uc3QgYnJpZGdlZDogdW5rbm93biA9IHJ1bGU7XG5cbiAgcmV0dXJuIGJyaWRnZWQgYXMgUGFyYW1ldGVyczxSdWxlVGVzdGVyWydydW4nXT5bMV07XG59XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBaUJPLFNBQVMsbUJBQW1CLE1BQXlEO0FBRzFGLFFBQU0sVUFBbUI7QUFFekIsU0FBTztBQUNUOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/cjs/linters/eslint-rules/rule-tester-helper.d.cts

@@ -0,0 +1,18 @@
+/// <reference path="../../library-references.d.cts" />
+/**
+ * @file
+ *
+ * Helper for bridging ESLint v10 rule types with `@typescript-eslint/rule-tester`.
+ */
+import type { RuleTester } from '@typescript-eslint/rule-tester' with { 'resolution-mode': 'import' };
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+ * 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];