@putout/engine-loader 15.4.1 → 16.1.0

package/lib/index.js

@@ -1,141 +1,14 @@
 'use strict';
 
 const {createAsyncLoader} = require('./load/async-loader');
-const {parsePluginNames} = require('./plugins/parse-plugin-names');
-const parseProcessorNames = require('./processors/parse-processor-names');
-const validatePlugin = require('./plugins/validate-plugin');
-const {loadPluginsAsync} = require('./plugins/load-plugins-async');
-
-const {
-    parseRules,
-    validateRules,
-    isEnabled,
-    getLoadedRules,
-} = require('./rules');
 
-const {filterEnabledPlugins} = require('./plugins/filter-enabled-plugins');
-const {check, checkRule} = require('./check');
-const {enableNestedRules} = require('./rules/parse-rules');
-const {isArray} = Array;
+const {validateRulesRelations} = require('./validators/validate-rules-relations');
+const {loadPluginsAsync} = require('./plugins/load-plugins-async');
+const {loadPlugins} = require('./plugins/load-plugins');
+const {loadProcessorsAsync} = require('./processors/load-processors-async');
 
+module.exports.loadPlugins = loadPlugins;
 module.exports.loadPluginsAsync = loadPluginsAsync;
-module.exports.loadProcessorsAsync = async (options, load) => {
-    check(options);
-    
-    const {processors = []} = options;
-    const parsedProcessors = parseProcessorNames(processors);
-    const loadProcessor = createAsyncLoader('processor');
-    
-    const list = [];
-    
-    for (const [name, fn] of parsedProcessors) {
-        if (fn) {
-            list.push(fn);
-            continue;
-        }
-        
-        list.push(loadProcessor(name, load));
-    }
-    
-    return await Promise.all(list);
-};
-
+module.exports.loadProcessorsAsync = loadProcessorsAsync;
 module.exports.createAsyncLoader = createAsyncLoader;
-
-module.exports.validateRules = (options) => {
-    check(options);
-    
-    const {pluginNames = [], rules = {}} = options;
-    const items = parsePluginNames(pluginNames);
-    
-    validateRules({
-        rules,
-        items,
-    });
-};
-
-module.exports.loadPlugins = (options) => {
-    check(options);
-    
-    const {pluginNames = [], rules = {}} = options;
-    
-    const enabledRules = enableNestedRules(rules);
-    const cookedEnabledRules = parseRules(enabledRules);
-    const loadedRules = getLoadedRules(cookedEnabledRules);
-    
-    const items = parsePluginNames(pluginNames);
-    const plugins = loadPlugins({
-        items,
-        loadedRules,
-    });
-    
-    const cookedRules = parseRules(rules);
-    return filterEnabledPlugins({
-        plugins,
-        cookedRules,
-    });
-};
-
-const splitRule = (rule) => [rule, 'putout'];
-
-const parseRule = (rule) => rule
-    .replace('import:@putout/plugin-', '')
-    .replace('@putout/plugin-', '');
-
-const maybeFromTuple = (a) => isArray(a) ? a[1] : a;
-
-function loadPlugins({items, loadedRules}) {
-    const plugins = [];
-    
-    for (const [rule, itemPlugin] of items) {
-        if (!isEnabled(rule, loadedRules))
-            continue;
-        
-        checkRule(rule);
-        const parsedRule = parseRule(rule);
-        
-        const [name, namespace] = splitRule(rule);
-        const plugin = maybeFromTuple(itemPlugin) || loadPlugin({
-            name,
-            namespace,
-        });
-        
-        validatePlugin({
-            plugin,
-            rule,
-        });
-        
-        const {rules} = plugin;
-        
-        if (rules) {
-            plugins.push(...extendRules(parsedRule, rules));
-            continue;
-        }
-        
-        plugins.push([parsedRule, plugin]);
-    }
-    
-    return plugins;
-}
-
-function extendRules(rule, plugin) {
-    const result = [];
-    const entries = Object.entries(plugin);
-    
-    for (const [name, plugin] of entries) {
-        result.push([`${rule}/${name}`, plugin]);
-    }
-    
-    return result;
-}
-
-// add support of esm.sh
-// https://github.com/esm-dev/esm.sh/issues/1045
-function loadPlugin({name, namespace}) {
-    const {loadPlugin} = require('./load/load');
-    
-    return loadPlugin({
-        name,
-        namespace,
-    });
-}
+module.exports.validateRulesRelations = validateRulesRelations;

package/lib/load/load.js

@@ -49,7 +49,9 @@ function getPath(namespace, type, name) {
     return [path, customRequire];
 }
 
-const {PUTOUT_YARN_PNP = 'putout'} = process.env;
+const {
+    PUTOUT_YARN_PNP = 'putout',
+} = process.env;
 
 const createCustomRequire = once(() => createRequire(require.resolve(PUTOUT_YARN_PNP)));
 const createPutoutRequire = once(() => createRequire(require.resolve('putout')));

package/lib/plugins/load-plugins-async.js

@@ -2,13 +2,10 @@
 
 const {basename} = require('node:path');
 
-const {
-    parseRules,
-    isEnabled,
-    getLoadedRules,
-} = require('../rules');
+const {isEnabled} = require('../rules');
+
+const {prepareRules} = require('./prepare-rules');
 
-const {parsePluginNames} = require('./parse-plugin-names');
 const validatePlugin = require('./validate-plugin');
 const {filterEnabledPlugins} = require('./filter-enabled-plugins');
 
@@ -21,10 +18,14 @@ module.exports.loadPluginsAsync = async (options) => {
     check(options);
     
     const {pluginNames = [], rules = {}} = options;
-    
-    const cookedRules = parseRules(rules);
-    const loadedRules = getLoadedRules(cookedRules);
-    const items = parsePluginNames(pluginNames);
+    const {
+        items,
+        loadedRules,
+        cookedRules,
+    } = prepareRules({
+        rules,
+        pluginNames,
+    });
     
     const plugins = await loadPlugins({
         items,

package/lib/plugins/load-plugins.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const validatePlugin = require('./validate-plugin');
+const {prepareRules} = require('./prepare-rules');
+
+const {isEnabled} = require('../rules');
+
+const {filterEnabledPlugins} = require('./filter-enabled-plugins');
+const {check, checkRule} = require('../check');
+
+const {isArray} = Array;
+
+module.exports.loadPlugins = (options) => {
+    check(options);
+    
+    const {pluginNames = [], rules = {}} = options;
+    const {
+        items,
+        loadedRules,
+        cookedRules,
+    } = prepareRules({
+        rules,
+        pluginNames,
+    });
+    
+    const plugins = loadPlugins({
+        items,
+        loadedRules,
+    });
+    
+    return filterEnabledPlugins({
+        plugins,
+        cookedRules,
+    });
+};
+
+const splitRule = (rule) => [rule, 'putout'];
+
+const parseRule = (rule) => rule
+    .replace('import:@putout/plugin-', '')
+    .replace('@putout/plugin-', '');
+
+const maybeFromTuple = (a) => isArray(a) ? a[1] : a;
+
+function loadPlugins({items, loadedRules}) {
+    const plugins = [];
+    
+    for (const [rule, itemPlugin] of items) {
+        if (!isEnabled(rule, loadedRules))
+            continue;
+        
+        checkRule(rule);
+        const parsedRule = parseRule(rule);
+        
+        const [name, namespace] = splitRule(rule);
+        const plugin = maybeFromTuple(itemPlugin) || loadPlugin({
+            name,
+            namespace,
+        });
+        
+        validatePlugin({
+            plugin,
+            rule,
+        });
+        
+        const {rules} = plugin;
+        
+        if (rules) {
+            plugins.push(...extendRules(parsedRule, rules));
+            continue;
+        }
+        
+        plugins.push([parsedRule, plugin]);
+    }
+    
+    return plugins;
+}
+
+function extendRules(rule, plugin) {
+    const result = [];
+    const entries = Object.entries(plugin);
+    
+    for (const [name, plugin] of entries) {
+        result.push([`${rule}/${name}`, plugin]);
+    }
+    
+    return result;
+}
+
+// add support of esm.sh
+// https://github.com/esm-dev/esm.sh/issues/1045
+function loadPlugin({name, namespace}) {
+    const {loadPlugin} = require('../load/load');
+    
+    return loadPlugin({
+        name,
+        namespace,
+    });
+}

package/lib/plugins/prepare-rules.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const {parsePluginNames} = require('./parse-plugin-names');
+const {enableNestedRules} = require('../rules/parse-rules');
+
+const {parseRules, getLoadedRules} = require('../rules');
+
+module.exports.prepareRules = ({rules, pluginNames}) => {
+    const enabledRules = enableNestedRules(rules);
+    const cookedEnabledRules = parseRules(enabledRules);
+    const loadedRules = getLoadedRules(cookedEnabledRules);
+    const items = parsePluginNames(pluginNames);
+    const cookedRules = parseRules(rules);
+    
+    return {
+        items,
+        loadedRules,
+        cookedRules,
+    };
+};

package/lib/processors/load-processors-async.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const {createAsyncLoader} = require('../load/async-loader');
+
+const parseProcessorNames = require('../processors/parse-processor-names');
+
+const {check} = require('../check');
+
+module.exports.loadProcessorsAsync = async (options, load) => {
+    check(options);
+    
+    const {processors = []} = options;
+    const parsedProcessors = parseProcessorNames(processors);
+    const loadProcessor = createAsyncLoader('processor');
+    
+    const list = [];
+    
+    for (const [name, fn] of parsedProcessors) {
+        if (fn) {
+            list.push(fn);
+            continue;
+        }
+        
+        list.push(loadProcessor(name, load));
+    }
+    
+    return await Promise.all(list);
+};

package/lib/rules/validate-rules.js

@@ -21,21 +21,23 @@ module.exports.validateRules = ({items, rules}) => {
     for (const rule of ruleItems) {
         let isName = false;
         let isWithSlash = false;
+        let isIncludes = false;
         
         for (const [pluginName, plugin = {}] of items) {
             const parsedPluginName = parsePluginName(pluginName);
             
             isName = parsedPluginName === rule;
             isWithSlash = parsedPluginName === parseSlashes(rule);
+            isIncludes = rule.includes(parsedPluginName);
             
             if (isName && plugin.rules)
                 throw Error(`Rule '${rule}' cannot be applied to nested plugin '${pluginName}'`);
             
-            if (isName || isWithSlash)
+            if (isName || isWithSlash || isIncludes)
                 break;
         }
         
-        if (!isName && !isWithSlash)
+        if (!isName && !isWithSlash && !isIncludes)
             throw Error(`No plugin found for a rule: '${rule}'`);
     }
 };

package/lib/validators/validate-rules-relations.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const {parsePluginNames} = require('../plugins/parse-plugin-names');
+const {validateRules} = require('../rules');
+const {check} = require('../check');
+
+module.exports.validateRulesRelations = (options) => {
+    check(options);
+    
+    const {pluginNames = [], rules = {}} = options;
+    const items = parsePluginNames(pluginNames);
+    
+    validateRules({
+        rules,
+        items,
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/engine-loader",
-  "version": "15.4.1",
+  "version": "16.1.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "load plugins and prepare them to run",
@@ -39,30 +39,30 @@
     "putout": "*"
   },
   "devDependencies": {
-    "@putout/eslint-flat": "^2.0.0",
+    "@putout/eslint-flat": "^3.0.0",
     "@putout/formatter-progress": "*",
     "@putout/plugin-apply-nullish-coalescing": "*",
     "@putout/plugin-convert-commonjs-to-esm": "*",
     "@putout/plugin-nodejs": "*",
-    "@putout/plugin-remove-unused-variables": "*",
+    "@putout/plugin-remove-debugger": "*",
     "@putout/processor-javascript": "*",
     "@putout/processor-markdown": "*",
     "c8": "^10.0.0",
     "eslint": "^9.0.0",
     "eslint-plugin-n": "^17.0.0",
-    "eslint-plugin-putout": "^25.0.1",
+    "eslint-plugin-putout": "^28.0.0",
     "estrace": "*",
     "just-camel-case": "^6.2.0",
-    "madrun": "^10.0.0",
+    "madrun": "^11.0.0",
     "mock-require": "^3.0.3",
     "montag": "^1.0.0",
     "nodemon": "^3.0.1",
     "putout": "*",
-    "supertape": "^10.0.0"
+    "supertape": "^11.0.3"
   },
   "license": "MIT",
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "publishConfig": {
     "access": "public"