@mnaoumov/typescript-dev-toolkit 5.0.0 → 5.2.0

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

@@ -9,9 +9,11 @@ import { noUnresolvedJsdocLink } from "./no-unresolved-jsdoc-link.mjs";
 import { noUnusedParamsMembers } from "./no-unused-params-members.mjs";
 import { noUsedUnderscoreVariables } from "./no-used-underscore-variables.mjs";
 import { paramsOptionsNameMatch } from "./params-options-name-match.mjs";
+import { preferDedent } from "./prefer-dedent.mjs";
 import { preferLogicalOperatorOverTernary } from "./prefer-logical-operator-over-ternary.mjs";
 import { preferNoopAsync } from "./prefer-noop-async.mjs";
 import { readonlyInterfaceMembers } from "./readonly-interface-members.mjs";
+import { readonlyMemberArrays } from "./readonly-member-arrays.mjs";
 import { requireMethodTemplate } from "./require-method-template.mjs";
 import { requireSuperCall } from "./require-super-call.mjs";
 const IN_HOUSE_ESLINT_PLUGIN_NAME = "typescript-dev-toolkit";
@@ -22,9 +24,11 @@ const genericInHouseEslintRules = {
   "no-unused-params-members": noUnusedParamsMembers,
   "no-used-underscore-variables": noUsedUnderscoreVariables,
   "params-options-name-match": paramsOptionsNameMatch,
+  "prefer-dedent": preferDedent,
   "prefer-logical-operator-over-ternary": preferLogicalOperatorOverTernary,
   "prefer-noop-async": preferNoopAsync,
   "readonly-interface-members": readonlyInterfaceMembers,
+  "readonly-member-arrays": readonlyMemberArrays,
   "require-method-template": requireMethodTemplate,
   "require-super-call": requireSuperCall
 };
@@ -36,4 +40,4 @@ export {
   genericInHouseEslintRules,
   inHouseEslintPlugin
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,4 +1,5 @@
 /// <reference path="../../library-references.d.mts" />
+export * as 'import-fix' from './import-fix.mjs';
 export * as 'in-house-plugin' from './in-house-plugin.mjs';
 export * as 'no-async-callback-to-unsafe-return' from './no-async-callback-to-unsafe-return.mjs';
 export * as 'no-keyword-identifiers' from './no-keyword-identifiers.mjs';
@@ -6,9 +7,11 @@ export * as 'no-unresolved-jsdoc-link' from './no-unresolved-jsdoc-link.mjs';
 export * as 'no-unused-params-members' from './no-unused-params-members.mjs';
 export * as 'no-used-underscore-variables' from './no-used-underscore-variables.mjs';
 export * as 'params-options-name-match' from './params-options-name-match.mjs';
+export * as 'prefer-dedent' from './prefer-dedent.mjs';
 export * as 'prefer-logical-operator-over-ternary' from './prefer-logical-operator-over-ternary.mjs';
 export * as 'prefer-noop-async' from './prefer-noop-async.mjs';
 export * as 'readonly-interface-members' from './readonly-interface-members.mjs';
+export * as 'readonly-member-arrays' from './readonly-member-arrays.mjs';
 export * as 'require-method-template' from './require-method-template.mjs';
 export * as 'require-super-call' from './require-super-call.mjs';
 export * as 'rule-tester-helper' from './rule-tester-helper.mjs';

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

@@ -3,6 +3,7 @@ THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
 
+import * as import_fix from "./import-fix.mjs";
 import * as in_house_plugin from "./in-house-plugin.mjs";
 import * as no_async_callback_to_unsafe_return from "./no-async-callback-to-unsafe-return.mjs";
 import * as no_keyword_identifiers from "./no-keyword-identifiers.mjs";
@@ -10,14 +11,17 @@ import * as no_unresolved_jsdoc_link from "./no-unresolved-jsdoc-link.mjs";
 import * as no_unused_params_members from "./no-unused-params-members.mjs";
 import * as no_used_underscore_variables from "./no-used-underscore-variables.mjs";
 import * as params_options_name_match from "./params-options-name-match.mjs";
+import * as prefer_dedent from "./prefer-dedent.mjs";
 import * as prefer_logical_operator_over_ternary from "./prefer-logical-operator-over-ternary.mjs";
 import * as prefer_noop_async from "./prefer-noop-async.mjs";
 import * as readonly_interface_members from "./readonly-interface-members.mjs";
+import * as readonly_member_arrays from "./readonly-member-arrays.mjs";
 import * as require_method_template from "./require-method-template.mjs";
 import * as require_super_call from "./require-super-call.mjs";
 import * as rule_tester_helper from "./rule-tester-helper.mjs";
 import * as ts_estree_node from "./ts-estree-node.mjs";
 export {
+  import_fix as "import-fix",
   in_house_plugin as "in-house-plugin",
   no_async_callback_to_unsafe_return as "no-async-callback-to-unsafe-return",
   no_keyword_identifiers as "no-keyword-identifiers",
@@ -25,12 +29,14 @@ export {
   no_unused_params_members as "no-unused-params-members",
   no_used_underscore_variables as "no-used-underscore-variables",
   params_options_name_match as "params-options-name-match",
+  prefer_dedent as "prefer-dedent",
   prefer_logical_operator_over_ternary as "prefer-logical-operator-over-ternary",
   prefer_noop_async as "prefer-noop-async",
   readonly_interface_members as "readonly-interface-members",
+  readonly_member_arrays as "readonly-member-arrays",
   require_method_template as "require-method-template",
   require_super_call as "require-super-call",
   rule_tester_helper as "rule-tester-helper",
   ts_estree_node as "ts-estree-node"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LXJ1bGVzL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKiBUSElTIElTIEEgR0VORVJBVEVEL0JVTkRMRUQgRklMRSBCWSBCVUlMRCBTQ1JJUFQgKi9cblxuZXhwb3J0ICogYXMgJ2ltcG9ydC1maXgnIGZyb20gJy4vaW1wb3J0LWZpeC50cyc7XG5leHBvcnQgKiBhcyAnaW4taG91c2UtcGx1Z2luJyBmcm9tICcuL2luLWhvdXNlLXBsdWdpbi50cyc7XG5leHBvcnQgKiBhcyAnbm8tYXN5bmMtY2FsbGJhY2stdG8tdW5zYWZlLXJldHVybicgZnJvbSAnLi9uby1hc3luYy1jYWxsYmFjay10by11bnNhZmUtcmV0dXJuLnRzJztcbmV4cG9ydCAqIGFzICduby1rZXl3b3JkLWlkZW50aWZpZXJzJyBmcm9tICcuL25vLWtleXdvcmQtaWRlbnRpZmllcnMudHMnO1xuZXhwb3J0ICogYXMgJ25vLXVucmVzb2x2ZWQtanNkb2MtbGluaycgZnJvbSAnLi9uby11bnJlc29sdmVkLWpzZG9jLWxpbmsudHMnO1xuZXhwb3J0ICogYXMgJ25vLXVudXNlZC1wYXJhbXMtbWVtYmVycycgZnJvbSAnLi9uby11bnVzZWQtcGFyYW1zLW1lbWJlcnMudHMnO1xuZXhwb3J0ICogYXMgJ25vLXVzZWQtdW5kZXJzY29yZS12YXJpYWJsZXMnIGZyb20gJy4vbm8tdXNlZC11bmRlcnNjb3JlLXZhcmlhYmxlcy50cyc7XG5leHBvcnQgKiBhcyAncGFyYW1zLW9wdGlvbnMtbmFtZS1tYXRjaCcgZnJvbSAnLi9wYXJhbXMtb3B0aW9ucy1uYW1lLW1hdGNoLnRzJztcbmV4cG9ydCAqIGFzICdwcmVmZXItZGVkZW50JyBmcm9tICcuL3ByZWZlci1kZWRlbnQudHMnO1xuZXhwb3J0ICogYXMgJ3ByZWZlci1sb2dpY2FsLW9wZXJhdG9yLW92ZXItdGVybmFyeScgZnJvbSAnLi9wcmVmZXItbG9naWNhbC1vcGVyYXRvci1vdmVyLXRlcm5hcnkudHMnO1xuZXhwb3J0ICogYXMgJ3ByZWZlci1ub29wLWFzeW5jJyBmcm9tICcuL3ByZWZlci1ub29wLWFzeW5jLnRzJztcbmV4cG9ydCAqIGFzICdyZWFkb25seS1pbnRlcmZhY2UtbWVtYmVycycgZnJvbSAnLi9yZWFkb25seS1pbnRlcmZhY2UtbWVtYmVycy50cyc7XG5leHBvcnQgKiBhcyAncmVhZG9ubHktbWVtYmVyLWFycmF5cycgZnJvbSAnLi9yZWFkb25seS1tZW1iZXItYXJyYXlzLnRzJztcbmV4cG9ydCAqIGFzICdyZXF1aXJlLW1ldGhvZC10ZW1wbGF0ZScgZnJvbSAnLi9yZXF1aXJlLW1ldGhvZC10ZW1wbGF0ZS50cyc7XG5leHBvcnQgKiBhcyAncmVxdWlyZS1zdXBlci1jYWxsJyBmcm9tICcuL3JlcXVpcmUtc3VwZXItY2FsbC50cyc7XG5leHBvcnQgKiBhcyAncnVsZS10ZXN0ZXItaGVscGVyJyBmcm9tICcuL3J1bGUtdGVzdGVyLWhlbHBlci50cyc7XG5leHBvcnQgKiBhcyAndHMtZXN0cmVlLW5vZGUnIGZyb20gJy4vdHMtZXN0cmVlLW5vZGUudHMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFFQSxZQUFZQSxnQkFBa0I7QUFDOUIsWUFBWUMscUJBQXVCO0FBQ25DLFlBQVlDLHdDQUEwQztBQUN0RCxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMsOEJBQWdDO0FBQzVDLFlBQVlDLDhCQUFnQztBQUM1QyxZQUFZQyxrQ0FBb0M7QUFDaEQsWUFBWUMsK0JBQWlDO0FBQzdDLFlBQVlDLG1CQUFxQjtBQUNqQyxZQUFZQywwQ0FBNEM7QUFDeEQsWUFBWUMsdUJBQXlCO0FBQ3JDLFlBQVlDLGdDQUFrQztBQUM5QyxZQUFZQyw0QkFBOEI7QUFDMUMsWUFBWUMsNkJBQStCO0FBQzNDLFlBQVlDLHdCQUEwQjtBQUN0QyxZQUFZQyx3QkFBMEI7QUFDdEMsWUFBWUMsb0JBQXNCOyIsCiAgIm5hbWVzIjogWyJpbXBvcnQtZml4IiwgImluLWhvdXNlLXBsdWdpbiIsICJuby1hc3luYy1jYWxsYmFjay10by11bnNhZmUtcmV0dXJuIiwgIm5vLWtleXdvcmQtaWRlbnRpZmllcnMiLCAibm8tdW5yZXNvbHZlZC1qc2RvYy1saW5rIiwgIm5vLXVudXNlZC1wYXJhbXMtbWVtYmVycyIsICJuby11c2VkLXVuZGVyc2NvcmUtdmFyaWFibGVzIiwgInBhcmFtcy1vcHRpb25zLW5hbWUtbWF0Y2giLCAicHJlZmVyLWRlZGVudCIsICJwcmVmZXItbG9naWNhbC1vcGVyYXRvci1vdmVyLXRlcm5hcnkiLCAicHJlZmVyLW5vb3AtYXN5bmMiLCAicmVhZG9ubHktaW50ZXJmYWNlLW1lbWJlcnMiLCAicmVhZG9ubHktbWVtYmVyLWFycmF5cyIsICJyZXF1aXJlLW1ldGhvZC10ZW1wbGF0ZSIsICJyZXF1aXJlLXN1cGVyLWNhbGwiLCAicnVsZS10ZXN0ZXItaGVscGVyIiwgInRzLWVzdHJlZS1ub2RlIl0KfQo=

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

@@ -0,0 +1,10 @@
+/// <reference path="../../library-references.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * Message ID reported when an array of string literals is joined with a newline instead of written as a `dedent` template.
+ */
+export declare const MESSAGE_ID = "preferDedent";
+/**
+ * ESLint rule preferring a `dedent` template over an array of string literals joined with a newline.
+ */
+export declare const preferDedent: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/prefer-dedent.mjs

@@ -0,0 +1,168 @@
+/*
+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 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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import {
+  findVisibleImportName,
+  getUnusedName,
+  insertImport
+} from "./import-fix.mjs";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const DEDENT_MODULE = "dedent";
+const INDENT = "  ";
+const LINE_BREAK_SEPARATORS = /* @__PURE__ */ new Set(["\n", "\r\n"]);
+const MINIMUM_ELEMENTS_WITH_A_LINE_BREAK = 2;
+const MESSAGE_ID = "preferDedent";
+const preferDedent = {
+  create(context) {
+    return {
+      "CallExpression"(node) {
+        const callNode = toTSESTreeNode(node);
+        const joined = getJoinedStringElements(callNode);
+        if (!joined) {
+          return;
+        }
+        context.report({
+          fix(fixer) {
+            const sourceCode = context.sourceCode;
+            if (sourceCode.getCommentsInside(node).length > 0) {
+              return null;
+            }
+            const text = getJoinedText(joined.elements, joined.separator);
+            const lines = text === null ? null : toDedentLines(text);
+            if (lines === null) {
+              return null;
+            }
+            const fixes = [];
+            let name = findVisibleImportName({ importedName: "default", moduleName: DEDENT_MODULE, node, sourceCode });
+            if (name === null) {
+              if (sourceCode.ast.sourceType !== "module") {
+                return null;
+              }
+              name = getUnusedName(sourceCode, "dedent");
+              fixes.push(insertImport(fixer, sourceCode, `import ${name} from '${DEDENT_MODULE}';`));
+            }
+            const linePrefix = sourceCode.text.slice(sourceCode.getIndexFromLoc({ column: 0, line: callNode.loc.start.line }), callNode.range[0]);
+            const lineIndent = linePrefix.slice(0, linePrefix.length - linePrefix.trimStart().length);
+            const body = lines.map((line) => line === "" ? "" : `${lineIndent}${INDENT}${line}`).join("\n");
+            fixes.push(fixer.replaceText(node, `${name}\`
+${body}
+${lineIndent}\``));
+            return fixes;
+          },
+          messageId: MESSAGE_ID,
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Prefer a `dedent` template over an array of string literals joined with a newline"
+    },
+    fixable: "code",
+    messages: {
+      [MESSAGE_ID]: "Write this multiline string as a `dedent` template instead of joining an array of string literals with a newline."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+function escapeLineBreaks(text) {
+  return text.replaceAll("\r", String.raw`\r`).replaceAll("\n", String.raw`\n`);
+}
+function escapeTemplateText(text) {
+  return text.replaceAll("`", "\\`").replaceAll("${", "\\${").replaceAll("\r", String.raw`\r`);
+}
+function getJoinedStringElements(node) {
+  const callee = node.callee;
+  if (node.optional || node.arguments.length !== 1 || callee.type !== AST_NODE_TYPES.MemberExpression || callee.optional || callee.computed || callee.property.type !== AST_NODE_TYPES.Identifier || callee.property.name !== "join" || callee.object.type !== AST_NODE_TYPES.ArrayExpression) {
+    return null;
+  }
+  const separator = getStaticString(ensureNonNullable(node.arguments[0]));
+  if (separator === null || !LINE_BREAK_SEPARATORS.has(separator)) {
+    return null;
+  }
+  const elements = [];
+  for (const element of callee.object.elements) {
+    if (!isStringElement(element)) {
+      return null;
+    }
+    elements.push(element);
+  }
+  return elements.length < MINIMUM_ELEMENTS_WITH_A_LINE_BREAK ? null : { elements, separator };
+}
+function getJoinedText(elements, separator) {
+  const values = [];
+  for (const element of elements) {
+    const value = getStaticString(element);
+    if (value === null) {
+      return null;
+    }
+    values.push(value);
+  }
+  return values.join(separator);
+}
+function getStaticString(node) {
+  if (node.type === AST_NODE_TYPES.Literal) {
+    return typeof node.value === "string" ? node.value : null;
+  }
+  return node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? ensureNonNullable(node.quasis[0]).value.cooked : null;
+}
+function isStringElement(element) {
+  return element?.type === AST_NODE_TYPES.TemplateLiteral || element?.type === AST_NODE_TYPES.Literal && typeof element.value === "string";
+}
+function toDedentLines(text) {
+  if (text.includes("\\")) {
+    return null;
+  }
+  const rest = text.replace(/^[\r\n]+/, "");
+  const leading = text.slice(0, text.length - rest.length);
+  const core = rest.replace(/[\r\n]+$/, "");
+  const trailing = rest.slice(core.length);
+  if (core === "" || leading === "" && /^\s/.test(core) || trailing === "" && /\s$/.test(core)) {
+    return null;
+  }
+  return `${escapeLineBreaks(leading)}${escapeTemplateText(core)}${escapeLineBreaks(trailing)}`.split("\n");
+}
+export {
+  MESSAGE_ID,
+  preferDedent
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../../src/linters/eslint-rules/prefer-dedent.ts"],"sourcesContent":["/**\n * @file\n *\n * ESLint rule: prefer-dedent\n *\n * Reports an array of string literals joined with a newline (`['a', 'b'].join('\\n')`) and fixes it to a `dedent`\n * template. An array holding anything but string and template literals is left alone: it builds a string at runtime.\n *\n * The fix rewrites the joined text so that `dedent` (1.x, used as a tag) returns exactly the same string. It runs the\n * same steps `dedent` does in reverse: a leading or trailing run of line breaks and every carriage return become\n * `\\n` / `\\r` escapes, which `dedent` decodes only after it trims, and backticks and `${` are escaped. Text it cannot\n * represent that way keeps the diagnostic without a fix: a backslash, which `dedent` passes on raw; leading or trailing\n * whitespace that `dedent` would trim; a template literal with expressions, whose values are unknown; and comments\n * inside the call. The fix reuses a visible default import of `dedent`, or adds one under a free name.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\nimport { AST_NODE_TYPES } from '@typescript-eslint/utils';\n\nimport {\n  findVisibleImportName,\n  getUnusedName,\n  insertImport\n} from './import-fix.ts';\nimport { toTSESTreeNode } from './ts-estree-node.ts';\n\nconst DEDENT_MODULE = 'dedent';\nconst INDENT = '  ';\nconst LINE_BREAK_SEPARATORS = new Set(['\\n', '\\r\\n']);\nconst MINIMUM_ELEMENTS_WITH_A_LINE_BREAK = 2;\n\n/**\n * Message ID reported when an array of string literals is joined with a newline instead of written as a `dedent` template.\n */\nexport const MESSAGE_ID = 'preferDedent';\n\ntype StringElement = TSESTree.StringLiteral | TSESTree.TemplateLiteral;\n\n/**\n * ESLint rule preferring a `dedent` template over an array of string literals joined with a newline.\n */\nexport const preferDedent: Rule.RuleModule = {\n  create(context) {\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n        const joined = getJoinedStringElements(callNode);\n        if (!joined) {\n          return;\n        }\n\n        context.report({\n          fix(fixer) {\n            const sourceCode = context.sourceCode;\n            if (sourceCode.getCommentsInside(node).length > 0) {\n              return null;\n            }\n            const text = getJoinedText(joined.elements, joined.separator);\n            const lines = text === null ? null : toDedentLines(text);\n            if (lines === null) {\n              return null;\n            }\n\n            const fixes: Rule.Fix[] = [];\n            let name = findVisibleImportName({ importedName: 'default', moduleName: DEDENT_MODULE, node, sourceCode });\n            if (name === null) {\n              // A script cannot accept an ESM import. Leave its diagnostic for a manual edit.\n              if (sourceCode.ast.sourceType !== 'module') {\n                return null;\n              }\n              name = getUnusedName(sourceCode, 'dedent');\n              fixes.push(insertImport(fixer, sourceCode, `import ${name} from '${DEDENT_MODULE}';`));\n            }\n\n            const linePrefix = sourceCode.text.slice(sourceCode.getIndexFromLoc({ column: 0, line: callNode.loc.start.line }), callNode.range[0]);\n            const lineIndent = linePrefix.slice(0, linePrefix.length - linePrefix.trimStart().length);\n            const body = lines.map((line) => line === '' ? '' : `${lineIndent}${INDENT}${line}`).join('\\n');\n            fixes.push(fixer.replaceText(node, `${name}\\`\\n${body}\\n${lineIndent}\\``));\n            return fixes;\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Prefer a `dedent` template over an array of string literals joined with a newline'\n    },\n    fixable: 'code',\n    messages: {\n      [MESSAGE_ID]: 'Write this multiline string as a `dedent` template instead of joining an array of string literals with a newline.'\n    },\n    schema: [],\n    type: 'suggestion'\n  }\n};\n\ninterface JoinedStringElements {\n  readonly elements: readonly StringElement[];\n  readonly separator: string;\n}\n\nfunction escapeLineBreaks(text: string): string {\n  return text.replaceAll('\\r', String.raw`\\r`).replaceAll('\\n', String.raw`\\n`);\n}\n\nfunction escapeTemplateText(text: string): string {\n  return text.replaceAll('`', '\\\\`').replaceAll('${', '\\\\${').replaceAll('\\r', String.raw`\\r`);\n}\n\nfunction getJoinedStringElements(node: TSESTree.CallExpression): JoinedStringElements | null {\n  const callee = node.callee;\n  if (\n    node.optional || node.arguments.length !== 1\n    || callee.type !== AST_NODE_TYPES.MemberExpression || callee.optional || callee.computed\n    || callee.property.type !== AST_NODE_TYPES.Identifier || callee.property.name !== 'join'\n    || callee.object.type !== AST_NODE_TYPES.ArrayExpression\n  ) {\n    return null;\n  }\n\n  const separator = getStaticString(ensureNonNullable(node.arguments[0]));\n  if (separator === null || !LINE_BREAK_SEPARATORS.has(separator)) {\n    return null;\n  }\n\n  const elements: StringElement[] = [];\n  for (const element of callee.object.elements) {\n    if (!isStringElement(element)) {\n      return null;\n    }\n    elements.push(element);\n  }\n  // A single element joins to itself; there is no line break to rewrite.\n  return elements.length < MINIMUM_ELEMENTS_WITH_A_LINE_BREAK ? null : { elements, separator };\n}\n\nfunction getJoinedText(elements: readonly StringElement[], separator: string): null | string {\n  const values: string[] = [];\n  for (const element of elements) {\n    const value = getStaticString(element);\n    if (value === null) {\n      return null;\n    }\n    values.push(value);\n  }\n  return values.join(separator);\n}\n\nfunction getStaticString(node: TSESTree.Node): null | string {\n  if (node.type === AST_NODE_TYPES.Literal) {\n    return typeof node.value === 'string' ? node.value : null;\n  }\n  // An untagged template with an invalid escape is a syntax error, so its cooked text always exists.\n  return node.type === AST_NODE_TYPES.TemplateLiteral && node.expressions.length === 0 ? ensureNonNullable(node.quasis[0]).value.cooked : null;\n}\n\nfunction isStringElement(element: null | TSESTree.Node): element is StringElement {\n  return element?.type === AST_NODE_TYPES.TemplateLiteral\n    || (element?.type === AST_NODE_TYPES.Literal && typeof element.value === 'string');\n}\n\n/**\n * Encodes text as the lines of a `dedent` template body, before indentation.\n *\n * `dedent` trims the whole result and only then decodes `\\n` and `\\r` escapes, so an edge run of line breaks survives\n * when written as escapes, and any other edge whitespace does not survive at all. It strips the smallest indentation\n * of the lines, and the first line here always starts with a non-blank character, so every line keeps its own.\n *\n * @param text - The text the template must produce.\n * @returns The body lines, or `null` when `dedent` cannot produce the text from a plain template.\n */\nfunction toDedentLines(text: string): null | string[] {\n  if (text.includes('\\\\')) {\n    return null;\n  }\n  const rest = text.replace(/^[\\r\\n]+/, '');\n  const leading = text.slice(0, text.length - rest.length);\n  const core = rest.replace(/[\\r\\n]+$/, '');\n  const trailing = rest.slice(core.length);\n  if (core === '' || (leading === '' && /^\\s/.test(core)) || (trailing === '' && /\\s$/.test(core))) {\n    return null;\n  }\n\n  // The escapes hold no line break, so splitting after escaping splits only the line breaks of the core.\n  return `${escapeLineBreaks(leading)}${escapeTemplateText(core)}${escapeLineBreaks(trailing)}`.split('\\n');\n}\n"],"mappings":"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","names":[]}

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

@@ -2,20 +2,73 @@
 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 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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import {
+  findVisibleImportName,
+  getUnusedName,
+  insertImport
+} from "./import-fix.mjs";
 import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const FUNCTION_MODULE = "@mnaoumov/typescript-lib/function";
 const MESSAGE_ID = "preferNoopAsync";
 const preferNoopAsync = {
   create(context) {
     return {
       "CallExpression"(node) {
         const callNode = toTSESTreeNode(node);
-        if (!isPromiseResolveWithNoArguments(callNode)) {
+        if (!isPromiseResolveWithNoArguments(callNode) || isLocallyBoundPromise(context.sourceCode.getScope(node), callNode)) {
           return;
         }
         context.report({
           fix(fixer) {
-            return fixer.replaceText(node, "noopAsync()");
+            const sourceCode = context.sourceCode;
+            const importedName = findVisibleImportName({ importedName: "noopAsync", moduleName: FUNCTION_MODULE, node, sourceCode });
+            if (importedName !== null) {
+              return fixer.replaceText(node, `${importedName}()`);
+            }
+            if (sourceCode.ast.sourceType !== "module") {
+              return null;
+            }
+            const name = getUnusedName(sourceCode, "noopAsync");
+            const binding = name === "noopAsync" ? name : `noopAsync as ${name}`;
+            return [
+              insertImport(fixer, sourceCode, `import { ${binding} } from '${FUNCTION_MODULE}';`),
+              fixer.replaceText(node, `${name}()`)
+            ];
           },
           messageId: MESSAGE_ID,
           node
@@ -35,6 +88,11 @@ const preferNoopAsync = {
     type: "suggestion"
   }
 };
+function isLocallyBoundPromise(scope, node) {
+  const callee = node.callee;
+  const reference = ensureNonNullable(scope.references.find((candidate) => toTSESTreeNode(candidate.identifier) === callee.object));
+  return (reference.resolved?.defs.length ?? 0) > 0;
+}
 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";
@@ -43,4 +101,4 @@ export {
   MESSAGE_ID,
   preferNoopAsync
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9saW50ZXJzL2VzbGludC1ydWxlcy9wcmVmZXItbm9vcC1hc3luYy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBmaWxlXG4gKlxuICogRVNMaW50IHJ1bGU6IHByZWZlci1ub29wLWFzeW5jXG4gKlxuICogUmVwb3J0cyBgYXdhaXQgUHJvbWlzZS5yZXNvbHZlKClgIGFuZCBzdWdnZXN0cyByZXBsYWNpbmcgaXQgd2l0aFxuICogYGF3YWl0IG5vb3BBc3luYygpYCBmb3IgY29uc2lzdGVuY3kgYW5kIHJlYWRhYmlsaXR5LlxuICpcbiAqIFRoZSBmaXggcmV1c2VzIGEgdmlzaWJsZSB2YWx1ZSBpbXBvcnQgZnJvbSBgQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL2Z1bmN0aW9uYCxcbiAqIG9yIGFkZHMgYSBjb2xsaXNpb24tZnJlZSBpbXBvcnQuIFNjcmlwdHMgd2l0aG91dCBvbmUgcmV0YWluIHRoZSBkaWFnbm9zdGljIG9ubHkuXG4gKi9cbmltcG9ydCB0eXBlIHsgVFNFU1RyZWUgfSBmcm9tICdAdHlwZXNjcmlwdC1lc2xpbnQvdXRpbHMnO1xuaW1wb3J0IHR5cGUge1xuICBSdWxlLFxuICBTY29wZVxufSBmcm9tICdlc2xpbnQnO1xuXG5pbXBvcnQgeyBlbnN1cmVOb25OdWxsYWJsZSB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi90eXBlLWd1YXJkcyc7XG5cbmltcG9ydCB7XG4gIGZpbmRWaXNpYmxlSW1wb3J0TmFtZSxcbiAgZ2V0VW51c2VkTmFtZSxcbiAgaW5zZXJ0SW1wb3J0XG59IGZyb20gJy4vaW1wb3J0LWZpeC50cyc7XG5pbXBvcnQgeyB0b1RTRVNUcmVlTm9kZSB9IGZyb20gJy4vdHMtZXN0cmVlLW5vZGUudHMnO1xuXG5jb25zdCBGVU5DVElPTl9NT0RVTEUgPSAnQG1uYW91bW92L3R5cGVzY3JpcHQtbGliL2Z1bmN0aW9uJztcbi8qKlxuTWVzc2FnZSBJRCByZXBvcnRlZCB3aGVuIGBQcm9taXNlLnJlc29sdmUoKWAgaXMgdXNlZCBmb3IgYW4gYXN5bmMgbm8tb3AgaW5zdGVhZCBvZiBgbm9vcEFzeW5jKClgLlxuICovXG5leHBvcnQgY29uc3QgTUVTU0FHRV9JRCA9ICdwcmVmZXJOb29wQXN5bmMnO1xuXG4vKipcbiAqIEVTTGludCBydWxlIHByZWZlcnJpbmcgYG5vb3BBc3luYygpYCBvdmVyIGBQcm9taXNlLnJlc29sdmUoKWAgZm9yIGFuIGFzeW5jIG5vLW9wLlxuICovXG5leHBvcnQgY29uc3QgcHJlZmVyTm9vcEFzeW5jOiBSdWxlLlJ1bGVNb2R1bGUgPSB7XG4gIGNyZWF0ZShjb250ZXh0KSB7XG4gICAgcmV0dXJuIHtcbiAgICAgICdDYWxsRXhwcmVzc2lvbicobm9kZTogUnVsZS5Ob2RlKTogdm9pZCB7XG4gICAgICAgIGNvbnN0IGNhbGxOb2RlID0gdG9UU0VTVHJlZU5vZGUobm9kZSkgYXMgVFNFU1RyZWUuQ2FsbEV4cHJlc3Npb247XG5cbiAgICAgICAgaWYgKCFpc1Byb21pc2VSZXNvbHZlV2l0aE5vQXJndW1lbnRzKGNhbGxOb2RlKSB8fCBpc0xvY2FsbHlCb3VuZFByb21pc2UoY29udGV4dC5zb3VyY2VDb2RlLmdldFNjb3BlKG5vZGUpLCBjYWxsTm9kZSkpIHtcbiAgICAgICAgICByZXR1cm47XG4gICAgICAgIH1cblxuICAgICAgICBjb250ZXh0LnJlcG9ydCh7XG4gICAgICAgICAgZml4KGZpeGVyKSB7XG4gICAgICAgICAgICBjb25zdCBzb3VyY2VDb2RlID0gY29udGV4dC5zb3VyY2VDb2RlO1xuICAgICAgICAgICAgY29uc3QgaW1wb3J0ZWROYW1lID0gZmluZFZpc2libGVJbXBvcnROYW1lKHsgaW1wb3J0ZWROYW1lOiAnbm9vcEFzeW5jJywgbW9kdWxlTmFtZTogRlVOQ1RJT05fTU9EVUxFLCBub2RlLCBzb3VyY2VDb2RlIH0pO1xuICAgICAgICAgICAgaWYgKGltcG9ydGVkTmFtZSAhPT0gbnVsbCkge1xuICAgICAgICAgICAgICByZXR1cm4gZml4ZXIucmVwbGFjZVRleHQobm9kZSwgYCR7aW1wb3J0ZWROYW1lfSgpYCk7XG4gICAgICAgICAgICB9XG5cbiAgICAgICAgICAgIC8vIEEgc2NyaXB0IGNhbm5vdCBhY2NlcHQgYW4gRVNNIGltcG9ydC4gTGVhdmUgaXRzIGRpYWdub3N0aWMgZm9yIGEgbWFudWFsIGVkaXQuXG4gICAgICAgICAgICBpZiAoc291cmNlQ29kZS5hc3Quc291cmNlVHlwZSAhPT0gJ21vZHVsZScpIHtcbiAgICAgICAgICAgICAgcmV0dXJuIG51bGw7XG4gICAgICAgICAgICB9XG4gICAgICAgICAgICBjb25zdCBuYW1lID0gZ2V0VW51c2VkTmFtZShzb3VyY2VDb2RlLCAnbm9vcEFzeW5jJyk7XG4gICAgICAgICAgICBjb25zdCBiaW5kaW5nID0gbmFtZSA9PT0gJ25vb3BBc3luYycgPyBuYW1lIDogYG5vb3BBc3luYyBhcyAke25hbWV9YDtcbiAgICAgICAgICAgIHJldHVybiBbXG4gICAgICAgICAgICAgIGluc2VydEltcG9ydChmaXhlciwgc291cmNlQ29kZSwgYGltcG9ydCB7ICR7YmluZGluZ30gfSBmcm9tICcke0ZVTkNUSU9OX01PRFVMRX0nO2ApLFxuICAgICAgICAgICAgICBmaXhlci5yZXBsYWNlVGV4dChub2RlLCBgJHtuYW1lfSgpYClcbiAgICAgICAgICAgIF07XG4gICAgICAgICAgfSxcbiAgICAgICAgICBtZXNzYWdlSWQ6IE1FU1NBR0VfSUQsXG4gICAgICAgICAgbm9kZVxuICAgICAgICB9KTtcbiAgICAgIH1cbiAgICB9O1xuICB9LFxuICBtZXRhOiB7XG4gICAgZG9jczoge1xuICAgICAgZGVzY3JpcHRpb246ICdQcmVmZXIgYG5vb3BBc3luYygpYCBvdmVyIGBQcm9taXNlLnJlc29sdmUoKWAnXG4gICAgfSxcbiAgICBmaXhhYmxlOiAnY29kZScsXG4gICAgbWVzc2FnZXM6IHtcbiAgICAgIFtNRVNTQUdFX0lEXTogJ1VzZSBgbm9vcEFzeW5jKClgIGluc3RlYWQgb2YgYFByb21pc2UucmVzb2x2ZSgpYCBmb3IgYXN5bmMgbm8tb3BzLidcbiAgICB9LFxuICAgIHNjaGVtYTogW10sXG4gICAgdHlwZTogJ3N1Z2dlc3Rpb24nXG4gIH1cbn07XG5cbi8qKlxuICogQ2hlY2tzIHdoZXRoZXIgdGhlIGBQcm9taXNlYCBvZiBhIGBQcm9taXNlLnJlc29sdmUoKWAgY2FsbCByZXNvbHZlcyB0byBhIGJpbmRpbmcgdGhlIGNvZGUgZGVjbGFyZXMgaXRzZWxmLFxuICogc3VjaCBhcyBhIGxvY2FsIHZhcmlhYmxlLCBhIHBhcmFtZXRlciBvciBhbiBpbXBvcnQsIHJhdGhlciB0aGFuIHRoZSBnbG9iYWwuXG4gKlxuICogQHBhcmFtIHNjb3BlIC0gVGhlIHNjb3BlIGVuY2xvc2luZyB0aGUgY2FsbC5cbiAqIEBwYXJhbSBub2RlIC0gVGhlIGBQcm9taXNlLnJlc29sdmUoKWAgY2FsbCBleHByZXNzaW9uLlxuICogQHJldHVybnMgYHRydWVgIGlmIGBQcm9taXNlYCBpcyBib3VuZCBieSBhIGRlY2xhcmF0aW9uIGluIHRoZSBjb2RlLlxuICovXG5mdW5jdGlvbiBpc0xvY2FsbHlCb3VuZFByb21pc2Uoc2NvcGU6IFNjb3BlLlNjb3BlLCBub2RlOiBUU0VTVHJlZS5DYWxsRXhwcmVzc2lvbik6IGJvb2xlYW4ge1xuICBjb25zdCBjYWxsZWUgPSBub2RlLmNhbGxlZSBhcyBUU0VTVHJlZS5NZW1iZXJFeHByZXNzaW9uO1xuICBjb25zdCByZWZlcmVuY2UgPSBlbnN1cmVOb25OdWxsYWJsZShzY29wZS5yZWZlcmVuY2VzLmZpbmQoKGNhbmRpZGF0ZSkgPT4gdG9UU0VTVHJlZU5vZGUoY2FuZGlkYXRlLmlkZW50aWZpZXIpID09PSBjYWxsZWUub2JqZWN0KSk7XG4gIC8vIEEgZ2xvYmFsIGBQcm9taXNlYCByZXNvbHZlcyB0byBhIHZhcmlhYmxlIHdpdGhvdXQgZGVmaW5pdGlvbnMsIG9yIHRvIG5vdGhpbmcgd2hlbiBubyBnbG9iYWxzIGFyZSBjb25maWd1cmVkLlxuICByZXR1cm4gKHJlZmVyZW5jZS5yZXNvbHZlZD8uZGVmcy5sZW5ndGggPz8gMCkgPiAwO1xufVxuXG4vKipcbiAqIENoZWNrcyB3aGV0aGVyIGEgY2FsbCBleHByZXNzaW9uIGlzIGBQcm9taXNlLnJlc29sdmUoKWAgd2l0aCBubyBhcmd1bWVudHMuXG4gKlxuICogQHBhcmFtIG5vZGUgLSBUaGUgY2FsbCBleHByZXNzaW9uIG5vZGUuXG4gKiBAcmV0dXJucyBgdHJ1ZWAgaWYgdGhlIG5vZGUgaXMgYFByb21pc2UucmVzb2x2ZSgpYCB3aXRoIG5vIGFyZ3VtZW50cy5cbiAqL1xuZnVuY3Rpb24gaXNQcm9taXNlUmVzb2x2ZVdpdGhOb0FyZ3VtZW50cyhub2RlOiBUU0VTVHJlZS5DYWxsRXhwcmVzc2lvbik6IGJvb2xlYW4ge1xuICBjb25zdCBjYWxsZWUgPSBub2RlLmNhbGxlZTtcblxuICAvKiBlc2xpbnQtZGlzYWJsZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tdW5zYWZlLWVudW0tY29tcGFyaXNvbiAtLSBBU1Qgbm9kZSB0eXBlIHN0cmluZyBsaXRlcmFscyBtYXRjaCB0aGUgVFNFU1RyZWUgZW51bSB2YWx1ZXMuICovXG4gIHJldHVybiBub2RlLmFyZ3VtZW50cy5sZW5ndGggPT09IDBcbiAgICAmJiBjYWxsZWUudHlwZSA9PT0gJ01lbWJlckV4cHJlc3Npb24nXG4gICAgJiYgY2FsbGVlLm9iamVjdC50eXBlID09PSAnSWRlbnRpZmllcicgJiYgY2FsbGVlLm9iamVjdC5uYW1lID09PSAnUHJvbWlzZSdcbiAgICAmJiBjYWxsZWUucHJvcGVydHkudHlwZSA9PT0gJ0lkZW50aWZpZXInICYmIGNhbGxlZS5wcm9wZXJ0eS5uYW1lID09PSAncmVzb2x2ZSc7XG4gIC8qIGVzbGludC1lbmFibGUgQHR5cGVzY3JpcHQtZXNsaW50L25vLXVuc2FmZS1lbnVtLWNvbXBhcmlzb24gLS0gQVNUIG5vZGUgdHlwZSBzdHJpbmcgbGl0ZXJhbHMgbWF0Y2ggdGhlIFRTRVNUcmVlIGVudW0gdmFsdWVzLiAqL1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQWlCQSxTQUFTLHlCQUF5QjtBQUVsQztBQUFBLEVBQ0U7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLE9BQ0s7QUFDUCxTQUFTLHNCQUFzQjtBQUUvQixNQUFNLGtCQUFrQjtBQUlqQixNQUFNLGFBQWE7QUFLbkIsTUFBTSxrQkFBbUM7QUFBQSxFQUM5QyxPQUFPLFNBQVM7QUFDZCxXQUFPO0FBQUEsTUFDTCxpQkFBaUIsTUFBdUI7QUFDdEMsY0FBTSxXQUFXLGVBQWUsSUFBSTtBQUVwQyxZQUFJLENBQUMsZ0NBQWdDLFFBQVEsS0FBSyxzQkFBc0IsUUFBUSxXQUFXLFNBQVMsSUFBSSxHQUFHLFFBQVEsR0FBRztBQUNwSDtBQUFBLFFBQ0Y7QUFFQSxnQkFBUSxPQUFPO0FBQUEsVUFDYixJQUFJLE9BQU87QUFDVCxrQkFBTSxhQUFhLFFBQVE7QUFDM0Isa0JBQU0sZUFBZSxzQkFBc0IsRUFBRSxjQUFjLGFBQWEsWUFBWSxpQkFBaUIsTUFBTSxXQUFXLENBQUM7QUFDdkgsZ0JBQUksaUJBQWlCLE1BQU07QUFDekIscUJBQU8sTUFBTSxZQUFZLE1BQU0sR0FBRyxZQUFZLElBQUk7QUFBQSxZQUNwRDtBQUdBLGdCQUFJLFdBQVcsSUFBSSxlQUFlLFVBQVU7QUFDMUMscUJBQU87QUFBQSxZQUNUO0FBQ0Esa0JBQU0sT0FBTyxjQUFjLFlBQVksV0FBVztBQUNsRCxrQkFBTSxVQUFVLFNBQVMsY0FBYyxPQUFPLGdCQUFnQixJQUFJO0FBQ2xFLG1CQUFPO0FBQUEsY0FDTCxhQUFhLE9BQU8sWUFBWSxZQUFZLE9BQU8sWUFBWSxlQUFlLElBQUk7QUFBQSxjQUNsRixNQUFNLFlBQVksTUFBTSxHQUFHLElBQUksSUFBSTtBQUFBLFlBQ3JDO0FBQUEsVUFDRjtBQUFBLFVBQ0EsV0FBVztBQUFBLFVBQ1g7QUFBQSxRQUNGLENBQUM7QUFBQSxNQUNIO0FBQUEsSUFDRjtBQUFBLEVBQ0Y7QUFBQSxFQUNBLE1BQU07QUFBQSxJQUNKLE1BQU07QUFBQSxNQUNKLGFBQWE7QUFBQSxJQUNmO0FBQUEsSUFDQSxTQUFTO0FBQUEsSUFDVCxVQUFVO0FBQUEsTUFDUixDQUFDLFVBQVUsR0FBRztBQUFBLElBQ2hCO0FBQUEsSUFDQSxRQUFRLENBQUM7QUFBQSxJQUNULE1BQU07QUFBQSxFQUNSO0FBQ0Y7QUFVQSxTQUFTLHNCQUFzQixPQUFvQixNQUF3QztBQUN6RixRQUFNLFNBQVMsS0FBSztBQUNwQixRQUFNLFlBQVksa0JBQWtCLE1BQU0sV0FBVyxLQUFLLENBQUMsY0FBYyxlQUFlLFVBQVUsVUFBVSxNQUFNLE9BQU8sTUFBTSxDQUFDO0FBRWhJLFVBQVEsVUFBVSxVQUFVLEtBQUssVUFBVSxLQUFLO0FBQ2xEO0FBUUEsU0FBUyxnQ0FBZ0MsTUFBd0M7QUFDL0UsUUFBTSxTQUFTLEtBQUs7QUFHcEIsU0FBTyxLQUFLLFVBQVUsV0FBVyxLQUM1QixPQUFPLFNBQVMsc0JBQ2hCLE9BQU8sT0FBTyxTQUFTLGdCQUFnQixPQUFPLE9BQU8sU0FBUyxhQUM5RCxPQUFPLFNBQVMsU0FBUyxnQkFBZ0IsT0FBTyxTQUFTLFNBQVM7QUFFekU7IiwibmFtZXMiOltdfQ==

package/dist/lib/esm/linters/eslint-rules/readonly-member-arrays.d.mts

@@ -0,0 +1,6 @@
+/// <reference path="../../library-references.d.mts" />
+import type { Rule } from 'eslint';
+/**
+ * Opt-in array immutability policy, independent of readonly property references.
+ */
+export declare const readonlyMemberArrays: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/readonly-member-arrays.mjs

@@ -0,0 +1,106 @@
+/*
+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 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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { toTSESTreeNode } from "./ts-estree-node.mjs";
+const readonlyMemberArrays = {
+  create(context) {
+    function check(node, property) {
+      if (node.type === AST_NODE_TYPES.TSUnionType || node.type === AST_NODE_TYPES.TSIntersectionType) {
+        for (const member of node.types) {
+          check(member, property);
+        }
+        return;
+      }
+      if (node.type === AST_NODE_TYPES.TSArrayType) {
+        context.report({
+          messageId: "readonly",
+          node,
+          suggest: [{ fix: (fixer) => fixer.insertTextBefore(node, "readonly "), messageId: "review" }]
+        });
+        return;
+      }
+      if (node.type !== AST_NODE_TYPES.TSTypeReference || node.typeName.type !== AST_NODE_TYPES.Identifier || node.typeName.name !== "Array" || node.typeArguments?.params.length !== 1) {
+        return;
+      }
+      let scope = context.sourceCode.getScope(property);
+      let canSuggest = true;
+      while (scope) {
+        if (scope.set.get("Array")?.defs.length) {
+          return;
+        }
+        if (scope.set.get("ReadonlyArray")?.defs.length) {
+          canSuggest = false;
+        }
+        scope = scope.upper;
+      }
+      context.report({
+        messageId: "readonly",
+        node,
+        suggest: canSuggest ? [{
+          fix: (fixer) => fixer.replaceTextRange(node.typeName.range, "ReadonlyArray"),
+          messageId: "review"
+        }] : []
+      });
+    }
+    function visitProperty(node) {
+      const property = toTSESTreeNode(node);
+      if (property.typeAnnotation) {
+        check(property.typeAnnotation.typeAnnotation, node);
+      }
+    }
+    return {
+      "TSInterfaceDeclaration TSPropertySignature": visitProperty,
+      "TSTypeAliasDeclaration TSPropertySignature": visitProperty
+    };
+  },
+  meta: {
+    docs: { description: "Require readonly member arrays as an explicit collection immutability policy" },
+    hasSuggestions: true,
+    messages: {
+      readonly: "Use a readonly member array, or disable this rule with a reason for mutation.",
+      review: "Make this array readonly after reviewing mutations and assignability."
+    },
+    schema: [],
+    type: "suggestion"
+  }
+};
+export {
+  readonlyMemberArrays
+};
+//# sourceMappingURL=data:application/json;base64,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