@putout/engine-loader 11.0.2 → 11.1.0

package/README.md

@@ -59,6 +59,28 @@ const plugins = loadPlugins({
 });
 ```
 
+### loadPluginsAsync
+
+Load **ESM** plugins:
+
+```js
+const {loadPluginsAsync} = require('@putout/engine-loader');
+
+const pluginNames = [
+    'remove-unusede-variables',
+];
+
+const rules = {
+    'remove-unused-variables': 'on',
+};
+
+const plugins = await loadPluginsAsync({
+    cache: true, //default
+    pluginNames,
+    rules,
+});
+```
+
 ### loadProcessorsAsync
 
 ```js

package/lib/index.js

@@ -10,38 +10,16 @@ const parseProcessorNames = require('./parse-processor-names');
 const parseRules = require('./parse-rules');
 const validateRules = require('./validate-rules');
 const validatePlugin = require('./validate-plugin');
+const {mergeRules} = require('./merge-rules');
+const {loadPluginsAsync} = require('./load-plugins-async');
 
 const isString = (a) => typeof a === 'string';
-const defaultOptions = () => Object.create(null);
-
-const mergeRules = ([rule, plugin], rules) => {
-    for (const currentRule of rules) {
-        if (currentRule.rule !== rule)
-            continue;
-        
-        const {msg, options} = currentRule;
-        
-        return {
-            rule,
-            plugin,
-            msg,
-            options,
-        };
-    }
-    
-    return {
-        rule,
-        plugin,
-        msg: '',
-        options: defaultOptions(),
-    };
-};
 
+module.exports.loadPluginsAsync = loadPluginsAsync;
 module.exports.loadProcessorsAsync = nanomemoize(async (options, load) => {
     check(options);
     
     const {processors = []} = options;
-    
     const parsedProcessors = parseProcessorNames(processors);
     const loadProcessor = createAsyncLoader('processor');
     

package/lib/load-plugins-async.js

@@ -0,0 +1,132 @@
+'use strict';
+
+const isEnabled = require('./is-enabled');
+const parseRules = require('./parse-rules');
+const {nanomemoize} = require('nano-memoize');
+const {createAsyncLoader} = require('./async-loader');
+const parsePluginNames = require('./parse-plugin-names');
+const validateRules = require('./validate-rules');
+const validatePlugin = require('./validate-plugin');
+const {mergeRules} = require('./merge-rules');
+
+const isString = (a) => typeof a === 'string';
+
+module.exports.loadPluginsAsync = nanomemoize(async (options) => {
+    check(options);
+    
+    const {pluginNames = [], rules = {}} = options;
+    
+    const cookedRules = parseRules(rules);
+    const loadedRules = getLoadedRules(cookedRules);
+    
+    const items = parsePluginNames(pluginNames);
+    
+    const plugins = await loadPlugins({
+        items,
+        loadedRules,
+    });
+    
+    validateRules({
+        rules,
+        items,
+    });
+    
+    const result = [];
+    
+    // Would be great to have ability to filter
+    // disabled plugins and prevent them from loading
+    // but we can't because of a way multi-rule plugins
+    // works. We can't determine count and names of all
+    // rules of a plugin before load.
+    for (const [name, plugin] of plugins) {
+        if (!isEnabled(name, cookedRules))
+            continue;
+        
+        result.push(mergeRules(
+            [name, plugin],
+            cookedRules,
+        ));
+    }
+    
+    return result;
+});
+
+function splitRule(rule) {
+    return [rule, 'putout'];
+}
+
+async function loadPlugins({items, loadedRules}) {
+    const loadPlugin = createAsyncLoader('plugin');
+    const promises = [];
+    
+    for (const [rule, itemPlugin] of items) {
+        if (!isEnabled(rule, loadedRules))
+            continue;
+        
+        checkRule(rule);
+        
+        const [name] = splitRule(rule);
+        const plugin = itemPlugin || loadPlugin(name);
+        
+        promises.push(plugin);
+    }
+    
+    const resolvedPlugins = await Promise.all(promises);
+    const plugins = [];
+    
+    for (const [i, [rule]] of items.entries()) {
+        const plugin = resolvedPlugins[i];
+        
+        validatePlugin({
+            plugin,
+            rule,
+        });
+        
+        const {rules} = plugin;
+        
+        if (rules) {
+            plugins.push(...extendRules(rule, rules));
+            continue;
+        }
+        
+        plugins.push([rule, plugin]);
+    }
+    
+    return plugins;
+}
+
+function getLoadedRules(rules) {
+    const loadedRules = [];
+    
+    for (const item of rules) {
+        const {rule} = item;
+        
+        if (rule.includes('/'))
+            continue;
+        
+        loadedRules.push(item);
+    }
+    
+    return loadedRules;
+}
+
+function extendRules(rule, plugin) {
+    const result = [];
+    const entries = Object.entries(plugin);
+    
+    for (const [name, plugin] of entries) {
+        result.push([`${rule}/${name}`, plugin]);
+    }
+    
+    return result;
+}
+
+function check(options) {
+    if (!options || typeof options !== 'object')
+        throw Error('options should be an object!');
+}
+
+function checkRule(rule) {
+    if (!isString(rule))
+        throw Error(`☝️ Looks like plugin name type is not 'string', but: '${typeof rule}'`);
+}

package/lib/merge-rules.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const defaultOptions = () => Object.create(null);
+
+module.exports.mergeRules = ([rule, plugin], rules) => {
+    for (const currentRule of rules) {
+        if (currentRule.rule !== rule)
+            continue;
+        
+        const {msg, options} = currentRule;
+        
+        return {
+            rule,
+            plugin,
+            msg,
+            options,
+        };
+    }
+    
+    return {
+        rule,
+        plugin,
+        msg: '',
+        options: defaultOptions(),
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/engine-loader",
-  "version": "11.0.2",
+  "version": "11.1.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "load plugins and prepare them to run",