@morev/eslint-disable-autofix 1.0.2 → 1.1.0

package/README.md

@@ -16,23 +16,21 @@ It's useful when you want a rule to remain active for linting purposes but preve
 ---
 
 > [!NOTE]
-> This is a temporary solution until [this RFC](https://github.com/eslint/rfcs/pull/134) is accepted
-> and a final implementation is made that closes [this issue](https://github.com/eslint/eslint/issues/18696) -
+> This is a temporary solution until [this issue](https://github.com/eslint/eslint/issues/18696) is resolved -
 > after that the feature for disabling autofix for rules will be in the ESLint core.
 >
-> I am working on RFC development and final implementation in the core myself,
-> but the process will take some time, and the problem is already there.
+> I tried to get [the RFC implemented](https://github.com/eslint/rfcs/pull/134), but was unsuccessful.
+> Now there is another RFC: <https://github.com/eslint/rfcs/pull/143>
 >
-> I'll probably be able to implement this as a polyfill for the final solution,
-> once [the RFC](https://github.com/eslint/rfcs/pull/134) discussion reaches
-> a consensus on a public API.
+> I'll probably be able to implement this package as a polyfill for the final solution,
+> once RFC discussion reaches a consensus on a public API.
 
 ---
 
 > [!IMPORTANT]
 >
-> * Only works with ESLint v9 and its flat config format;
-> * You have to restart ESLint server after adding/removing `no-autofix/` prefix to take effect.
+> - Only works with ESLint v9 with flat config format or ESLint v10;
+> - You have to restart ESLint server after adding/removing `no-autofix/` prefix to take effect.
 
 ---
 
@@ -48,15 +46,15 @@ due to project-specific or personal preferences.
 
 ## Installation
 
-```bash
+```sh
 pnpm add -D @morev/eslint-disable-autofix
 ```
 
-```bash
+```sh
 yarn add @morev/eslint-disable-autofix -D
 ```
 
-```bash
+```sh
 npm install -D @morev/eslint-disable-autofix
 ```
 
@@ -111,29 +109,7 @@ export default disableAutofix([
 1. Strips the prefix to keep the original name of the rule;
 1. Patches rules from ESLint core or third-party plugins directly to disable autofix.
 
-Under the hood, it uses [`eslint-rule-composer`](https://github.com/not-an-aardvark/eslint-rule-composer)
-to wrap rules with autofix disabled.
-
->[!CAUTION]
+> [!CAUTION]
 > Direct patching is quite risky and hacky, it relies on non-public ESLint API. \
 > While it's currently the only way to access certain rule internals,
 > it may break in future ESLint versions.
-
-## Alternatives
-
-I've been using [eslint-plugin-no-autofix](https://github.com/aladdin-add/eslint-plugin/tree/master/packages/no-autofix)
-for a long time and haven't had much trouble with it, however recently problems have arisen:
-
-1. Some popular plugins (like [eslint-plugin-unicorn](https://github.com/sindresorhus/eslint-plugin-unicorn)
-   or [eslint-stylistic](https://github.com/eslint-stylistic/eslint-stylistic))
-   switch to the ESM-only distribution format and
-   [eslint-plugin-no-autofix](https://github.com/aladdin-add/eslint-plugin/tree/master/packages/no-autofix) doesn't work with it.
-   The [issue have no response](https://github.com/aladdin-add/eslint-plugin/issues/104),
-   so I've decided to create my own solution that works in a different way.
-1. I'm getting tired of rules being renamed just to make them work. \
-   Say I need to disable a rule with autofix turned off for a single file - I write `/* eslint-disable no-autofix/unicorn/no-lonely-if */`. \
-   Later, the broken autofix in the original rule gets fixed, I re-enable the main rule,
-   and now the directive no longer applies, which leads to unexpected changes I didn't want.
-
-   Patching the original rules instead of creating new ones might be a bit riskier technically,
-   but from a developer experience perspective, it's definitely cleaner and more intuitive.

package/dist/index.cjs

@@ -34,14 +34,203 @@ __export(index_exports, {
   disableAutofix: () => disableAutofix
 });
 module.exports = __toCommonJS(index_exports);
-var import_utils = require("@morev/utils");
+var import_utils2 = require("@morev/utils");
 var import_use_at_your_own_risk = __toESM(require("eslint/use-at-your-own-risk"), 1);
 
+// src/rule-composer.js
+var import_utils = require("@morev/utils");
+var getRuleCreateFunction = (rule) => (0, import_utils.isFunction)(rule) ? rule : rule.create;
+var getRuleMeta = (rule) => {
+  return (0, import_utils.isObject)(rule) && "meta" in rule && (0, import_utils.isObject)(rule.meta) ? rule.meta : {};
+};
+var getMessageIds = (rule) => {
+  const meta = getRuleMeta(rule);
+  return "messages" in meta && (0, import_utils.isObject)(rule.meta.messages) ? meta.messages : {};
+};
+var normalizeMultiArgReportCall = (...args) => {
+  if (args.length === 1) return args[0];
+  if ((0, import_utils.isString)(args[1])) {
+    return {
+      node: args[0],
+      message: args[1],
+      data: args[2],
+      fix: args[3]
+    };
+  }
+  return {
+    node: args[0],
+    loc: args[1],
+    message: args[2],
+    data: args[3],
+    fix: args[4]
+  };
+};
+var normalizeReportLoc = (descriptor) => {
+  if (!descriptor.loc) return descriptor.node.loc;
+  return descriptor.loc.start ? descriptor.loc : { start: descriptor.loc, end: null };
+};
+var normalizeMessagePlaceholders = (descriptor, messageIds) => {
+  const message = (0, import_utils.isString)(descriptor.messageId) ? messageIds[descriptor.messageId] : descriptor.message;
+  if (!descriptor.data) {
+    return {
+      message,
+      data: (0, import_utils.isString)(descriptor.messageId) ? {} : null
+    };
+  }
+  const normalizedData = /* @__PURE__ */ Object.create(null);
+  const interpolatedMessage = message.replaceAll(
+    /\{\{\s*([^{}]+?)\s*\}\}/g,
+    (fullMatch, term) => {
+      if (term in descriptor.data) {
+        normalizedData[term] = descriptor.data[term];
+        return descriptor.data[term];
+      }
+      return fullMatch;
+    }
+  );
+  return {
+    message: interpolatedMessage,
+    data: Object.freeze(normalizedData)
+  };
+};
+var getReportNormalizer = (rule) => {
+  const messageIds = getMessageIds(rule);
+  return function normalizeReport(...args) {
+    const descriptor = normalizeMultiArgReportCall(...args);
+    const interpolatedMessageAndData = normalizeMessagePlaceholders(descriptor, messageIds);
+    return {
+      node: descriptor.node,
+      message: interpolatedMessageAndData.message,
+      messageId: (0, import_utils.isString)(descriptor.messageId) ? descriptor.messageId : null,
+      data: (0, import_utils.isString)(descriptor.messageId) ? interpolatedMessageAndData.data : null,
+      loc: normalizeReportLoc(descriptor),
+      fix: descriptor.fix
+    };
+  };
+};
+var removeMessageIfMessageIdPresent = (reportDescriptor) => {
+  const newDescriptor = { ...reportDescriptor };
+  if ((0, import_utils.isString)(reportDescriptor.messageId) && (0, import_utils.isString)(reportDescriptor.message)) {
+    delete newDescriptor.message;
+  }
+  return newDescriptor;
+};
+var getContextVariables = (context) => {
+  const filename = "getFilename" in context && (0, import_utils.isFunction)(context.getFilename) ? context.getFilename() : context.filename;
+  const sourceCode = "getSourceCode" in context && (0, import_utils.isFunction)(context.getSourceCode) ? context.getSourceCode() : context.sourceCode;
+  return { filename, sourceCode };
+};
+var rule_composer_default = Object.freeze({
+  filterReports(rule, predicate) {
+    return Object.freeze({
+      create(context) {
+        const { filename, sourceCode } = getContextVariables(context);
+        const { settings, options } = context;
+        return getRuleCreateFunction(rule)(
+          Object.freeze(
+            Object.create(
+              context,
+              {
+                report: {
+                  enumerable: true,
+                  value(...args) {
+                    const reportDescriptor = getReportNormalizer(rule)(...args);
+                    if (predicate(reportDescriptor, {
+                      sourceCode,
+                      settings,
+                      options,
+                      filename
+                    })) {
+                      context.report(removeMessageIfMessageIdPresent(reportDescriptor));
+                    }
+                  }
+                }
+              }
+            )
+          )
+        );
+      },
+      schema: rule.schema,
+      meta: getRuleMeta(rule)
+    });
+  },
+  mapReports(rule, iteratee) {
+    return Object.freeze({
+      create(context) {
+        const { filename, sourceCode } = getContextVariables(context);
+        const { settings, options } = context;
+        return getRuleCreateFunction(rule)(
+          Object.freeze(
+            Object.create(
+              context,
+              {
+                report: {
+                  enumerable: true,
+                  value(...args) {
+                    context.report(
+                      removeMessageIfMessageIdPresent(
+                        iteratee(
+                          getReportNormalizer(rule)(...args),
+                          {
+                            sourceCode,
+                            settings,
+                            options,
+                            filename
+                          }
+                        )
+                      )
+                    );
+                  }
+                }
+              }
+            )
+          )
+        );
+      },
+      schema: rule.schema,
+      meta: getRuleMeta(rule)
+    });
+  },
+  joinReports(rules) {
+    return Object.freeze({
+      create(context) {
+        return rules.map((rule) => getRuleCreateFunction(rule)(context)).reduce(
+          (allListeners, ruleListeners) => Object.keys(ruleListeners).reduce(
+            (combinedListeners, key) => {
+              const currentListener = combinedListeners[key];
+              const ruleListener = ruleListeners[key];
+              if (currentListener) {
+                return {
+                  ...combinedListeners,
+                  [key](...args) {
+                    currentListener(...args);
+                    ruleListener(...args);
+                  }
+                };
+              }
+              return { ...combinedListeners, [key]: ruleListener };
+            },
+            allListeners
+          ),
+          /* @__PURE__ */ Object.create(null)
+        );
+      },
+      meta: Object.freeze({
+        // eslint-disable-next-line unicorn/prefer-reflect-apply
+        messages: Object.assign.apply(
+          null,
+          [/* @__PURE__ */ Object.create(null), ...rules.map((rule) => getMessageIds(rule))]
+        ),
+        fixable: "code"
+      })
+    });
+  }
+});
+
 // src/utils.ts
-var import_eslint_rule_composer = __toESM(require("eslint-rule-composer"), 1);
 var createNonFixableRule = (rule) => {
   if (!rule) return null;
-  return import_eslint_rule_composer.default.mapReports(
+  return rule_composer_default.mapReports(
     Object.create(rule),
     (problem) => {
       problem.fix = null;
@@ -57,25 +246,25 @@ var omitMutable = (source, keys) => {
 var internalDisableAutofix = (options) => {
   const { configurations, prefix } = options;
   const allNoAutofixRules = configurations.reduce((acc, configuration) => {
-    if ((0, import_utils.isEmpty)(configuration.rules)) return acc;
-    const rulesToDisableAutofix = import_utils.tsObject.fromEntries(
-      import_utils.tsObject.entries(configuration.rules).filter(([ruleName, ruleValue]) => ruleName.startsWith(prefix))
+    if ((0, import_utils2.isEmpty)(configuration.rules)) return acc;
+    const rulesToDisableAutofix = import_utils2.tsObject.fromEntries(
+      import_utils2.tsObject.entries(configuration.rules).filter(([ruleName, ruleValue]) => ruleName.startsWith(prefix))
     );
-    if ((0, import_utils.isEmpty)(rulesToDisableAutofix)) return acc;
-    const cleanRules = import_utils.tsObject.fromEntries(
-      import_utils.tsObject.entries(rulesToDisableAutofix).map(([ruleName, ruleValue]) => [
+    if ((0, import_utils2.isEmpty)(rulesToDisableAutofix)) return acc;
+    const cleanRules = import_utils2.tsObject.fromEntries(
+      import_utils2.tsObject.entries(rulesToDisableAutofix).map(([ruleName, ruleValue]) => [
         ruleName.replace(`${prefix}/`, ""),
         ruleValue
       ])
     );
-    omitMutable(configuration.rules, import_utils.tsObject.keys(rulesToDisableAutofix));
+    omitMutable(configuration.rules, import_utils2.tsObject.keys(rulesToDisableAutofix));
     Object.assign(configuration.rules, cleanRules);
-    acc.push(...import_utils.tsObject.keys(cleanRules));
+    acc.push(...import_utils2.tsObject.keys(cleanRules));
     return acc;
   }, []);
-  if ((0, import_utils.isEmpty)(allNoAutofixRules)) return configurations;
+  if ((0, import_utils2.isEmpty)(allNoAutofixRules)) return configurations;
   const allPlugins = configurations.reduce((acc, configuration) => {
-    import_utils.tsObject.entries(configuration.plugins ?? {}).forEach(([pluginMappingName, pluginObject]) => {
+    import_utils2.tsObject.entries(configuration.plugins ?? {}).forEach(([pluginMappingName, pluginObject]) => {
       acc[pluginMappingName] ??= pluginObject;
     });
     return acc;

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import * as eslint from 'eslint';
 import { PlainObject } from '@morev/utils';
+import { Linter } from 'eslint';
 
 /**
  * Options of the factory that creates a `disableAutofix` wrapper.
@@ -37,7 +37,7 @@ type CreateDisableAutofixOptions = {
  *
  * @returns           Wrapper function that will disable autofix for config rules.
  */
-declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptions>) => (configurations: PlainObject[]) => eslint.Linter.Config<eslint.Linter.RulesRecord>[];
+declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptions>) => (configurations: PlainObject[]) => Linter.Config[];
 /**
  * Wrapper function that will disable autofix
  * for config rules that have `no-autofix/` prefix.
@@ -61,6 +61,6 @@ declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptio
  *    are replaced with the same rules without the prefix,
  *    and the original rules are patched so that `autofix` is not performed.
  */
-declare const disableAutofix: (configurations: PlainObject[]) => eslint.Linter.Config<eslint.Linter.RulesRecord>[];
+declare const disableAutofix: (configurations: PlainObject[]) => Linter.Config[];
 
 export { createDisableAutofix, disableAutofix };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import * as eslint from 'eslint';
 import { PlainObject } from '@morev/utils';
+import { Linter } from 'eslint';
 
 /**
  * Options of the factory that creates a `disableAutofix` wrapper.
@@ -37,7 +37,7 @@ type CreateDisableAutofixOptions = {
  *
  * @returns           Wrapper function that will disable autofix for config rules.
  */
-declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptions>) => (configurations: PlainObject[]) => eslint.Linter.Config<eslint.Linter.RulesRecord>[];
+declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptions>) => (configurations: PlainObject[]) => Linter.Config[];
 /**
  * Wrapper function that will disable autofix
  * for config rules that have `no-autofix/` prefix.
@@ -61,6 +61,6 @@ declare const createDisableAutofix: (options?: Partial<CreateDisableAutofixOptio
  *    are replaced with the same rules without the prefix,
  *    and the original rules are patched so that `autofix` is not performed.
  */
-declare const disableAutofix: (configurations: PlainObject[]) => eslint.Linter.Config<eslint.Linter.RulesRecord>[];
+declare const disableAutofix: (configurations: PlainObject[]) => Linter.Config[];
 
 export { createDisableAutofix, disableAutofix };

package/dist/index.js

@@ -2,11 +2,200 @@
 import { isEmpty, tsObject } from "@morev/utils";
 import riskyEslint from "eslint/use-at-your-own-risk";
 
+// src/rule-composer.js
+import { isFunction, isObject, isString } from "@morev/utils";
+var getRuleCreateFunction = (rule) => isFunction(rule) ? rule : rule.create;
+var getRuleMeta = (rule) => {
+  return isObject(rule) && "meta" in rule && isObject(rule.meta) ? rule.meta : {};
+};
+var getMessageIds = (rule) => {
+  const meta = getRuleMeta(rule);
+  return "messages" in meta && isObject(rule.meta.messages) ? meta.messages : {};
+};
+var normalizeMultiArgReportCall = (...args) => {
+  if (args.length === 1) return args[0];
+  if (isString(args[1])) {
+    return {
+      node: args[0],
+      message: args[1],
+      data: args[2],
+      fix: args[3]
+    };
+  }
+  return {
+    node: args[0],
+    loc: args[1],
+    message: args[2],
+    data: args[3],
+    fix: args[4]
+  };
+};
+var normalizeReportLoc = (descriptor) => {
+  if (!descriptor.loc) return descriptor.node.loc;
+  return descriptor.loc.start ? descriptor.loc : { start: descriptor.loc, end: null };
+};
+var normalizeMessagePlaceholders = (descriptor, messageIds) => {
+  const message = isString(descriptor.messageId) ? messageIds[descriptor.messageId] : descriptor.message;
+  if (!descriptor.data) {
+    return {
+      message,
+      data: isString(descriptor.messageId) ? {} : null
+    };
+  }
+  const normalizedData = /* @__PURE__ */ Object.create(null);
+  const interpolatedMessage = message.replaceAll(
+    /\{\{\s*([^{}]+?)\s*\}\}/g,
+    (fullMatch, term) => {
+      if (term in descriptor.data) {
+        normalizedData[term] = descriptor.data[term];
+        return descriptor.data[term];
+      }
+      return fullMatch;
+    }
+  );
+  return {
+    message: interpolatedMessage,
+    data: Object.freeze(normalizedData)
+  };
+};
+var getReportNormalizer = (rule) => {
+  const messageIds = getMessageIds(rule);
+  return function normalizeReport(...args) {
+    const descriptor = normalizeMultiArgReportCall(...args);
+    const interpolatedMessageAndData = normalizeMessagePlaceholders(descriptor, messageIds);
+    return {
+      node: descriptor.node,
+      message: interpolatedMessageAndData.message,
+      messageId: isString(descriptor.messageId) ? descriptor.messageId : null,
+      data: isString(descriptor.messageId) ? interpolatedMessageAndData.data : null,
+      loc: normalizeReportLoc(descriptor),
+      fix: descriptor.fix
+    };
+  };
+};
+var removeMessageIfMessageIdPresent = (reportDescriptor) => {
+  const newDescriptor = { ...reportDescriptor };
+  if (isString(reportDescriptor.messageId) && isString(reportDescriptor.message)) {
+    delete newDescriptor.message;
+  }
+  return newDescriptor;
+};
+var getContextVariables = (context) => {
+  const filename = "getFilename" in context && isFunction(context.getFilename) ? context.getFilename() : context.filename;
+  const sourceCode = "getSourceCode" in context && isFunction(context.getSourceCode) ? context.getSourceCode() : context.sourceCode;
+  return { filename, sourceCode };
+};
+var rule_composer_default = Object.freeze({
+  filterReports(rule, predicate) {
+    return Object.freeze({
+      create(context) {
+        const { filename, sourceCode } = getContextVariables(context);
+        const { settings, options } = context;
+        return getRuleCreateFunction(rule)(
+          Object.freeze(
+            Object.create(
+              context,
+              {
+                report: {
+                  enumerable: true,
+                  value(...args) {
+                    const reportDescriptor = getReportNormalizer(rule)(...args);
+                    if (predicate(reportDescriptor, {
+                      sourceCode,
+                      settings,
+                      options,
+                      filename
+                    })) {
+                      context.report(removeMessageIfMessageIdPresent(reportDescriptor));
+                    }
+                  }
+                }
+              }
+            )
+          )
+        );
+      },
+      schema: rule.schema,
+      meta: getRuleMeta(rule)
+    });
+  },
+  mapReports(rule, iteratee) {
+    return Object.freeze({
+      create(context) {
+        const { filename, sourceCode } = getContextVariables(context);
+        const { settings, options } = context;
+        return getRuleCreateFunction(rule)(
+          Object.freeze(
+            Object.create(
+              context,
+              {
+                report: {
+                  enumerable: true,
+                  value(...args) {
+                    context.report(
+                      removeMessageIfMessageIdPresent(
+                        iteratee(
+                          getReportNormalizer(rule)(...args),
+                          {
+                            sourceCode,
+                            settings,
+                            options,
+                            filename
+                          }
+                        )
+                      )
+                    );
+                  }
+                }
+              }
+            )
+          )
+        );
+      },
+      schema: rule.schema,
+      meta: getRuleMeta(rule)
+    });
+  },
+  joinReports(rules) {
+    return Object.freeze({
+      create(context) {
+        return rules.map((rule) => getRuleCreateFunction(rule)(context)).reduce(
+          (allListeners, ruleListeners) => Object.keys(ruleListeners).reduce(
+            (combinedListeners, key) => {
+              const currentListener = combinedListeners[key];
+              const ruleListener = ruleListeners[key];
+              if (currentListener) {
+                return {
+                  ...combinedListeners,
+                  [key](...args) {
+                    currentListener(...args);
+                    ruleListener(...args);
+                  }
+                };
+              }
+              return { ...combinedListeners, [key]: ruleListener };
+            },
+            allListeners
+          ),
+          /* @__PURE__ */ Object.create(null)
+        );
+      },
+      meta: Object.freeze({
+        // eslint-disable-next-line unicorn/prefer-reflect-apply
+        messages: Object.assign.apply(
+          null,
+          [/* @__PURE__ */ Object.create(null), ...rules.map((rule) => getMessageIds(rule))]
+        ),
+        fixable: "code"
+      })
+    });
+  }
+});
+
 // src/utils.ts
-import ruleComposer from "eslint-rule-composer";
 var createNonFixableRule = (rule) => {
   if (!rule) return null;
-  return ruleComposer.mapReports(
+  return rule_composer_default.mapReports(
     Object.create(rule),
     (problem) => {
       problem.fix = null;

package/package.json

@@ -3,7 +3,7 @@
   "description": "Utility to disable autofix for specific ESLint rules",
   "type": "module",
   "private": false,
-  "version": "1.0.2",
+  "version": "1.1.0",
   "engines": {
     "node": ">=18"
   },
@@ -46,34 +46,31 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "peerDependencies": {
-    "eslint": "^9.0.0"
+    "eslint": "^9.0.0 || ^10.0.0"
   },
   "dependencies": {
-    "@morev/utils": "^3.12.2",
-    "eslint-rule-composer": "^0.3.0"
+    "@morev/utils": "^3.13.1"
   },
   "devDependencies": {
     "@morev/commitlint-config": "^0.2.2",
-    "@morev/eslint-config": "^38.1.0",
-    "@morev/stylelint-config": "^7.1.0",
+    "@morev/eslint-config": "^41.0.0",
     "@release-it/conventional-changelog": "^8.0.1",
     "@types/node": "^22.15.18",
-    "eslint": "9.27.0",
-    "eslint-plugin-unicorn": "^59.0.1",
-    "lefthook": "^1.11.13",
-    "release-it": "^19.0.2",
-    "stylelint": "^16.19.1",
+    "eslint": "9.39.2",
+    "eslint-plugin-unicorn": "^63.0.0",
+    "lefthook": "^2.1.0",
+    "release-it": "^19.2.4",
     "ts-node": "^10.9.2",
-    "tsup": "^8.5.0",
-    "tsx": "^4.19.4",
-    "typescript": "^5.8.3",
-    "vitest": "^3.1.3"
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.18"
   },
   "scripts": {
     "test": "vitest",
     "test:dev": "vitest --watch",
-    "lint": "eslint \"**/*.{js,ts,vue,json,json5,jsonc,yml,yaml,md}\"",
-    "lint:fix": "eslint \"**/*.{js,ts,vue,json,json5,jsonc,yml,yaml,md}\" --fix",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
     "build": "rm -rf dist && tsup",
     "release": "release-it --disable-metrics"
   }