@putout/plugin-variables 1.4.0 → 1.6.0

package/README.md

@@ -17,8 +17,10 @@ npm i @putout/plugin-variables -D
 
 ## Rules
 
+- ✅ [apply-declarations-order](#apply-declarations-order);
 - ✅ [convert-const-to-let](#convert-const-to-let');
 - ✅ [extract-keywords](#extract-keywords');
+- ✅ [reuse-duplicate-init](#reuse-duplicate-init);
 - ✅ [remove-useless-assignment](#remove-useless-assignmenn);
 - ✅ [remove-useless-declaration](#remove-useless-declaration);
 - ✅ [remove-useless-duplicate](#remove-useless-duplicate);
@@ -32,8 +34,10 @@ npm i @putout/plugin-variables -D
 ```json
 {
     "rules": {
+        "variables/apply-declarations-order": "on",
         "variables/convert-const-to-let": "on",
         "variables/extract-keywords": "on",
+        "variables/reuse-duplicate-init": "on",
         "variables/remove-useless-assignment": "on",
         "variables/remove-useless-declaration": ["on", {
             "maxLength": 20
@@ -47,6 +51,24 @@ npm i @putout/plugin-variables -D
 }
 ```
 
+## apply-declarations-order
+
+Helps to [reuse duplicate init](#reuse-duplicate-init'). Checkout in 🐊[**Putout Editor**](https://putout.vercel.app/#/gist/b70ff926b36e1e97ec7129aa0e0458a7/ece0a706de2fd24a66b4671284f7f75017f3c268).
+
+### ❌ Example of incorrect code
+
+```js
+const {env} = require('node:process');
+const process = require('node:process');
+```
+
+### ✅ Example of correct code
+
+```js
+const process = require('node:process');
+const {env} = process;
+```
+
 ## assignment
 
 Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/a2f7fe5e2c294443576f95dce6fde67e/0699ccb4f7335e8e3f80de891913a8e3ad4f35e3).
@@ -63,6 +85,42 @@ while (!(files = readDirectory(parentDir)).length) {}
 while (!readDirectory(parentDir).length) {}
 ```
 
+## reuse-duplicate-init
+
+> Functions are one of the fundamental building blocks it contains set of statements that performs a calculations, takes some input and returns an output. To use a function, you must define it somewhere in the scope from which you wish to call it.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to reuse duplicate init.
+
+### ❌ Example of incorrect code
+
+```js
+const putout = require('putout');
+
+const {
+    a,
+    b,
+    operator,
+} = putout;
+
+const {replaceWith} = operator;
+```
+
+### ✅ Example of correct code
+
+```js
+const putout = require('putout');
+
+const {
+    a,
+    b,
+    operator,
+} = putout;
+
+const {replaceWith} = operator;
+```
+
 ## remove-useless-rename
 
 ### ❌ Example of incorrect code

package/lib/apply-declarations-order/index.js

@@ -0,0 +1,54 @@
+import {types, operator} from 'putout';
+
+const {
+    insertAfter,
+    remove,
+    compare,
+    getTemplateValues,
+} = operator;
+
+const {
+    isVariableDeclaration,
+    isIdentifier,
+    isCallExpression,
+    isObjectPattern,
+} = types;
+
+export const report = () => `Apply declarations order`;
+
+export const fix = ({path, current}) => {
+    const {node} = current;
+    remove(current);
+    insertAfter(path, node);
+};
+
+export const traverse = ({push}) => ({
+    'const __a = __b': (path) => {
+        const {__a, __b} = getTemplateValues(path, 'const __a = __b');
+        
+        if (!isIdentifier(__a))
+            return;
+        
+        if (!isCallExpression(__b))
+            return;
+        
+        const prev = path.getAllPrevSiblings();
+        
+        for (const current of prev.filter(isObjectDestructuring)) {
+            const {__d} = getTemplateValues(current, 'const __c = __d');
+            
+            if (compare(__b, __d))
+                push({
+                    current,
+                    path,
+                });
+        }
+    },
+});
+
+function isObjectDestructuring(path) {
+    if (!isVariableDeclaration(path))
+        return false;
+    
+    return isObjectPattern(path.node.declarations[0].id);
+}

package/lib/index.js

@@ -1,5 +1,7 @@
+import * as applyDeclarationsOrder from './apply-declarations-order/index.js';
 import * as convertConstToLet from './convert-const-to-let/index.js';
 import * as extractKeywords from './extract-keywords/index.js';
+import * as reuseDuplicateInit from './reuse-duplicate-init/index.js';
 import * as removeUseless from './remove-useless/index.js';
 import * as removeUselessAssignment from './remove-useless-assignment/index.js';
 import * as removeUselessDeclarations from './remove-useless-declarations/index.js';
@@ -10,8 +12,10 @@ import * as removeUnused from './remove-unused/index.js';
 import * as splitDeclarations from './split-declarations/index.js';
 
 export const rules = {
+    'apply-declarations-order': applyDeclarationsOrder,
     'convert-const-to-let': convertConstToLet,
     'extract-keywords': extractKeywords,
+    'reuse-duplicate-init': reuseDuplicateInit,
     'remove-useless': removeUseless,
     'remove-useless-assignment': removeUselessAssignment,
     'remove-useless-declarations': removeUselessDeclarations,

package/lib/remove-unused/get-vars/get-vars.js

@@ -23,12 +23,12 @@ const {
     isFunctionDeclaration,
     isArrayExpression,
     isRestElement,
+    isArrayPattern,
 } = types;
 
 export default ({use, declare, addParams}) => {
     const traverseObj = traverseObjectExpression(use);
-    
-    const processObj = processObjectPattern({
+    const declareObject = processObjectPattern({
         use,
         declare,
     });
@@ -64,7 +64,7 @@ export default ({use, declare, addParams}) => {
             const param = path.get('param');
             
             if (param.isObjectPattern())
-                return processObj(param.get('properties'));
+                return declareObject(param.get('properties'));
             
             if (!param.isIdentifier())
                 return;
@@ -141,7 +141,7 @@ export default ({use, declare, addParams}) => {
                 
                 for (const elPath of elements) {
                     if (elPath.isObjectPattern()) {
-                        processObj(elPath.get('properties'));
+                        declareObject(elPath.get('properties'));
                         continue;
                     }
                     
@@ -213,7 +213,7 @@ export default ({use, declare, addParams}) => {
                 use(rightPath, rightPath.node.name);
         },
         
-        'ArrayExpression'(path) {
+        ArrayExpression(path) {
             const {elements} = path.node;
             
             for (const el of elements) {
@@ -557,7 +557,12 @@ export default ({use, declare, addParams}) => {
                 
                 /* istanbul ignore else */
                 if (isObjectPattern(node)) {
-                    processObj(paramPath.get('properties'));
+                    declareObject(paramPath.get('properties'));
+                    continue;
+                }
+                
+                if (isArrayPattern(node)) {
+                    declareArray(paramPath.get('elements'));
                     continue;
                 }
             }

package/lib/remove-unused/get-vars/traverse.js

@@ -125,6 +125,9 @@ export const traverseArrayExpression = (use) => {
         for (const elementPath of elementsPaths) {
             const {node} = elementPath;
             
+            if (isIdentifier(node))
+                use(elementPath, node.name);
+            
             if (node.properties)
                 traverseObjExpression(elementPath.get('properties'));
         }

package/lib/reuse-duplicate-init/index.js

@@ -0,0 +1,54 @@
+import {operator} from 'putout';
+
+const {replaceWith} = operator;
+
+export const report = () => 'Reuse duplicate init';
+
+export const fix = ({path, newPath}) => {
+    replaceWith(path.get('declarations.0.init'), newPath);
+};
+
+export const exclude = () => [
+    'const __a = __identifier',
+];
+
+export const traverse = ({push, store}) => ({
+    'const __identifier = __b'(path) {
+        const idPath = path.get('declarations.0.id');
+        const initPath = path.get('declarations.0.init');
+        const initName = initPath.toString();
+        
+        store(initName, idPath);
+    },
+    
+    'const __object = __b'(path) {
+        const initPath = path.get('declarations.0.init');
+        const initName = initPath.toString();
+        
+        for (const propPath of path.get('declarations.0.id.properties')) {
+            if (propPath.isRestElement())
+                continue;
+            
+            const nestedPath = propPath.get('key');
+            const nestedName = nestedPath.toString();
+            
+            store(`${initName}.${nestedName}`, nestedPath);
+        }
+        
+        const newPath = store(initName);
+        
+        if (!newPath || !newPath.node)
+            return;
+        
+        if (path === newPath.parentPath.parentPath)
+            return;
+        
+        if (path.scope.uid !== newPath.scope.uid)
+            return;
+        
+        push({
+            path,
+            newPath,
+        });
+    },
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-variables",
-  "version": "1.4.0",
+  "version": "1.6.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to find and remove useless",
@@ -42,6 +42,7 @@
     "@putout/plugin-nodejs": "*",
     "@putout/plugin-putout": "*",
     "@putout/plugin-reuse-duplicate-init": "*",
+    "@putout/plugin-tape": "*",
     "@putout/test": "^14.0.0",
     "c8": "^10.0.0",
     "eslint": "^10.0.0-alpha.0",