@putout/engine-loader 16.3.1 → 17.0.0

package/README.md

@@ -27,16 +27,20 @@ Simplest type of plugin support by [`@putout/engine-runner`](https://github.com/
 Nested contains one or more rules:
 
 ```js
-module.exports.rules = {
-    'remove-unused-variables': require('@putout/plugin-remove-unused-variables'),
+import * as removeDebugger from '@putout/plugin-remove-debugger';
+
+export const rules = {
+    'remove-debugger': removeDebugger,
 };
 ```
 
 When you want to make it disabled by default, use:
 
 ```js
-module.exports.rules = {
-    'remove-unused-variables': ['off', require('@putout/plugin-remove-unused-variables')],
+import * as removeDebugger from '@putout/plugin-remove-debugger';
+
+export const rules = {
+    'remove-debugger': ['off', removeDebugger],
 };
 ```
 
@@ -45,7 +49,7 @@ So when someone using your plugin, he needs to enable it:
 ```json
 {
     "rules": {
-        "nested/remove-unused-variables": "on"
+        "nested/remove-debugger": "on"
     },
     "plugins": ["nested"]
 }
@@ -63,7 +67,7 @@ If you want to load from custom directory (for Visual Studio Code Extension, for
 ### loadPlugins
 
 ```js
-const {loadPlugins} = require('@putout/engine-loader');
+import {loadPlugins} from '@putout/engine-loader';
 
 const pluginNames = [
     'remove-unusede-variables',
@@ -100,7 +104,7 @@ const plugins = loadPlugins({
 Load **ESM** plugins:
 
 ```js
-const {loadPluginsAsync} = require('@putout/engine-loader');
+import {loadPluginsAsync} from '@putout/engine-loader';
 
 const pluginNames = [
     'remove-unusede-variables',
@@ -170,7 +174,8 @@ Or used inside `.putout.json`:
 ### loadProcessorsAsync
 
 ```js
-const {loadProcessors} = require('@putout/engine-loader');
+import {loadProcessors} from '@putout/engine-loader';
+
 const optionalLoad = async (a) => await import(a);
 
 const plugins = await loadProcessorsAsync({
@@ -186,7 +191,8 @@ const plugins = await loadProcessorsAsync({
 Gives ability to create loader for `processor` or `formatter`.
 
 ```js
-const {createAsyncLoader} = require('@putout/engine-loader');
+import {createAsyncLoader} from '@putout/engine-loader';
+
 const {loadProcessor} = createAsyncLoader('processor');
 
 // load @putout/processor-markdown
@@ -200,7 +206,7 @@ await loadProcess('json', () => {
 ### validateRules
 
 ```js
-const {validateRules} = require('@putout/engine-loader');
+import {validateRules} from '@putout/engine-loader';
 
 const pluginNames = [];
 const rules = {

package/lib/check/index.js

@@ -1,13 +1,11 @@
-'use strict';
-
 const isString = (a) => typeof a === 'string';
 
-module.exports.check = (options) => {
+export const check = (options) => {
     if (!options || typeof options !== 'object')
         throw Error('options should be an object!');
 };
 
-module.exports.checkRule = (rule) => {
+export const checkRule = (rule) => {
     if (!isString(rule))
         throw Error(`☝️ Looks like plugin name type is not 'string', but: '${typeof rule}'`);
 };

package/lib/index.js

@@ -1,14 +1,5 @@
-'use strict';
-
-const {createAsyncLoader} = require('./load/async-loader');
-
-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 = loadProcessorsAsync;
-module.exports.createAsyncLoader = createAsyncLoader;
-module.exports.validateRulesRelations = validateRulesRelations;
+export {createAsyncLoader} from './load/async-loader.js';
+export {validateRulesRelations} from './validators/validate-rules-relations.js';
+export {loadPluginsAsync} from './plugins/load-plugins-async.js';
+export {loadPlugins} from './plugins/load-plugins.js';
+export {loadProcessorsAsync} from './processors/load-processors-async.js';

package/lib/load/async-loader.js

@@ -1,15 +1,14 @@
-'use strict';
-
-const process = require('node:process');
-const {join} = require('node:path');
-
-const tryToCatch = require('try-to-catch');
-const {simpleImport: _simpleImport} = require('./simple-import');
+import process from 'node:process';
+import {join} from 'node:path';
+import {createRequire} from 'node:module';
+import tryToCatch from 'try-to-catch';
+import {simpleImport as _simpleImport} from './simple-import.js';
 
+const require = createRequire(import.meta.url);
 const {assign} = Object;
 const stub = () => () => {};
 
-module.exports.createAsyncLoader = (type, overrides = {}) => {
+export const createAsyncLoader = (type, overrides = {}) => {
     const {
         simpleImport = _simpleImport,
     } = overrides;

package/lib/load/fixture/putout-plugin-hello.js

@@ -1 +1 @@
-module.exports.report = () => 'hello';
+export const report = () => 'hello';

package/lib/load/fixture/putout-plugin-world/package.json

@@ -1,3 +1,4 @@
 {
+    "type": "commonjs",
     "main": "index.js"
 }

package/lib/load/load.js

@@ -1,10 +1,12 @@
-'use strict';
-
-const process = require('node:process');
-const {createRequire: _createRequire} = require('node:module');
-const {join} = require('node:path');
-const tryCatch = require('try-catch');
+import process from 'node:process';
+import {
+    createRequire as _createRequire,
+    createRequire,
+} from 'node:module';
+import {join} from 'node:path';
+import tryCatch from 'try-catch';
 
+const require = createRequire(import.meta.url);
 const bigFirst = (a) => `${a[0].toUpperCase()}${a.slice(1)}`;
 
 const load = (type) => (overrides) => {
@@ -31,8 +33,8 @@ const load = (type) => (overrides) => {
     return result;
 };
 
-module.exports.loadPlugin = load('plugin');
-module.exports.loadProcessor = load('processor');
+export const loadPlugin = load('plugin');
+export const loadProcessor = load('processor');
 
 function getPath(namespace, type, name, overrides) {
     const {getModulePath, createRequire} = overrides;

package/lib/load/simple-import.js

@@ -1,7 +1,5 @@
-'use strict';
-
 // How in other way to mock import using mock require in CommonJS?
-module.exports.simpleImport = async (url) => {
+export const simpleImport = async (url) => {
     const result = await import(url);
     return result.default || result;
 };

package/lib/plugins/filter-enabled-plugins.js

@@ -1,6 +1,4 @@
-'use strict';
-
-const {isEnabled, mergeRules} = require('../rules');
+import {isEnabled, mergeRules} from '../rules/index.js';
 
 const {isArray} = Array;
 const maybeTuple = (a) => isArray(a) ? a : ['on', a];
@@ -10,7 +8,7 @@ const maybeTuple = (a) => isArray(a) ? a : ['on', a];
 // 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.
-module.exports.filterEnabledPlugins = ({plugins, cookedRules}) => {
+export const filterEnabledPlugins = ({plugins, cookedRules}) => {
     const result = [];
     
     for (const [name, plugin] of plugins) {

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

@@ -1,20 +1,14 @@
-'use strict';
-
-const {basename} = require('node:path');
-
-const {isEnabled} = require('../rules');
-
-const {prepareRules} = require('./prepare-rules');
-
-const validatePlugin = require('./validate-plugin');
-const {filterEnabledPlugins} = require('./filter-enabled-plugins');
-
-const {createAsyncLoader} = require('../load/async-loader');
-const {check, checkRule} = require('../check');
+import {basename} from 'node:path';
+import {isEnabled} from '../rules/index.js';
+import {prepareRules} from './prepare-rules.js';
+import validatePlugin from './validate-plugin.js';
+import {filterEnabledPlugins} from './filter-enabled-plugins.js';
+import {createAsyncLoader} from '../load/async-loader.js';
+import {check, checkRule} from '../check/index.js';
 
 const loadPluginAsync = createAsyncLoader('plugin');
 
-module.exports.loadPluginsAsync = async (options) => {
+export const loadPluginsAsync = async (options) => {
     check(options);
     
     const {pluginNames = [], rules = {}} = options;

package/lib/plugins/load-plugins.js

@@ -1,16 +1,15 @@
-'use strict';
+import {createRequire} from 'node:module';
+import validatePlugin from './validate-plugin.js';
+import {prepareRules} from './prepare-rules.js';
+import {isEnabled} from '../rules/index.js';
+import {filterEnabledPlugins} from './filter-enabled-plugins.js';
+import {check, checkRule} from '../check/index.js';
 
-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 require = createRequire(import.meta.url);
 
 const {isArray} = Array;
 
-module.exports.loadPlugins = (options) => {
+export const loadPlugins = (options) => {
     check(options);
     
     const {pluginNames = [], rules = {}} = options;
@@ -23,7 +22,7 @@ module.exports.loadPlugins = (options) => {
         pluginNames,
     });
     
-    const plugins = loadPlugins({
+    const plugins = loadAllPlugins({
         items,
         loadedRules,
     });
@@ -42,7 +41,7 @@ const parseRule = (rule) => rule
 
 const maybeFromTuple = (a) => isArray(a) ? a[1] : a;
 
-function loadPlugins({items, loadedRules}) {
+function loadAllPlugins({items, loadedRules}) {
     const plugins = [];
     
     for (const [rule, itemPlugin] of items) {
@@ -53,7 +52,7 @@ function loadPlugins({items, loadedRules}) {
         const parsedRule = parseRule(rule);
         
         const [name, namespace] = splitRule(rule);
-        const plugin = maybeFromTuple(itemPlugin) || loadPlugin({
+        const plugin = maybeFromTuple(itemPlugin) || loadOnePlugin({
             name,
             namespace,
         });
@@ -89,8 +88,8 @@ function extendRules(rule, plugin) {
 
 // add support of esm.sh
 // https://github.com/esm-dev/esm.sh/issues/1045
-function loadPlugin({name, namespace}) {
-    const {loadPlugin} = require('../load/load');
+function loadOnePlugin({name, namespace}) {
+    const {loadPlugin} = require('../load/load.js');
     
     return loadPlugin({
         name,

package/lib/plugins/parse-plugin-names.js

@@ -1,10 +1,8 @@
-'use strict';
-
 const isStr = (a) => typeof a === 'string';
 const {isArray} = Array;
 const {entries} = Object;
 
-module.exports.parsePluginNames = (plugins) => {
+export const parsePluginNames = (plugins) => {
     const result = [];
     
     for (const plugin of plugins) {

package/lib/plugins/prepare-rules.js

@@ -1,11 +1,8 @@
-'use strict';
+import {parsePluginNames} from './parse-plugin-names.js';
+import {enableNestedRules} from '../rules/parse-rules.js';
+import {parseRules, getLoadedRules} from '../rules/index.js';
 
-const {parsePluginNames} = require('./parse-plugin-names');
-const {enableNestedRules} = require('../rules/parse-rules');
-
-const {parseRules, getLoadedRules} = require('../rules');
-
-module.exports.prepareRules = ({rules, pluginNames}) => {
+export const prepareRules = ({rules, pluginNames}) => {
     const enabledRules = enableNestedRules(rules);
     const cookedEnabledRules = parseRules(enabledRules);
     const loadedRules = getLoadedRules(cookedEnabledRules);

package/lib/plugins/validate-plugin.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const supportedKeys = [
     'find',
     'traverse',
@@ -11,7 +9,7 @@ const supportedKeys = [
     'scan',
 ];
 
-module.exports = ({plugin, rule}) => {
+export default ({plugin, rule}) => {
     const keys = Object.keys(plugin);
     
     for (const key of supportedKeys) {

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

@@ -1,11 +1,8 @@
-'use strict';
+import {createAsyncLoader} from '../load/async-loader.js';
+import parseProcessorNames from '../processors/parse-processor-names.js';
+import {check} from '../check/index.js';
 
-const {createAsyncLoader} = require('../load/async-loader');
-const parseProcessorNames = require('../processors/parse-processor-names');
-
-const {check} = require('../check');
-
-module.exports.loadProcessorsAsync = async (options, simpleImport) => {
+export const loadProcessorsAsync = async (options, simpleImport) => {
     check(options);
     
     const {processors = []} = options;

package/lib/processors/parse-processor-names.js

@@ -1,12 +1,10 @@
-'use strict';
-
 const isStr = (a) => typeof a === 'string';
 const {isArray} = Array;
 
 const isOn = (a) => a === 'on';
 const isOff = (a) => a === 'off';
 
-module.exports = (plugins) => {
+export default (plugins) => {
     const result = [];
     
     for (const plugin of plugins) {

package/lib/rules/get-loaded-rules.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.getLoadedRules = (rules) => {
+export const getLoadedRules = (rules) => {
     const loadedRules = [];
     
     for (const item of rules) {

package/lib/rules/index.js

@@ -1,15 +1,5 @@
-'use strict';
-
-const {parseRules} = require('./parse-rules');
-const {mergeRules} = require('./merge-rules');
-const {validateRules} = require('./validate-rules');
-const {isEnabled} = require('./is-enabled');
-const {getLoadedRules} = require('./get-loaded-rules');
-
-module.exports = {
-    parseRules,
-    mergeRules,
-    validateRules,
-    isEnabled,
-    getLoadedRules,
-};
+export {parseRules} from './parse-rules.js';
+export {mergeRules} from './merge-rules.js';
+export {validateRules} from './validate-rules.js';
+export {isEnabled} from './is-enabled.js';
+export {getLoadedRules} from './get-loaded-rules.js';

package/lib/rules/is-enabled.js

@@ -1,6 +1,4 @@
-'use strict';
-
-module.exports.isEnabled = (name, rules) => {
+export const isEnabled = (name, rules) => {
     for (const {rule, state} of rules) {
         if (rule === name)
             return state;

package/lib/rules/merge-rules.js

@@ -1,8 +1,6 @@
-'use strict';
-
 const defaultOptions = () => Object.create(null);
 
-module.exports.mergeRules = ([rule, plugin], rules) => {
+export const mergeRules = ([rule, plugin], rules) => {
     for (const currentRule of rules) {
         if (currentRule.rule !== rule)
             continue;

package/lib/rules/parse-rules.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const {isArray} = Array;
 const isBool = (a) => typeof a === 'boolean';
 const isStr = (a) => typeof a === 'string';
@@ -24,7 +22,7 @@ const parseState = (rule, value) => {
     return value;
 };
 
-module.exports.parseRules = (rules) => {
+export const parseRules = (rules) => {
     const result = [];
     const plugin = null;
     const msg = '';
@@ -118,7 +116,7 @@ function validateState(rule, value) {
 
 const cut = (a) => a.split('/')[0];
 
-module.exports.enableNestedRules = (rules) => {
+export const enableNestedRules = (rules) => {
     const newRules = {};
     
     for (const [rule, value] of entries(rules)) {

package/lib/rules/validate-rules.js

@@ -1,5 +1,3 @@
-'use strict';
-
 const parseSlashes = (rule) => {
     if (rule.includes('/'))
         return rule
@@ -15,7 +13,7 @@ const parsePluginName = (a) => {
         .replace('@putout/plugin-', '');
 };
 
-module.exports.validateRules = ({items, rules}) => {
+export const validateRules = ({items, rules}) => {
     const ruleItems = Object.keys(rules);
     
     for (const rule of ruleItems) {

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

@@ -1,10 +1,8 @@
-'use strict';
+import {parsePluginNames} from '../plugins/parse-plugin-names.js';
+import {validateRules} from '../rules/index.js';
+import {check} from '../check/index.js';
 
-const {parsePluginNames} = require('../plugins/parse-plugin-names');
-const {validateRules} = require('../rules');
-const {check} = require('../check');
-
-module.exports.validateRulesRelations = (options) => {
+export const validateRulesRelations = (options) => {
     check(options);
     
     const {pluginNames = [], rules = {}} = options;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@putout/engine-loader",
-  "version": "16.3.1",
-  "type": "commonjs",
+  "version": "17.0.0",
+  "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "load plugins and prepare them to run",
   "homepage": "https://github.com/coderaiser/putout/tree/master/packages/engine-loader#readme",