@lohn/eslint-plugin-disable-autofix 6.1.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Mikl Wolfe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @lohn/eslint-plugin-disable-autofix
+
+> **Temporary fork — use the original: [eslint-plugin-disable-autofix](https://www.npmjs.com/package/eslint-plugin-disable-autofix)**
+
+This package publishes bug fixes pending merge upstream. Once the fixes are merged, this package will be removed and no longer usable — switch back to the original before then.
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,21 @@
+import type { Linter, Rule } from 'eslint';
+interface CreatePluginOptions {
+    mode?: 'all' | 'fix' | 'suggest';
+    plugins?: string[];
+}
+interface PluginInstance {
+    meta: {
+        name: string;
+        version: string;
+    };
+    configs: Record<string, Linter.Config | Linter.Config[]>;
+    rules: Record<string, Rule.RuleModule>;
+    processors: Record<string, Linter.Processor>;
+    configure: (rules: Record<string, Linter.RuleEntry>) => {
+        plugins: Record<string, PluginInstance>;
+        rules: Record<string, Linter.RuleEntry>;
+    };
+    createPlugin: (options?: CreatePluginOptions) => PluginInstance;
+}
+declare const plugin: PluginInstance;
+export = plugin;

package/index.js

@@ -0,0 +1,326 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const VERSION = '6.1.3';
+const MODES = {
+    all: { fix: true, suggest: true },
+    fix: { fix: true, suggest: false },
+    suggest: { fix: false, suggest: true },
+};
+const MODE_PREFIXES = {
+    all: 'disable-autofix',
+    fix: 'disable-fix',
+    suggest: 'disable-suggest',
+};
+const disableFix = (rule, mode) => {
+    const result = {
+        create(context) {
+            const wrappedContext = Object.create(context, {
+                report: {
+                    enumerable: true,
+                    value(descriptor) {
+                        const cleaned = { ...descriptor };
+                        if (mode.fix) {
+                            delete cleaned.fix;
+                        }
+                        if (mode.suggest) {
+                            delete cleaned.suggest;
+                        }
+                        context.report(cleaned);
+                    },
+                },
+            });
+            return rule.create(wrappedContext);
+        },
+    };
+    if (rule.meta) {
+        const meta = { ...rule.meta };
+        if (mode.fix) {
+            delete meta.fixable;
+        }
+        if (mode.suggest) {
+            delete meta.hasSuggestions;
+        }
+        result.meta = meta;
+    }
+    return result;
+};
+const convertPluginId = (pluginId) => {
+    if (pluginId.startsWith('@')) {
+        return pluginId.replace(/\/eslint-plugin(-|$)/u, '/').replace(/\/$/, '');
+    }
+    return pluginId.replace(/^eslint-plugin-/u, '');
+};
+const safeRequire = (id) => {
+    try {
+        const module_ = require(id);
+        if (module_.__esModule &&
+            module_.default &&
+            typeof module_.default === 'object') {
+            return module_.default;
+        }
+        return module_;
+    }
+    catch {
+        return undefined;
+    }
+};
+let eslintBuiltinRules;
+try {
+    const unsupported = require('eslint/use-at-your-own-risk');
+    eslintBuiltinRules = unsupported.builtinRules;
+}
+catch {
+}
+let discoveryDone = false;
+const builtinRuleNames = [];
+const prefixToPackage = new Map();
+const discover = () => {
+    if (discoveryDone) {
+        return;
+    }
+    discoveryDone = true;
+    const nmDirectories = [];
+    try {
+        const eslintEntry = require.resolve('eslint/package.json');
+        nmDirectories.push(node_path_1.default.resolve(node_path_1.default.dirname(eslintEntry), '..'));
+    }
+    catch {
+    }
+    const searchPaths = require.resolve.paths?.('eslint-plugin-disable-autofix') ?? [];
+    for (const p of searchPaths) {
+        try {
+            if (!nmDirectories.includes(p) && node_fs_1.default.statSync(p).isDirectory()) {
+                nmDirectories.push(p);
+            }
+        }
+        catch {
+        }
+    }
+    if (nmDirectories.length === 0) {
+        nmDirectories.push(node_path_1.default.join(process.cwd(), 'node_modules'));
+    }
+    if (eslintBuiltinRules) {
+        builtinRuleNames.push(...eslintBuiltinRules.keys());
+    }
+    else {
+        for (const nmDir of nmDirectories) {
+            try {
+                const rulesDir = node_path_1.default.join(nmDir, 'eslint', 'lib', 'rules');
+                for (const f of node_fs_1.default.readdirSync(rulesDir)) {
+                    if (f.endsWith('.js') && !f.includes('index')) {
+                        const name = f.replace('.js', '');
+                        if (!builtinRuleNames.includes(name)) {
+                            builtinRuleNames.push(name);
+                        }
+                    }
+                }
+                break;
+            }
+            catch {
+            }
+        }
+    }
+    const seen = new Set();
+    for (const nmDir of nmDirectories) {
+        try {
+            for (const entry of node_fs_1.default.readdirSync(nmDir)) {
+                if (entry === 'eslint-plugin-disable-autofix') {
+                    continue;
+                }
+                if (entry === '@types' || entry.startsWith('@eslint')) {
+                    continue;
+                }
+                if (entry.startsWith('eslint-plugin-') && !seen.has(entry)) {
+                    seen.add(entry);
+                    prefixToPackage.set(convertPluginId(entry), entry);
+                }
+                else if (entry.startsWith('@')) {
+                    try {
+                        const scopeDir = node_path_1.default.join(nmDir, entry);
+                        for (const sub of node_fs_1.default.readdirSync(scopeDir)) {
+                            if (!sub.startsWith('eslint-plugin')) {
+                                continue;
+                            }
+                            const package_ = `${entry}/${sub}`;
+                            if (!seen.has(package_)) {
+                                seen.add(package_);
+                                prefixToPackage.set(convertPluginId(package_), package_);
+                            }
+                        }
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        catch {
+        }
+    }
+};
+const pluginRulesCache = new Map();
+const loadPluginRules = (packageName) => {
+    if (pluginRulesCache.has(packageName)) {
+        return pluginRulesCache.get(packageName);
+    }
+    const module_ = safeRequire(packageName);
+    const rules = module_?.rules ?? {};
+    pluginRulesCache.set(packageName, rules);
+    return rules;
+};
+const loadBuiltinRule = (name) => {
+    if (eslintBuiltinRules) {
+        return eslintBuiltinRules.get(name);
+    }
+    try {
+        const eslintDir = node_path_1.default.dirname(require.resolve('eslint/package.json'));
+        return require(node_path_1.default.join(eslintDir, 'lib', 'rules', `${name}.js`));
+    }
+    catch {
+        return undefined;
+    }
+};
+const parseRuleName = (name) => {
+    let bestPrefix = '';
+    for (const prefix of prefixToPackage.keys()) {
+        if (name.startsWith(`${prefix}/`) && prefix.length > bestPrefix.length) {
+            bestPrefix = prefix;
+        }
+    }
+    if (bestPrefix) {
+        return { prefix: bestPrefix, ruleId: name.slice(bestPrefix.length + 1) };
+    }
+    return undefined;
+};
+const createPlugin = (options) => {
+    discover();
+    const modeName = options?.mode ?? 'all';
+    const mode = MODES[modeName] ?? MODES.all;
+    const prefix = MODE_PREFIXES[modeName] ?? 'disable-autofix';
+    const allowedPrefixes = options?.plugins ? new Set(options.plugins) : null;
+    const ruleCache = new Map();
+    const isAllowed = (name) => {
+        if (!allowedPrefixes) {
+            return true;
+        }
+        if (!name.includes('/')) {
+            return true;
+        }
+        const parsed = parseRuleName(name);
+        return parsed ? allowedPrefixes.has(parsed.prefix) : false;
+    };
+    const getRule = (name) => {
+        if (ruleCache.has(name)) {
+            return ruleCache.get(name);
+        }
+        if (!isAllowed(name)) {
+            return undefined;
+        }
+        let original;
+        if (name.includes('/')) {
+            const parsed = parseRuleName(name);
+            if (!parsed) {
+                return undefined;
+            }
+            const packageName = prefixToPackage.get(parsed.prefix);
+            if (!packageName) {
+                return undefined;
+            }
+            const rules = loadPluginRules(packageName);
+            original = rules[parsed.ruleId];
+        }
+        else {
+            if (!builtinRuleNames.includes(name)) {
+                return undefined;
+            }
+            original = loadBuiltinRule(name);
+        }
+        if (!original) {
+            return undefined;
+        }
+        try {
+            const wrapped = disableFix(original, mode);
+            ruleCache.set(name, wrapped);
+            return wrapped;
+        }
+        catch {
+            return undefined;
+        }
+    };
+    const getRuleNames = () => {
+        const names = [...builtinRuleNames];
+        const entries = allowedPrefixes
+            ? [...prefixToPackage.entries()].filter(([p]) => allowedPrefixes.has(p))
+            : [...prefixToPackage.entries()];
+        for (const [pfx, packageName] of entries) {
+            try {
+                for (const ruleId of Object.keys(loadPluginRules(packageName))) {
+                    names.push(`${pfx}/${ruleId}`);
+                }
+            }
+            catch {
+            }
+        }
+        return names;
+    };
+    const rules = new Proxy(Object.create(null), {
+        get(_, property) {
+            if (typeof property !== 'string') {
+                return;
+            }
+            return getRule(property);
+        },
+        getOwnPropertyDescriptor(_, property) {
+            if (typeof property !== 'string') {
+                return;
+            }
+            if (builtinRuleNames.includes(property)) {
+                return { configurable: true, enumerable: true, writable: true };
+            }
+            const parsed = parseRuleName(property);
+            if (parsed && isAllowed(property)) {
+                const packageName = prefixToPackage.get(parsed.prefix);
+                if (packageName) {
+                    const pluginRules = loadPluginRules(packageName);
+                    if (parsed.ruleId in pluginRules) {
+                        return { configurable: true, enumerable: true, writable: true };
+                    }
+                }
+            }
+        },
+        has(_, property) {
+            if (typeof property !== 'string') {
+                return false;
+            }
+            return getRule(property) !== undefined;
+        },
+        ownKeys() {
+            return getRuleNames();
+        },
+    });
+    const configure = (input) => {
+        const resultRules = {};
+        for (const [name, config] of Object.entries(input)) {
+            resultRules[name] = 'off';
+            resultRules[`${prefix}/${name}`] = config;
+        }
+        return {
+            plugins: { [prefix]: instance },
+            rules: resultRules,
+        };
+    };
+    const instance = {
+        configs: {},
+        configure,
+        createPlugin,
+        meta: { name: 'eslint-plugin-disable-autofix', version: VERSION },
+        processors: {},
+        rules,
+    };
+    return instance;
+};
+const plugin = createPlugin();
+module.exports = plugin;

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@lohn/eslint-plugin-disable-autofix",
+  "version": "6.1.3",
+  "description": "Temporary fork of eslint-plugin-disable-autofix — use the original at https://www.npmjs.com/package/eslint-plugin-disable-autofix instead",
+  "main": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "LICENSE",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "license": "MIT",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "disable",
+    "autofix",
+    "suggestions",
+    "flat-config"
+  ],
+  "homepage": "https://github.com/lohn/eslint-plugin-disable-autofix/tree/fix-scoped-types-plugin-discovery",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lohn/eslint-plugin-disable-autofix.git#fix-scoped-types-plugin-discovery"
+  },
+  "bugs": "https://github.com/lohn/eslint-plugin-disable-autofix/issues",
+  "author": "Mikl Wolfe <wolfe@mikl.io> (https://github.com/chiefmikey)"
+}