@mnaoumov/typescript-dev-toolkit 0.0.0 → 1.1.0

package/dist/lib/cjs/linters/eslint-rules/params-options-name-match.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 params_options_name_match_exports = {};
+__export(params_options_name_match_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  paramsOptionsNameMatch: () => paramsOptionsNameMatch
+});
+module.exports = __toCommonJS(params_options_name_match_exports);
+const PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;
+const PARAMS_SUFFIX = "Params";
+const OPTIONS_SUFFIX = "Options";
+const MESSAGE_ID = "paramsOptionsNameMatch";
+const paramsOptionsNameMatch = {
+  create(context) {
+    return {
+      ":function[params.length>0]"(node) {
+        if (!isInExportedScope(node)) {
+          return;
+        }
+        const functionNode = node;
+        const expectedPrefix = getExpectedPrefix(node);
+        if (!expectedPrefix) {
+          return;
+        }
+        const isSoleParameter = functionNode.params.length === 1;
+        for (const parameter of functionNode.params) {
+          const typeInfo = getTypeAnnotationInfo(parameter);
+          if (!typeInfo || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeInfo.name)) {
+            continue;
+          }
+          const expectedSuffix = isSoleParameter && !isOptionalParameter(parameter) ? PARAMS_SUFFIX : OPTIONS_SUFFIX;
+          const expectedName = `${expectedPrefix}${expectedSuffix}`;
+          if (typeInfo.name !== expectedName) {
+            context.report({
+              data: {
+                actualName: typeInfo.name,
+                expectedName
+              },
+              messageId: MESSAGE_ID,
+              node: typeInfo.node
+            });
+          }
+        }
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require `*Params`/`*Options` type names to match the owning function/constructor (prefix) and the sole-vs-supplementary argument convention (suffix)"
+    },
+    messages: {
+      [MESSAGE_ID]: 'Type "{{ actualName }}" does not match the expected name "{{ expectedName }}" for this function/constructor.'
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function getClassName(methodDefinition) {
+  const classBody = methodDefinition.parent;
+  const classNode = classBody?.parent;
+  return !classNode || !("id" in classNode) || !classNode.id || typeof classNode.id !== "object" || !("name" in classNode.id) || typeof classNode.id.name !== "string" ? void 0 : classNode.id.name;
+}
+function getExpectedPrefix(node) {
+  const methodPrefix = getMethodExpectedPrefix(node);
+  return methodPrefix ?? getFunctionExpectedPrefix(node);
+}
+function getFunctionExpectedPrefix(node) {
+  if ("id" in node && node.id && typeof node.id === "object" && "name" in node.id && typeof node.id.name === "string") {
+    return toPascalCase(node.id.name);
+  }
+  return node.parent?.type === "VariableDeclarator" && "id" in node.parent && node.parent.id && typeof node.parent.id === "object" && "name" in node.parent.id && typeof node.parent.id.name === "string" ? toPascalCase(node.parent.id.name) : void 0;
+}
+function getMethodExpectedPrefix(node) {
+  const methodDefinition = node.parent;
+  if (methodDefinition?.type !== "MethodDefinition") {
+    return void 0;
+  }
+  if (!("key" in methodDefinition) || !methodDefinition.key || typeof methodDefinition.key !== "object" || !("name" in methodDefinition.key) || typeof methodDefinition.key.name !== "string") {
+    return void 0;
+  }
+  const methodName = methodDefinition.key.name;
+  const className = getClassName(methodDefinition);
+  if (!className) {
+    return void 0;
+  }
+  return methodName === "constructor" ? `${className}Constructor` : className + toPascalCase(methodName);
+}
+function getTypeAnnotationInfo(parameter) {
+  const target = parameter.type === "AssignmentPattern" ? parameter.left : parameter;
+  if (!("typeAnnotation" in target) || !target.typeAnnotation) {
+    return void 0;
+  }
+  const annotation = target.typeAnnotation;
+  const typeNode = annotation["typeAnnotation"];
+  if (!typeNode || typeof typeNode !== "object") {
+    return void 0;
+  }
+  const typeNodeObject = typeNode;
+  if (typeNodeObject["type"] === "TSTypeReference" && typeNodeObject["typeName"] && typeof typeNodeObject["typeName"] === "object") {
+    const typeName = typeNodeObject["typeName"];
+    if (typeName["type"] === "Identifier" && typeof typeName["name"] === "string") {
+      return { name: typeName["name"], node: typeNode };
+    }
+  }
+  return void 0;
+}
+function isInExportedScope(node) {
+  const methodDefinition = node.parent;
+  if (methodDefinition?.type === "MethodDefinition") {
+    const classBody = methodDefinition.parent;
+    const classNode = classBody?.parent;
+    if (!classNode) {
+      return false;
+    }
+    const classParent = classNode.parent;
+    return classParent?.type === "ExportNamedDeclaration" || classParent?.type === "ExportDefaultDeclaration";
+  }
+  if (node.type === "FunctionDeclaration") {
+    const parentNode = node.parent;
+    return parentNode?.type === "ExportNamedDeclaration" || parentNode?.type === "ExportDefaultDeclaration";
+  }
+  if (node.parent?.type === "VariableDeclarator") {
+    const variableDeclaration = node.parent.parent;
+    if (variableDeclaration?.parent?.type === "ExportNamedDeclaration") {
+      return true;
+    }
+  }
+  return false;
+}
+function isOptionalParameter(parameter) {
+  return parameter.type === "AssignmentPattern" || parameter.optional === true;
+}
+function toPascalCase(name) {
+  return name.charAt(0).toUpperCase() + name.slice(1);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  paramsOptionsNameMatch
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/params-options-name-match.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: params-options-name-match\n *\n * Ensures that parameter-bag type names match the function or constructor they\n * belong to, on two axes \u2014 a prefix derived from the owner and a suffix derived\n * from how the bag is passed.\n *\n * Prefix (owner):\n * - `fooBar(params: FooBar\u2026)` \u2014 PascalCase of the function name\n * - `class Baz { constructor(params: BazConstructor\u2026) }` \u2014 ClassName + `Constructor`\n * - `class Baz { method(params: BazMethod\u2026) }` \u2014 ClassName + PascalCase(methodName)\n *\n * Suffix (whether the bag is a required sole argument):\n * - `Params` only when the bag is the SOLE and REQUIRED parameter \u2014\n *   `fooBar(params: FooBarParams)`\n * - `Options` otherwise. That is: an OPTIONAL bag \u2014 `fooBar(options?: FooBarOptions)`\n *   or `fooBar(options: FooBarOptions = {})` \u2014 or a bag SUPPLEMENTARY to other\n *   parameters \u2014 `fooBar(baz: string, options: FooBarOptions)`.\n *\n * Only checks parameters whose type annotation name ends with `Params` or\n * `Options`. Only checks exported functions and members of exported classes\n * (regardless of accessibility \u2014 `public`, `protected`, and `private` are all\n * checked) to avoid false positives from internal options-passthrough helpers.\n */\n\n/* eslint-disable @typescript-eslint/no-unnecessary-condition -- Rule.Node parent/property types are wider than what the type checker infers; defensive checks are appropriate for AST traversal. */\n\nimport type { Rule } from 'eslint';\n\nconst PARAMS_OPTIONS_SUFFIX_PATTERN = /(?:Params|Options)$/;\nconst PARAMS_SUFFIX = 'Params';\nconst OPTIONS_SUFFIX = 'Options';\n\n/**\nMessage ID reported when a parameter-bag type's name does not match the expected name (prefix and required/optional suffix) for its function or constructor.\n */\nexport const MESSAGE_ID = 'paramsOptionsNameMatch';\n\ninterface FunctionNodeWithParams {\n  readonly params: Rule.Node[];\n}\n\ninterface MaybeOptionalNode {\n  readonly optional?: boolean;\n}\n\ninterface TypeAnnotationInfo {\n  readonly name: string;\n  readonly node: Rule.Node;\n}\n\n/**\n * ESLint rule requiring `*Params`/`*Options` type names to match their owning function or constructor, and to use the suffix that matches the sole-vs-supplementary argument convention.\n */\nexport const paramsOptionsNameMatch: Rule.RuleModule = {\n  create(context) {\n    return {\n      ':function[params.length>0]'(node: Rule.Node): void {\n        if (!isInExportedScope(node)) {\n          return;\n        }\n\n        const functionNode = node as FunctionNodeWithParams & Rule.Node;\n        const expectedPrefix = getExpectedPrefix(node);\n        if (!expectedPrefix) {\n          return;\n        }\n\n        const isSoleParameter = functionNode.params.length === 1;\n\n        for (const parameter of functionNode.params) {\n          const typeInfo = getTypeAnnotationInfo(parameter);\n          if (!typeInfo || !PARAMS_OPTIONS_SUFFIX_PATTERN.test(typeInfo.name)) {\n            continue;\n          }\n\n          // A required sole-argument bag \u2192 `*Params`. An optional bag (`?` or a default\n          // value) or a bag supplementary to other parameters \u2192 `*Options`.\n          const expectedSuffix = isSoleParameter && !isOptionalParameter(parameter) ? PARAMS_SUFFIX : OPTIONS_SUFFIX;\n          const expectedName = `${expectedPrefix}${expectedSuffix}`;\n\n          if (typeInfo.name !== expectedName) {\n            context.report({\n              data: {\n                actualName: typeInfo.name,\n                expectedName\n              },\n              messageId: MESSAGE_ID,\n              node: typeInfo.node\n            });\n          }\n        }\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require `*Params`/`*Options` type names to match the owning function/constructor (prefix) and the sole-vs-supplementary argument convention (suffix)'\n    },\n    messages: {\n      [MESSAGE_ID]: 'Type \"{{ actualName }}\" does not match the expected name \"{{ expectedName }}\" for this function/constructor.'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\nfunction getClassName(methodDefinition: Rule.Node): string | undefined {\n  const classBody = methodDefinition.parent;\n  const classNode = classBody?.parent;\n  return !classNode || !('id' in classNode) || !classNode.id || typeof classNode.id !== 'object' || !('name' in classNode.id)\n      || typeof classNode.id.name !== 'string'\n    ? undefined\n    : classNode.id.name;\n}\n\nfunction getExpectedPrefix(node: Rule.Node): string | undefined {\n  const methodPrefix = getMethodExpectedPrefix(node);\n  return methodPrefix ?? getFunctionExpectedPrefix(node);\n}\n\nfunction getFunctionExpectedPrefix(node: Rule.Node): string | undefined {\n  // Named function declaration: function fooBar(params: FooBarParams)\n  if ('id' in node && node.id && typeof node.id === 'object' && 'name' in node.id && typeof node.id.name === 'string') {\n    return toPascalCase(node.id.name);\n  }\n\n  // Arrow function assigned to a variable: const fooBar = (params: FooBarParams) => ...\n  return node.parent?.type === 'VariableDeclarator' && 'id' in node.parent && node.parent.id && typeof node.parent.id === 'object' && 'name' in node.parent.id\n      && typeof node.parent.id.name === 'string'\n    ? toPascalCase(node.parent.id.name)\n    : undefined;\n}\n\nfunction getMethodExpectedPrefix(node: Rule.Node): string | undefined {\n  const methodDefinition = node.parent;\n  if (methodDefinition?.type !== 'MethodDefinition') {\n    return undefined;\n  }\n\n  /* v8 ignore start -- Defensive guard: ESLint AST MethodDefinition always has a named key. */\n  if (\n    !('key' in methodDefinition) || !methodDefinition.key || typeof methodDefinition.key !== 'object' || !('name' in methodDefinition.key) || typeof methodDefinition.key.name !== 'string'\n  ) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const methodName = methodDefinition.key.name;\n  const className = getClassName(methodDefinition);\n  if (!className) {\n    return undefined;\n  }\n\n  return methodName === 'constructor' ? `${className}Constructor` : className + toPascalCase(methodName);\n}\n\nfunction getTypeAnnotationInfo(parameter: Rule.Node): TypeAnnotationInfo | undefined {\n  // Unwrap a defaulted parameter such as `options: FooOptions = {}`.\n  // Its type annotation lives on the AssignmentPattern's left-hand binding.\n  const target = parameter.type === 'AssignmentPattern' ? parameter.left : parameter;\n\n  /* v8 ignore start -- Defensive guard: TypeScript-parsed params always have typeAnnotation when typed. */\n  if (!('typeAnnotation' in target) || !target.typeAnnotation) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const annotation = target.typeAnnotation as Record<string, unknown>;\n  const typeNode = annotation['typeAnnotation'];\n  /* v8 ignore start -- Defensive guard: the TypeScript parser always produces an AST node for typeAnnotation. */\n  if (!typeNode || typeof typeNode !== 'object') {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const typeNodeObject = typeNode as Record<string, unknown>;\n\n  // Direct reference: FooBarParams\n  if (typeNodeObject['type'] === 'TSTypeReference' && typeNodeObject['typeName'] && typeof typeNodeObject['typeName'] === 'object') {\n    const typeName = typeNodeObject['typeName'] as Record<string, unknown>;\n    /* v8 ignore start -- Defensive guard: TSTypeReference typeName is always an Identifier with a string name. */\n    if (typeName['type'] === 'Identifier' && typeof typeName['name'] === 'string') {\n      /* v8 ignore stop */\n      return { name: typeName['name'], node: typeNode as Rule.Node };\n    }\n  }\n\n  return undefined;\n}\n\nfunction isInExportedScope(node: Rule.Node): boolean {\n  // Class method or constructor: check that the class is exported, regardless of accessibility\n  // (public/protected/private members are all checked).\n  const methodDefinition = node.parent;\n  if (methodDefinition?.type === 'MethodDefinition') {\n    // Check if the class itself is exported\n    const classBody = methodDefinition.parent;\n    const classNode = classBody?.parent;\n    /* v8 ignore start -- Defensive guard: ESLint AST always has parent chain for class methods. */\n    if (!classNode) {\n      return false;\n    }\n    /* v8 ignore stop */\n    const classParent = classNode.parent;\n    return classParent?.type === 'ExportNamedDeclaration' || classParent?.type === 'ExportDefaultDeclaration';\n  }\n\n  // Top-level function: check if exported\n  if (node.type === 'FunctionDeclaration') {\n    const parentNode = node.parent;\n    return parentNode?.type === 'ExportNamedDeclaration' || parentNode?.type === 'ExportDefaultDeclaration';\n  }\n\n  // Arrow function in variable: check if the variable declaration is exported\n  if (node.parent?.type === 'VariableDeclarator') {\n    const variableDeclaration = node.parent.parent;\n    if (variableDeclaration?.parent?.type === 'ExportNamedDeclaration') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction isOptionalParameter(parameter: Rule.Node): boolean {\n  // `options: FooOptions = {}` is an AssignmentPattern; `options?: FooOptions` carries an\n  // `optional` flag. Both make the bag optional \u2192 `*Options`.\n  return parameter.type === 'AssignmentPattern' || (parameter as MaybeOptionalNode).optional === true;\n}\n\nfunction toPascalCase(name: string): string {\n  return name.charAt(0).toUpperCase() + name.slice(1);\n}\n\n/* eslint-enable @typescript-eslint/no-unnecessary-condition -- Re-enable after AST traversal code, which is now the whole file: the prefix helpers moved to module scope and walk the same optional-parent chain. */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/linters/eslint-rules/params-options-name-match.d.cts

@@ -0,0 +1,36 @@
+/// <reference path="../../library-references.d.cts" />
+/**
+ * @file
+ *
+ * ESLint rule: params-options-name-match
+ *
+ * Ensures that parameter-bag type names match the function or constructor they
+ * belong to, on two axes — a prefix derived from the owner and a suffix derived
+ * from how the bag is passed.
+ *
+ * Prefix (owner):
+ * - `fooBar(params: FooBar…)` — PascalCase of the function name
+ * - `class Baz { constructor(params: BazConstructor…) }` — ClassName + `Constructor`
+ * - `class Baz { method(params: BazMethod…) }` — ClassName + PascalCase(methodName)
+ *
+ * Suffix (whether the bag is a required sole argument):
+ * - `Params` only when the bag is the SOLE and REQUIRED parameter —
+ *   `fooBar(params: FooBarParams)`
+ * - `Options` otherwise. That is: an OPTIONAL bag — `fooBar(options?: FooBarOptions)`
+ *   or `fooBar(options: FooBarOptions = {})` — or a bag SUPPLEMENTARY to other
+ *   parameters — `fooBar(baz: string, options: FooBarOptions)`.
+ *
+ * Only checks parameters whose type annotation name ends with `Params` or
+ * `Options`. Only checks exported functions and members of exported classes
+ * (regardless of accessibility — `public`, `protected`, and `private` are all
+ * checked) to avoid false positives from internal options-passthrough helpers.
+ */
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+Message ID reported when a parameter-bag type's name does not match the expected name (prefix and required/optional suffix) for its function or constructor.
+ */
+export declare const MESSAGE_ID = "paramsOptionsNameMatch";
+/**
+ * ESLint rule requiring `*Params`/`*Options` type names to match their owning function or constructor, and to use the suffix that matches the sole-vs-supplementary argument convention.
+ */
+export declare const paramsOptionsNameMatch: Rule.RuleModule;

package/dist/lib/cjs/linters/eslint-rules/prefer-noop-async.cjs

@@ -0,0 +1,126 @@
+/*
+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 prefer_noop_async_exports = {};
+__export(prefer_noop_async_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  preferNoopAsync: () => preferNoopAsync
+});
+module.exports = __toCommonJS(prefer_noop_async_exports);
+var import_ts_estree_node = require('./ts-estree-node.cjs');
+const MESSAGE_ID = "preferNoopAsync";
+const preferNoopAsync = {
+  create(context) {
+    return {
+      "CallExpression"(node) {
+        const callNode = (0, import_ts_estree_node.toTSESTreeNode)(node);
+        if (!isPromiseResolveWithNoArguments(callNode)) {
+          return;
+        }
+        context.report({
+          fix(fixer) {
+            return fixer.replaceText(node, "noopAsync()");
+          },
+          messageId: MESSAGE_ID,
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Prefer `noopAsync()` over `Promise.resolve()`"
+    },
+    fixable: "code",
+    messages: {
+      [MESSAGE_ID]: "Use `noopAsync()` instead of `Promise.resolve()` for async no-ops."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function isPromiseResolveWithNoArguments(node) {
+  const callee = node.callee;
+  return node.arguments.length === 0 && callee.type === "MemberExpression" && callee.object.type === "Identifier" && callee.object.name === "Promise" && callee.property.type === "Identifier" && callee.property.name === "resolve";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  preferNoopAsync
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/eslint-rules/prefer-noop-async.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 `Promise.resolve()` is used for an async no-op instead of `noopAsync()`.
+ */
+export declare const MESSAGE_ID = "preferNoopAsync";
+/**
+ * ESLint rule preferring `noopAsync()` over `Promise.resolve()` for an async no-op.
+ */
+export declare const preferNoopAsync: Rule.RuleModule;

package/dist/lib/cjs/linters/eslint-rules/readonly-params-options-result-members.cjs

@@ -0,0 +1,125 @@
+/*
+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 readonly_params_options_result_members_exports = {};
+__export(readonly_params_options_result_members_exports, {
+  MESSAGE_ID: () => MESSAGE_ID,
+  readonlyParamsOptionsResultMembers: () => readonlyParamsOptionsResultMembers
+});
+module.exports = __toCommonJS(readonly_params_options_result_members_exports);
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+const MESSAGE_ID = "readonlyParamsOptionsResultMembers";
+const readonlyParamsOptionsResultMembers = {
+  create(context) {
+    return {
+      "TSInterfaceDeclaration[id.name=/(?:Params|Options|Result)$/] TSPropertySignature[readonly=false]"(node) {
+        reportNonReadonly(context, node);
+      },
+      "TSTypeAliasDeclaration[id.name=/(?:Params|Options|Result)$/] TSPropertySignature[readonly=false]"(node) {
+        reportNonReadonly(context, node);
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require all properties in `*Params`, `*Options`, and `*Result` interfaces to be `readonly`"
+    },
+    fixable: "code",
+    messages: {
+      [MESSAGE_ID]: "Property must be `readonly`. Params/Options/Result interfaces should be immutable."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function reportNonReadonly($context, node) {
+  const propertyNode = node;
+  $context.report({
+    fix(fixer) {
+      return fixer.insertTextBefore((0, import_type_guards.ensureNonNullable)(propertyNode.key), "readonly ");
+    },
+    messageId: MESSAGE_ID,
+    node
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MESSAGE_ID,
+  readonlyParamsOptionsResultMembers
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/linters/eslint-rules/readonly-params-options-result-members.d.cts

@@ -0,0 +1,20 @@
+/// <reference path="../../library-references.d.cts" />
+/**
+ * @file
+ *
+ * ESLint rule: readonly-params-options-result-members
+ *
+ * Reports an error when an interface or type alias whose name ends with
+ * `Params`, `Options`, or `Result` has a property signature that is not
+ * `readonly`. Parameter/options/result bags should be immutable — callers
+ * should never mutate the object they received.
+ */
+import type { Rule } from 'eslint' with { 'resolution-mode': 'import' };
+/**
+Message ID reported when a member of a `*Params`/`*Options`/`*Result` interface is not declared `readonly`.
+ */
+export declare const MESSAGE_ID = "readonlyParamsOptionsResultMembers";
+/**
+ * ESLint rule requiring every property of a `*Params`, `*Options`, or `*Result` interface to be `readonly`.
+ */
+export declare const readonlyParamsOptionsResultMembers: Rule.RuleModule;