@putout/plugin-destructuring 1.2.0 → 1.4.0

package/README.md

@@ -17,9 +17,11 @@ npm i @putout/plugin-destructuring
 
 ## Rules
 
-- ✅ [apply-object](#apply-object);
 - ✅ [apply-array](#apply-array);
+- ✅ [apply-object](#apply-object);
+- ✅ [apply-declarations-order](#apply-declarations-order);
 - ✅ [convert-object-to-array](#convert-object-to-array);
+- ✅ [extract-properties](#extract-properties);
 - ✅ [remove-useless-object](#remove-useless-object);
 - ✅ [remove-useless-arguments](#remove-useless-arguments);
 - ✅ [remove-useless-variables](#remove-useless-variables);
@@ -32,9 +34,11 @@ npm i @putout/plugin-destructuring
 ```json
 {
     "rules": {
-        "destructuring/apply-object": "on",
         "destructuring/apply-array": "on",
+        "destructuring/apply-object": "on",
+        "destructuring/apply-declarations-order": "on",
         "destructuring/convert-object-to-array": "on",
+        "destructuring/extract-properties": "on",
         "destructuring/remove-useless-object": "on",
         "destructuring/remove-useless-arguments": "on",
         "destructuring/remove-useless-variables": "on",
@@ -53,7 +57,7 @@ npm i @putout/plugin-destructuring
 const first = array[0];
 ```
 
-## ✅ Example of correct code
+### ✅ Example of correct code
 
 ```js
 const [first] = array;
@@ -77,6 +81,24 @@ const {name} = user;
 ({hello} = world);
 ```
 
+## apply-declarations-order
+
+Helps to [extract-properties](#extract-properties'). 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;
+```
+
 ## remove-useless-object
 
 Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/c9ed04b421d75ae39e58038fa6e14630/4c097e3173990ec7e5ebabbe2cedf8e952092ebf).
@@ -118,8 +140,6 @@ const [a, b] = c;
 >
 > (c) [Destructuring in JavaScript: the not so good parts](https://goodguydaniel.com/blog/destructuring-not-so-good-parts)
 
-🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to split nested destructuring.
-
 ### ❌ Example of incorrect code
 
 ```js
@@ -196,7 +216,7 @@ const {one, two} = require('numbers');
 } = data);
 ```
 
-### remove-useless-arguments
+## remove-useless-arguments
 
 ### ❌ Example of incorrect code
 
@@ -237,6 +257,42 @@ function hi(c) {
 function hi({a, b}) {}
 ```
 
+## extract-properties
+
+### Equal Deep
+
+#### ❌ Example of incorrect code
+
+```js
+const {replaceWith} = a.operate;
+const {isIdentifier} = a.types;
+```
+
+#### ✅ Example of correct code
+
+```js
+const {operator, types} = a;
+
+const {replaceWith} = operator;
+const {isIdentifier} = types;
+```
+
+### Not Equal Deep
+
+#### ❌ Example of incorrect code
+
+```js
+const {replaceWith} = a;
+const {isIdentifier} = a.types;
+```
+
+#### ✅ Example of correct code
+
+```js
+const {replaceWith, types} = a;
+const {isIdentifier} = types;
+```
+
 ## License
 
 MIT

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

@@ -0,0 +1,40 @@
+import {types, operator} from 'putout';
+
+const {
+    insertAfter,
+    remove,
+    compare,
+    getTemplateValues,
+} = operator;
+
+const {
+    isVariableDeclaration,
+    isIdentifier,
+} = 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;
+        
+        const prev = path.getAllPrevSiblings();
+        
+        for (const current of prev.filter(isVariableDeclaration)) {
+            if (compare(__b, current.node.declarations[0].init))
+                push({
+                    current,
+                    path,
+                });
+        }
+    },
+});

package/lib/extract-properties-equal-deep/index.js

@@ -0,0 +1,78 @@
+import {
+    template,
+    generate,
+    types,
+    operator,
+} from 'putout';
+
+const {
+    findBinding,
+    replaceWith,
+    getTemplateValues,
+} = operator;
+
+const {
+    isIdentifier,
+    isCallExpression,
+} = types;
+
+export const report = () => `Extract object properties into variables`;
+
+const buildAst = template(`
+    const {PROPERTY} = OBJECT;
+`);
+
+export const fix = ({items}) => {
+    const names = [];
+    
+    for (const item of items) {
+        const {object, property} = item.node;
+        
+        if (isIdentifier(property) && !names.includes(property.name)) {
+            names.push(property.name);
+            
+            const {body = item.scope.block.body} = item.scope.block.body;
+            
+            body.unshift(buildAst({
+                PROPERTY: property,
+                OBJECT: object,
+            }));
+        }
+        
+        replaceWith(item, item.node.property);
+    }
+};
+
+export const traverse = ({uplist, push}) => ({
+    'const __object = __a.__b': (fullPath) => {
+        const {__a, __b} = getTemplateValues(fullPath, 'const __object = __a.__b');
+        const initPath = fullPath.get('declarations.0.init');
+        const {uid} = initPath.scope;
+        
+        if (findBinding(fullPath, __b.name))
+            return;
+        
+        if (isIdentifier(__a) || isCallExpression(__a)) {
+            const {code} = generate(__a);
+            const id = `${uid}-${code}`;
+            
+            return uplist(id, initPath);
+        }
+    },
+    'Program': {
+        exit: () => {
+            for (const items of uplist()) {
+                if (items.length < 2)
+                    continue;
+                
+                const index = items.length - 1;
+                const path = items[index];
+                
+                push({
+                    path,
+                    items,
+                });
+            }
+        },
+    },
+});

package/lib/extract-properties-not-equal-deep/index.js

@@ -0,0 +1,72 @@
+import {operator, types} from 'putout';
+
+const {objectProperty} = types;
+
+const {replaceWith, compare} = operator;
+
+const SHORTHAND = true;
+const COMPUTED = false;
+
+export const report = () => `Extract object properties into variables`;
+
+export const fix = ({path, expandPath, property}) => {
+    const newProperty = objectProperty(property, property, COMPUTED, SHORTHAND);
+    
+    expandPath.node.properties.push(newProperty);
+    replaceWith(path, property);
+};
+
+export const traverse = ({listStore, push}) => ({
+    'const __object = __a.__b': save({
+        listStore,
+    }),
+    'const __object = __a(__args)': save({
+        listStore,
+    }),
+    'Program': {
+        exit: exit({
+            push,
+            listStore,
+        }),
+    },
+});
+
+const save = ({listStore}) => (path) => {
+    const idPath = path.get('declarations.0.id');
+    const initPath = path.get('declarations.0.init');
+    
+    listStore([initPath, idPath]);
+};
+
+const exit = ({push, listStore}) => () => {
+    const items = listStore();
+    
+    for (const [initPath] of items) {
+        for (const [currentPath, expandPath] of items) {
+            const objectPath = initPath.get('object');
+            
+            if (!objectPath.isMemberExpression() && !objectPath.isCallExpression())
+                continue;
+            
+            const propertyPath = initPath.get('property');
+            const property = propertyPath.node;
+            
+            const current = currentPath.node;
+            const {object} = initPath.node;
+            const {name} = property;
+            
+            if (expandPath.scope.bindings[name])
+                continue;
+            
+            if (expandPath.scope.uid !== initPath.scope.uid)
+                continue;
+            
+            if (compare(object, current))
+                push({
+                    expandPath,
+                    path: initPath,
+                    property,
+                });
+        }
+    }
+};

package/lib/index.js

@@ -1,6 +1,9 @@
-import * as convertObjectToArray from './convert-object-to-array/index.js';
+import * as applyDeclarationsOrder from './apply-declarations-order/index.js';
 import * as applyObject from './apply-object/index.js';
 import * as applyArray from './apply-array/index.js';
+import * as extractPropertiesEqualDeep from './extract-properties-equal-deep/index.js';
+import * as extractPropertiesNotEqualDeep from './extract-properties-not-equal-deep/index.js';
+import * as convertObjectToArray from './convert-object-to-array/index.js';
 import * as removeUselessObject from './remove-useless-object/index.js';
 import * as removeUselessArguments from './remove-useless-arguments/index.js';
 import * as removeUselessVariables from './remove-useless-variables/index.js';
@@ -9,12 +12,15 @@ import * as splitCall from './split-call/index.js';
 import * as mergeProperties from './merge-properties/index.js';
 
 export const rules = {
-    'apply-object': applyObject,
     'apply-array': applyArray,
+    'apply-object': applyObject,
+    'apply-declarations-order': applyDeclarationsOrder,
+    'convert-object-to-array': convertObjectToArray,
+    'extract-properties-equal-deep': extractPropertiesEqualDeep,
+    'extract-properties-not-equal-deep': extractPropertiesNotEqualDeep,
     'remove-useless-object': removeUselessObject,
     'remove-useless-arguments': removeUselessArguments,
     'remove-useless-variables': removeUselessVariables,
-    'convert-object-to-array': convertObjectToArray,
     'split-nested': splitNested,
     'split-call': splitCall,
     'merge-properties': mergeProperties,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/plugin-destructuring",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "🐊Putout plugin adds ability to transform destructuring",
@@ -23,7 +23,9 @@
     "coverage": "madrun coverage",
     "report": "madrun report"
   },
-  "dependencies": {},
+  "dependencies": {
+    "redput": "^3.6.0"
+  },
   "keywords": [
     "putout",
     "putout-plugin",
@@ -39,9 +41,10 @@
     "@putout/plugin-printer": "*",
     "@putout/plugin-putout": "*",
     "@putout/plugin-tape": "*",
+    "@putout/plugin-variables": "*",
     "@putout/test": "^14.0.0",
     "c8": "^10.0.0",
-    "eslint": "v10.0.0-alpha.0",
+    "eslint": "^10.0.0-alpha.0",
     "eslint-plugin-n": "^17.0.0",
     "eslint-plugin-putout": "^29.0.0",
     "madrun": "^11.0.0",