eslint-plugin-putout 19.1.0 → 19.3.0

package/lib/index.js

@@ -109,6 +109,29 @@ const recommended = {
     plugins: ['n'],
 };
 
+const safeRules = {
+    'apply-template-literals': 'off',
+    'remove-empty': 'off',
+    'nodejs/remove-process-exit': 'off',
+    'typescript/remove-unused-types': 'off',
+    'remove-unused-variables': 'off',
+    'remove-unused-expressions': 'off',
+    'remove-unreachable-code': 'off',
+    'remove-useless-arguments': 'off',
+    'remove-useless-variables/rename': 'off',
+    'remove-useless-return': 'off',
+    'remove-useless-spread': 'off',
+    'remove-unreferenced-variables': 'off',
+    'tape/remove-skip': 'off',
+    'tape/remove-only': 'off',
+    'remove-console': 'off',
+    'remove-debugger': 'off',
+    'for-of/for': 'off',
+    'for-of/remove-unused-variables': 'off',
+    'for-of/remove-useless': 'off',
+    'maybe/noop': 'off',
+};
+
 const safe = {
     ...recommended,
     rules: {
@@ -118,28 +141,27 @@ const safe = {
         'putout/align-spaces': 'off',
         'putout/remove-newline-from-empty-object': 'off',
         'putout/putout': ['error', {
-            rules: {
-                'apply-template-literals': 'off',
-                'remove-empty': 'off',
-                'nodejs/remove-process-exit': 'off',
-                'typescript/remove-unused-types': 'off',
-                'remove-unused-variables': 'off',
-                'remove-unused-expressions': 'off',
-                'remove-unreachable-code': 'off',
-                'remove-useless-arguments': 'off',
-                'remove-useless-variables/rename': 'off',
-                'remove-useless-return': 'off',
-                'remove-useless-spread': 'off',
-                'remove-unreferenced-variables': 'off',
-                'tape/remove-skip': 'off',
-                'tape/remove-only': 'off',
-                'remove-console': 'off',
-                'remove-debugger': 'off',
-                'for-of/for': 'off',
-                'for-of/remove-unused-variables': 'off',
-                'for-of/remove-useless': 'off',
-                'maybe/noop': 'off',
-            },
+            esm: false,
+            rules: safeRules,
+        }],
+    },
+};
+
+const safeAlign = {
+    ...safe,
+    rules: {
+        ...safe.rules,
+        'putout/align-spaces': 'error',
+    },
+};
+
+const esm = {
+    ...safeAlign,
+    rules: {
+        ...safeAlign.rules,
+        'putout/putout': ['error', {
+            esm: true,
+            rules: safeRules,
         }],
     },
 };
@@ -148,11 +170,6 @@ module.exports.configs = {
     recommended,
     'jsx': jsx.jsx,
     safe,
-    'safe+align': {
-        ...safe,
-        rules: {
-            ...safe.rules,
-            'putout/align-spaces': 'error',
-        },
-    },
+    'safe+align': safeAlign,
+    esm,
 };

package/lib/putout/async/find-places.mjs

@@ -0,0 +1,13 @@
+import {findPlacesAsync} from 'putout';
+import tryToCatch from 'try-to-catch';
+import {runAsWorker} from 'synckit';
+import parseOptions from 'putout/parse-options';
+
+runAsWorker(async ({name, options, ast, text}) => {
+    const resultOptions = parseOptions({
+        name,
+        options,
+    });
+    
+    return await tryToCatch(findPlacesAsync, ast, text, resultOptions);
+});

package/lib/putout/async/index.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const tryCatch = require('try-catch');
+const {createSyncFn} = require('synckit');
+
+const {
+    ignores,
+    print,
+    parse,
+} = require('putout');
+
+const parseOptions = require('putout/parse-options');
+const {parseError} = require('../parse-error');
+
+const cwd = process.cwd();
+
+const findPlacesSync = createSyncFn(require.resolve('./find-places.mjs'));
+const transformSync = createSyncFn(require.resolve('./transform.mjs'));
+
+const EMPTY_VISITORS = {};
+
+module.exports = ({context, options}) => {
+    const name = context.filename;
+    const resultOptions = parseOptions({
+        name,
+        options,
+    });
+    
+    if (ignores(cwd, name, resultOptions))
+        return EMPTY_VISITORS;
+    
+    const source = context.sourceCode;
+    const {text} = source;
+    const node = source.ast;
+    
+    const [errorParser, ast] = tryCatch(parse, text, {
+        isTS: true,
+    });
+    
+    if (errorParser) {
+        context.report({
+            message: `${parseError(errorParser)} (putout)`,
+            node,
+        });
+        
+        return EMPTY_VISITORS;
+    }
+    
+    const [error, places = []] = findPlacesSync({
+        name,
+        options,
+        ast,
+        text,
+    });
+    
+    if (error) {
+        context.report({
+            message: `${parseError(error)} (putout)`,
+            node,
+        });
+        
+        return EMPTY_VISITORS;
+    }
+    
+    const rules = getRules(places);
+    
+    for (const {rule, message, position} of places) {
+        context.report({
+            message: `${message} (${rule})`,
+            fix: fix({
+                ast,
+                text,
+                name,
+                node,
+                source,
+                options,
+                rules,
+            }),
+            loc: {
+                start: position,
+                end: position,
+            },
+        });
+    }
+    
+    return EMPTY_VISITORS;
+};
+
+const fix = ({name, ast, text, node, options, source, rules}) => (fixer) => {
+    const lastToken = source.getLastToken(node, {
+        includeComments: true,
+    });
+    
+    ast = transformSync({
+        name,
+        options,
+        ast,
+        text,
+        rules,
+    });
+    
+    const [, last] = lastToken.range;
+    const code = print(ast);
+    
+    return fixer.replaceTextRange([0, last], code);
+};
+
+function getRules(places) {
+    const rules = [];
+    
+    for (const {rule} of places) {
+        rules.push(rule);
+    }
+    
+    return [...new Set(rules)];
+}

package/lib/putout/async/transform.mjs

@@ -0,0 +1,14 @@
+import {transformAsync} from 'putout';
+import {runAsWorker} from 'synckit';
+import parseOptions from 'putout/parse-options';
+
+runAsWorker(async ({name, options, ast, text}) => {
+    const resultOptions = parseOptions({
+        name,
+        options,
+    });
+    
+    await transformAsync(ast, text, resultOptions);
+    
+    return ast;
+});

package/lib/putout/index.js

@@ -1,27 +1,10 @@
 'use strict';
 
-const tryCatch = require('try-catch');
-
-const {
-    ignores,
-    findPlaces,
-    transform,
-    print,
-    parse,
-} = require('putout');
-
-const parseOptions = require('putout/parse-options');
-const {parseError} = require('./parse-error');
-
-const cwd = process.cwd();
-
 const getContextOptions = ({options}) => {
     const [allContextOptions = {}] = options;
     return allContextOptions;
 };
 
-const EMPTY_VISITORS = {};
-
 module.exports = {
     meta: {
         type: 'suggestion',
@@ -35,78 +18,22 @@ module.exports = {
     },
     
     create(context) {
-        const name = context.filename;
-        const options = getContextOptions(context);
-        
-        const resultOptions = parseOptions({
-            name,
-            options,
-        });
-        
-        if (ignores(cwd, name, resultOptions))
-            return EMPTY_VISITORS;
+        const {esm, ...options} = getContextOptions(context);
         
-        const source = context.sourceCode;
-        const {text} = source;
-        const node = source.ast;
-        
-        const [errorParser, ast] = tryCatch(parse, text, {
-            isTS: true,
-        });
-        
-        if (errorParser) {
-            context.report({
-                message: `${parseError(errorParser)} (putout)`,
-                node,
-            });
+        if (esm) {
+            const putoutAsync = require('./async');
             
-            return EMPTY_VISITORS;
-        }
-        
-        const [error, places = []] = tryCatch(findPlaces, ast, text, resultOptions);
-        
-        if (error) {
-            context.report({
-                message: `${parseError(error)} (putout)`,
-                node,
+            return putoutAsync({
+                context,
+                options,
             });
-            
-            return EMPTY_VISITORS;
         }
         
-        for (const {rule, message, position} of places) {
-            context.report({
-                message: `${message} (${rule})`,
-                fix: fix({
-                    ast,
-                    text,
-                    node,
-                    source,
-                    resultOptions,
-                }),
-                loc: {
-                    start: position,
-                    end: position,
-                },
-            });
-        }
+        const putoutSync = require('./sync');
         
-        return EMPTY_VISITORS;
+        return putoutSync({
+            context,
+            options,
+        });
     },
 };
-
-const fix = ({ast, text, node, source, resultOptions}) => (fixer) => {
-    const includeComments = true;
-    
-    const lastToken = source.getLastToken(node, {
-        includeComments,
-    });
-    
-    transform(ast, text, resultOptions);
-    
-    const [, last] = lastToken.range;
-    
-    const code = print(ast);
-    
-    return fixer.replaceTextRange([0, last], code);
-};

package/lib/putout/sync/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const tryCatch = require('try-catch');
+
+const {
+    ignores,
+    findPlaces,
+    transform,
+    print,
+    parse,
+} = require('putout');
+
+const parseOptions = require('putout/parse-options');
+const {parseError} = require('../parse-error');
+
+const cwd = process.cwd();
+
+const EMPTY_VISITORS = {};
+
+module.exports = ({context, options}) => {
+    const name = context.filename;
+    const resultOptions = parseOptions({
+        name,
+        options,
+    });
+    
+    if (ignores(cwd, name, resultOptions))
+        return EMPTY_VISITORS;
+    
+    const source = context.sourceCode;
+    const {text} = source;
+    const node = source.ast;
+    
+    const [errorParser, ast] = tryCatch(parse, text, {
+        isTS: true,
+    });
+    
+    if (errorParser) {
+        context.report({
+            message: `${parseError(errorParser)} (putout)`,
+            node,
+        });
+        
+        return EMPTY_VISITORS;
+    }
+    
+    const [error, places = []] = tryCatch(findPlaces, ast, text, resultOptions);
+    
+    if (error) {
+        context.report({
+            message: `${parseError(error)} (putout)`,
+            node,
+        });
+        
+        return EMPTY_VISITORS;
+    }
+    
+    for (const {rule, message, position} of places) {
+        context.report({
+            message: `${message} (${rule})`,
+            fix: fix({
+                ast,
+                text,
+                node,
+                source,
+                resultOptions,
+            }),
+            loc: {
+                start: position,
+                end: position,
+            },
+        });
+    }
+    
+    return EMPTY_VISITORS;
+};
+
+const fix = ({ast, text, node, source, resultOptions}) => (fixer) => {
+    const includeComments = true;
+    
+    const lastToken = source.getLastToken(node, {
+        includeComments,
+    });
+    
+    transform(ast, text, resultOptions);
+    
+    const [, last] = lastToken.range;
+    
+    const code = print(ast);
+    
+    return fixer.replaceTextRange([0, last], code);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-putout",
-  "version": "19.1.0",
+  "version": "19.3.0",
   "type": "commonjs",
   "description": "ESLint plugin for 🐊Putout",
   "release": false,
@@ -50,7 +50,9 @@
     "eslint-plugin-n": "^16.0.0",
     "eslint-plugin-react": "^7.32.2",
     "parse-import-specifiers": "^1.0.1",
+    "synckit": "^0.8.5",
     "try-catch": "^3.0.0",
+    "try-to-catch": "^3.0.1",
     "typescript": "^5.0.4"
   },
   "devDependencies": {
@@ -64,8 +66,7 @@
     "mocha": "^10.0.0",
     "montag": "^1.0.0",
     "simport": "^1.2.0",
-    "supertape": "^8.0.0",
-    "try-to-catch": "^3.0.0"
+    "supertape": "^8.0.0"
   },
   "engines": {
     "node": ">=16"