@putout/engine-loader 11.0.1 → 11.1.0

package/README.md

@@ -59,39 +59,25 @@ const plugins = loadPlugins({
 });
 ```
 
-#### Babel Plugins
+### loadPluginsAsync
 
-You can use `babel plugins` with help of `babel/` prefix.
-
-*Example*
-Let's use two plugins:
-
-- `babel-plugin-transform-inline-consecutive-adds`
-- `@babel/plugin-codemod-object-assign-to-object-spread`
-
-`@putout/engine-loader` will gues the prefix of `plugin` :).
+Load **ESM** plugins:
 
 ```js
+const {loadPluginsAsync} = require('@putout/engine-loader');
+
 const pluginNames = [
-    'babel/transform-inline-consecutive-adds',
-    'babel/codemod-object-assign-to-object-spread',
+    'remove-unusede-variables',
 ];
 
-const plugins = loadPlugins({
-    pluginNames,
-});
-```
-
-When you need to use imported babel plugin use `babelPlugin`:
-
-```js
-import {babelPlugin} from '@putout/engine-loader';
-import transformBlockScoping from '@babel/plugin-transform-block-scoping';
+const rules = {
+    'remove-unused-variables': 'on',
+};
 
-const plugins = loadPlugins({
-    pluginNames: [
-        ['babel/transform-inline-consecutive-adds', babelPlugin(transformBlockScoping, 'Optional message')],
-    ],
+const plugins = await loadPluginsAsync({
+    cache: true, //default
+    pluginNames,
+    rules,
 });
 ```
 

package/lib/index.js

@@ -10,40 +10,16 @@ const parseProcessorNames = require('./parse-processor-names');
 const parseRules = require('./parse-rules');
 const validateRules = require('./validate-rules');
 const validatePlugin = require('./validate-plugin');
-const {babelPlugin} = require('./wrap-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');
     
@@ -63,8 +39,6 @@ module.exports.loadProcessorsAsync = nanomemoize(async (options, load) => {
 
 module.exports.createAsyncLoader = createAsyncLoader;
 
-module.exports.babelPlugin = babelPlugin;
-
 module.exports.loadPlugins = (options) => {
     check(options);
     
@@ -121,12 +95,7 @@ function getLoadedRules(rules) {
 }
 
 function splitRule(rule) {
-    const name = rule.replace('babel/', '');
-    
-    if (rule.startsWith('babel'))
-        return [name, 'babel'];
-    
-    return [name, 'putout'];
+    return [rule, 'putout'];
 }
 
 function loadPlugins({items, loadedRules}) {
@@ -139,7 +108,6 @@ function loadPlugins({items, loadedRules}) {
         checkRule(rule);
         
         const [name, namespace] = splitRule(rule);
-        
         const plugin = itemPlugin || loadPlugin({
             name,
             namespace,

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/load.js

@@ -5,14 +5,9 @@ const {createRequire} = require('module');
 const tryCatch = require('try-catch');
 const once = require('once');
 
-const wrapPlugin = require('./wrap-plugin');
-
 const bigFirst = (a) => `${a[0].toUpperCase()}${a.slice(1)}`;
 
 const load = (type) => ({name, namespace}) => {
-    if (namespace !== 'putout')
-        return wrapPlugin(name, namespace);
-    
     const [pluginPath, customRequire] = getPath(namespace, type, name);
     
     if (!pluginPath)

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/lib/parse-rules.js

@@ -78,34 +78,14 @@ function parseArray(rule, args) {
         };
     }
     
-    const [, msg = '', options = defaultOptions()] = args;
-    
-    if (args.length === 2 && !isStr(msg)) {
-        return {
-            rule,
-            state,
-            plugin,
-            msg: '',
-            options: msg,
-        };
-    }
-    
-    if (args.length === 1 && isObj(rawState)) {
-        return {
-            rule,
-            state,
-            plugin,
-            msg,
-            options: rawState,
-        };
-    }
+    const [, msg = ''] = args;
     
     return {
         rule,
         state,
         plugin,
-        msg,
-        options,
+        msg: '',
+        options: msg,
     };
 }
 

package/lib/validate-rules.js

@@ -1,9 +1,6 @@
 'use strict';
 
 const parse = (rule) => {
-    if (rule.startsWith('babel/'))
-        return rule;
-    
     if (rule.includes('/'))
         return rule
             .split('/')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/engine-loader",
-  "version": "11.0.1",
+  "version": "11.1.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "load plugins and prepare them to run",
@@ -25,7 +25,6 @@
   },
   "dependencies": {
     "@putout/engine-parser": "^8.0.0",
-    "@babel/core": "^7.12.3",
     "diff-match-patch": "^1.0.4",
     "nano-memoize": "^3.0.11",
     "once": "^1.4.0",
@@ -41,14 +40,11 @@
     "putout": "*"
   },
   "devDependencies": {
-    "@babel/plugin-codemod-object-assign-to-object-spread": "^7.7.4",
     "@putout/formatter-progress": "*",
     "@putout/plugin-convert-commonjs-to-esm": "*",
     "@putout/plugin-remove-unused-variables": "*",
     "@putout/processor-javascript": "*",
     "@putout/processor-markdown": "*",
-    "babel-plugin-angularjs-annotate": "https://github.com/putoutjs/babel-plugin-angularjs-annotate",
-    "babel-plugin-transform-inline-consecutive-adds": "^0.4.3",
     "c8": "^8.0.0",
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^16.0.0",

package/lib/get-positions-by-diff.js

@@ -1,68 +0,0 @@
-'use strict';
-
-const DiffMatchPatch = require('diff-match-patch');
-
-module.exports = (oldText, newText) => {
-    const lines = diffLineMode(oldText, newText);
-    const changedLines = getChangedLines(lines);
-    
-    return convert(changedLines);
-};
-
-function convert(lines) {
-    const result = [];
-    const column = 0;
-    
-    for (const line of lines) {
-        result.push({
-            line,
-            column,
-        });
-    }
-    
-    return result;
-}
-
-const NOT_CHANGED = 0;
-const REMOVED = -1;
-
-function getChangedLines(lines) {
-    let i = 0;
-    const changedLines = [];
-    let prevState = 0;
-    
-    for (const [state, line] of lines) {
-        if (state === NOT_CHANGED) {
-            ++i;
-            continue;
-        }
-        
-        if (state === REMOVED) {
-            i += line.split('\n').length - 1;
-        }
-        
-        if (prevState !== NOT_CHANGED) {
-            prevState = state;
-            continue;
-        }
-        
-        changedLines.push(i);
-        prevState = state;
-    }
-    
-    return changedLines;
-}
-
-// https://github.com/google/diff-match-patch/wiki/Line-or-Word-Diffs
-function diffLineMode(text1, text2) {
-    const dmp = new DiffMatchPatch();
-    const a = dmp.diff_linesToChars_(text1, text2);
-    const lineText1 = a.chars1;
-    const lineText2 = a.chars2;
-    const {lineArray} = a;
-    const diffs = dmp.diff_main(lineText1, lineText2, false);
-    
-    dmp.diff_charsToLines_(diffs, lineArray);
-    
-    return diffs;
-}

package/lib/transforms/babel.js

@@ -1,22 +0,0 @@
-'use strict';
-
-const {
-    createConfigItem,
-    transformFromAstSync,
-} = require('@babel/core');
-
-const isString = (a) => typeof a === 'string';
-
-module.exports = (ast, code, name) => {
-    const plugin = !isString(name) ? name : require(name);
-    
-    transformFromAstSync(ast, code, {
-        cloneInputAst: false,
-        plugins: [
-            // globally installed modules support
-            createConfigItem(plugin),
-        ],
-    });
-    
-    return ast;
-};

package/lib/wrap-plugin.js

@@ -1,82 +0,0 @@
-'use strict';
-
-const tryCatch = require('try-catch');
-const {print} = require('@putout/engine-parser');
-
-const getPositions = require('./get-positions-by-diff');
-
-const babelTransform = require('./transforms/babel');
-
-const BABEL_REG = /@babel\/plugin-|babel-plugin-/;
-
-const getMessage = (a) => a.replace(BABEL_REG, '').replaceAll('-', ' ');
-
-const getModulePath = (name) => {
-    const [, path] = tryCatch(require.resolve, name);
-    return path;
-};
-
-module.exports = (name, namespace) => {
-    const message = getMessage(name);
-    
-    if (/babel/.test(namespace))
-        return getPlugin({
-            name: getBabelPluginName(name),
-            message,
-            transform: babelTransform,
-        });
-    
-    return null;
-};
-
-const getPlugin = ({name, transform, message}) => ({
-    report: () => message,
-    fix: () => {},
-    find(ast, {push}) {
-        const oldCode = print(ast, {
-            printer: 'putout',
-        });
-        
-        transform(ast, oldCode, name);
-        
-        const newCode = print(ast, {
-            printer: 'putout',
-        });
-        
-        if (newCode === oldCode)
-            return;
-        
-        const positions = getPositions(oldCode, newCode);
-        
-        for (const start of positions) {
-            const node = {
-                loc: {
-                    start,
-                },
-            };
-            
-            const path = {
-                node,
-            };
-            
-            push(path);
-        }
-    },
-});
-
-module.exports.babelPlugin = (plugin, message) => {
-    return getPlugin({
-        name: plugin,
-        transform: babelTransform,
-        message,
-    });
-};
-
-function getBabelPluginName(name) {
-    const namespaced = getModulePath(`@babel/plugin-${name}`);
-    
-    if (namespaced)
-        return namespaced;
-    
-    return `babel-plugin-${name}`;
-}