@putout/plugin-putout 20.7.0 → 20.9.0

package/lib/check-replace-code/generate-code/index.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const {parse, print, transform} = require('putout');
+const tryCatch = require('try-catch');
+const pluginGenerate = require('./plugin-generate');
+
+module.exports = (rootPath, source) => {
+    const [parseError, ast] = tryCatch(parse, source, {
+        isTS: true,
+    });
+    
+    if (parseError)
+        return [parseError];
+     
+    const getVar = createVarStore(rootPath);
+    
+     transform(ast, source, {
+        rules: {
+            'generate': ['on', {
+                getVar,
+            }],
+        },
+        plugins: [
+            ['generate', pluginGenerate],
+        ]
+    });
+    
+    
+    const code = print(ast);
+    
+    return [null, code];
+};
+
+function createVarStore(path) {
+    const store = {};
+
+    return (name) => {
+        if (store[name])
+            return store[name];
+
+        store[name] = path.scope.generateUid();
+
+        return store[name];
+    };
+}

package/lib/check-replace-code/generate-code/plugin-generate.js

@@ -0,0 +1,87 @@
+'use strict';
+
+const {operator, types} = require('putout');
+const {
+    ObjectPattern,
+    BlockStatement,
+    Identifier,
+    ArrayPattern,
+    ObjectExpression,
+} = types;
+const {replaceWith} = operator;
+const noop = () => {};
+
+module.exports.report = noop;
+
+module.exports.include = () => [
+    'Identifier',
+    'StringLiteral',
+];
+
+module.exports.fix = (path, {options}) => {
+    const {getVar} = options;
+    const {node} = path;
+    
+    const {value, name} = node;
+    
+    if (path.isStringLiteral() && /^__[a-z]$/.test(value)) {
+        path.node.value = getVar(name);
+        return;
+    }
+    
+    if (/^__identifier__[a-z]$/.test(name)) {
+        path.node.name = getVar(name);
+        return;
+    }
+    
+    if (/^__[a-z]$/.test(name)) {
+        path.node.name = getVar(name);
+        return;
+    }
+    
+    if (/__args/.test(name)) {
+        path.node.name = getVar(name);
+        return;
+    }
+    
+    if (name === '__array') {
+        if (path.parentPath.isCallExpression())
+            return replaceWith(path, ArrayPattern([]));
+        
+        if (path.parentPath.isFunction())
+            return replaceWith(path, ArrayPattern([]));
+    }
+    
+    if (name === '__object')
+        return objectify(path);
+    
+    if (name === '__body') {
+        if (path.parentPath.isClassProperty()) {
+            const key = Identifier(getVar());
+            
+            replaceWith(path, key);
+            
+            return;
+        }
+        
+        replaceWith(path, BlockStatement([]));
+    }
+};
+
+function objectify(path) {
+    const {parentPath} = path;
+    const isAssign = parentPath.isAssignmentExpression();
+    const isVar = parentPath.isVariableDeclarator();
+    
+    if (path.parentPath.isExportDeclaration())
+        return replaceWith(path, ObjectExpression([]));
+    
+    if (path.parentPath.isCallExpression())
+        return replaceWith(path, ObjectExpression([]));
+    
+    if (isAssign && parentPath.get('right') === path)
+        return replaceWith(path, ObjectExpression([]));
+    
+    if (isVar && parentPath.get('id') === path)
+        return replaceWith(path, ObjectPattern([]));
+}

package/lib/check-replace-code/index.js

@@ -38,79 +38,91 @@ module.exports.fix = ({mainPath}) => {
 };
 
 module.exports.traverse = ({push}) => ({
-    'module.exports.replace = () => __a': (path) => {
-        if (get(path))
-            return;
+    'module.exports.replace = () => __a': createTraverseReplacer(push),
+    'export const replace = () => __a': createTraverseReplacer(push),
+});
+
+function getProperties(path) {
+    const props = `body.properties`;
+    
+    if (path.isExportNamedDeclaration())
+        return path.get(`declaration.declarations.0.init.${props}`);
+    
+    return path.get(`right.${props}`);
+}
+
+const createTraverseReplacer = (push) => (path) => {
+    if (get(path))
+        return;
+    
+    if (hasMatch(path))
+        return;
+    
+    for (const propertyPath of getProperties(path)) {
+        const template = extractValue(propertyPath);
         
-        if (hasMatch(path))
-            return;
+        if (!template)
+            continue;
         
-        for (const propertyPath of path.get('right.body.properties')) {
-            const template = extractValue(propertyPath);
-            
-            if (!template)
-                continue;
-            
-            const [parseError, key] = parseKey(propertyPath);
-            
-            if (parseError) {
-                push({
-                    error: parseError,
-                    mainPath: path,
-                    path: propertyPath,
-                });
-                
-                return;
-            }
-            
-            const [generateError, keyCode] = generateCode(path, key);
-            
-            if (generateError) {
-                push({
-                    error: generateError,
-                    mainPath: path,
-                    path: propertyPath,
-                });
-                
-                return;
-            }
-            
-            const [transformError, result] = tryCatch(putout, keyCode, {
-                printer: 'putout',
-                fix: true,
-                isTS: true,
-                plugins: [
-                    ['evaluate', {
-                        report: noop,
-                        replace: () => ({
-                            [key]: template,
-                        }),
-                    }],
-                ],
+        const [parseError, key] = parseKey(propertyPath);
+        
+        if (parseError) {
+            push({
+                error: parseError,
+                mainPath: path,
+                path: propertyPath,
             });
             
-            if (transformError) {
-                push({
-                    error: transformError,
-                    mainPath: path,
-                    path: propertyPath,
-                });
-                
-                return;
-            }
+            return;
+        }
+        
+        const [generateError, keyCode] = generateCode(path, key);
+        
+        if (generateError) {
+            push({
+                error: generateError,
+                mainPath: path,
+                path: propertyPath,
+            });
             
-            const code = result.code.slice(0, -1);
-            const [error, is] = tryCatch(compare, rmSemi(code), template);
+            return;
+        }
+        
+        const [transformError, result] = tryCatch(putout, keyCode, {
+            printer: 'putout',
+            fix: true,
+            isTS: true,
+            plugins: [
+                ['evaluate', {
+                    report: noop,
+                    replace: () => ({
+                        [key]: template,
+                    }),
+                }],
+            ],
+        });
+        
+        if (transformError) {
+            push({
+                error: transformError,
+                mainPath: path,
+                path: propertyPath,
+            });
             
-            if (error || !is)
-                push({
-                    code,
-                    mainPath: path,
-                    path: propertyPath,
-                });
+            return;
         }
-    },
-});
+        
+        const code = result.code.slice(0, -1);
+        const [error, is] = tryCatch(compare, rmSemi(code), template);
+        
+        if (error || !is)
+            push({
+                code,
+                mainPath: path,
+                path: propertyPath,
+            });
+    }
+};
 
 function parseKey(propertyPath) {
     const keyPath = propertyPath.get('key');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-putout",
-  "version": "20.7.0",
+  "version": "20.9.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin helps with plugins development",

package/lib/check-replace-code/generate-code.js

@@ -1,120 +0,0 @@
-'use strict';
-
-const putout = require('putout');
-const tryCatch = require('try-catch');
-
-const noop = () => {};
-const {types, operator} = putout;
-
-const {
-    ArrayPattern,
-    BlockStatement,
-    ObjectExpression,
-    ObjectPattern,
-    Identifier,
-} = types;
-
-const {replaceWith} = operator;
-
-module.exports = (rootPath, key) => {
-    const getVar = createVarStore(rootPath);
-    
-    const [transformError, result] = tryCatch(putout, key, {
-        printer: 'putout',
-        fix: true,
-        isTS: true,
-        plugins: [
-            ['generate', {
-                report: noop,
-                include: () => [
-                    'Identifier',
-                    'StringLiteral',
-                ],
-                fix: (path) => {
-                    const {node} = path;
-                    
-                    const {value, name} = node;
-                    
-                    if (path.isStringLiteral() && /^__[a-z]$/.test(value)) {
-                        path.node.value = getVar(name);
-                        return;
-                    }
-                    
-                    if (/^__identifier__[a-z]$/.test(name)) {
-                        path.node.name = getVar(name);
-                        return;
-                    }
-                    
-                    if (/^__[a-z]$/.test(name)) {
-                        path.node.name = getVar(name);
-                        return;
-                    }
-                    
-                    if (/__args/.test(name)) {
-                        path.node.name = getVar(name);
-                        return;
-                    }
-                    
-                    if (name === '__array') {
-                        if (path.parentPath.isCallExpression())
-                            return replaceWith(path, ArrayPattern([]));
-                        
-                        if (path.parentPath.isFunction())
-                            return replaceWith(path, ArrayPattern([]));
-                    }
-                    
-                    if (name === '__object')
-                        return objectify(path);
-                    
-                    if (name === '__body') {
-                        if (path.parentPath.isClassProperty()) {
-                            const key = Identifier(getVar());
-                            
-                            replaceWith(path, key);
-                            
-                            return;
-                        }
-                        
-                        replaceWith(path, BlockStatement([]));
-                    }
-                },
-            }],
-        ],
-    });
-    
-    return [
-        transformError,
-        result?.code,
-    ];
-};
-
-function createVarStore(path) {
-    const store = {};
-    
-    return (name) => {
-        if (store[name])
-            return store[name];
-        
-        store[name] = path.scope.generateUid();
-        
-        return store[name];
-    };
-}
-
-function objectify(path) {
-    const {parentPath} = path;
-    const isAssign = parentPath.isAssignmentExpression();
-    const isVar = parentPath.isVariableDeclarator();
-    
-    if (path.parentPath.isExportDeclaration())
-        return replaceWith(path, ObjectExpression([]));
-    
-    if (path.parentPath.isCallExpression())
-        return replaceWith(path, ObjectExpression([]));
-    
-    if (isAssign && parentPath.get('right') === path)
-        return replaceWith(path, ObjectExpression([]));
-    
-    if (isVar && parentPath.get('id') === path)
-        return replaceWith(path, ObjectPattern([]));
-}