@putout/plugin-destructuring 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) coderaiser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,197 @@
+# @putout/plugin-destructuring [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-destructuring.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/plugin-destructuring"npm"
+
+> The **destructuring** assignment syntax is a **JavaScript** expression that makes it possible to unpack values from arrays, or properties from objects, into distinct variables.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin adds ability to use **destructuring** on variable declarations.
+
+## Install
+
+```
+npm i @putout/plugin-destructuring
+```
+
+## Rules
+
+- ✅ [apply-object](#apply-object);
+- ✅ [apply-array](#apply-array);
+- ✅ [remove-useless-object](#remove-useless-object);
+- ✅ [convert-object-to-array](#convert-object-to-array);
+- ✅ [split-nested](#split-nested);
+- ✅ [split-call](#split-call);
+
+## Config
+
+```json
+{
+    "rules": {
+        "destructuring/apply-object": "on",
+        "destructuring/apply-array": "on",
+        "destructuring/remove-useless-object": "on",
+        "destructuring/convert-object-to-array": "on"
+    }
+}
+```
+
+## apply-array
+
+### ❌ Example of incorrect code
+
+```js
+const first = array[0];
+```
+
+## ✅ Example of correct code
+
+```js
+const [first] = array;
+```
+
+## apply-object
+
+### ❌ Example of incorrect code
+
+```js
+const name = user.name;
+
+hello = world.hello;
+```
+
+### ✅ Example of correct code
+
+```js
+const {name} = user;
+
+({hello} = world);
+```
+
+## remove-useless-object
+
+Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/c9ed04b421d75ae39e58038fa6e14630/4c097e3173990ec7e5ebabbe2cedf8e952092ebf).
+
+### ❌ Example of incorrect code
+
+```js
+const {maxElementsInOneLine} = {
+    options,
+};
+```
+
+### ✅ Example of correct code
+
+```js
+const {maxElementsInOneLine} = options;
+```
+
+## convert-object-to-array
+
+Check out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/a1d26daf8bb83ee3ea1c0b62a6ad3afd/cef9b4d27c9dbb0d413a935b0359a6fe9b50364f).
+
+### ❌ Example of incorrect code
+
+```js
+const {0: a, 1: b} = c;
+```
+
+### ✅ Example of correct code
+
+```js
+const [a, b] = c;
+```
+
+## split-nested
+
+> - Don't use nested destructuring on data that comes from any external data sources (such as `REST API`s, `GraphQL` endpoints or files).
+> - Don't use nested destructuring on function arguments that have long or complicated signatures.
+>
+> (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
+const {
+    a: {
+        b,
+    },
+    a: {
+        b: x,
+    },
+} = c;
+
+function f({a}) {
+    const {b} = a;
+    console.log(b);
+}
+```
+
+### ✅ Example of correct code
+
+```js
+const {a} = c;
+const {b, b: x} = a;
+
+function f({a}) {
+    const {b} = a;
+    console.log(b);
+}
+```
+
+## split-call
+
+### ❌ Example of incorrect code
+
+```js
+console.log('hello')({uid} = path.scope);
+console.log('hello')[uid] = path.scope;
+```
+
+### ✅ Example of correct code
+
+```js
+console.log('hello');
+({uid} = path.scope);
+
+console.log('hello');
+[uid] = path.scope;
+```
+
+## merge-properties
+
+> The destructuring assignment syntax is a JavaScript expression that makes it possible to unpack values from `arrays`, or `properties` from `objects`, into distinct `variables`.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment)
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/11c8cfa59f87e46238309b857448b9c5/688f10ad8fd7c0e4d9e9e0c74c399f1edb3ba29e).
+
+### ❌ Example of incorrect code
+
+```js
+const {one} = require('numbers');
+const {two} = require('numbers');
+
+({from} = data);
+({to} = data);
+({names} = data);
+```
+
+### ✅ Example of correct code
+
+```js
+const {one, two} = require('numbers');
+
+({
+    from,
+    to,
+    names,
+} = data);
+```
+
+## License
+
+MIT

package/lib/array/index.js

@@ -0,0 +1,22 @@
+export const report = () => `Use array destructuring`;
+
+export const exclude = () => [
+    'const __object = __[0]',
+    'const __array = __[0]',
+    '({__} = __[0])',
+    '[__] = __[0]',
+    '__a[0] = __b[0]',
+];
+
+export const replace = () => ({
+    '__a = __b[0]': '[__a] = __b',
+    '__a = __b[1]': '[, __a] = __b',
+    'const __a = __b[1]': 'const [, __a] = __b',
+    'const __a = __b[0]': convertTo('const [__a] = __b'),
+    'let __a = __b[0]': convertTo('let [__a] = __b'),
+});
+
+const convertTo = (template) => ({__a}) => {
+    delete __a.typeAnnotation;
+    return template;
+};

package/lib/convert-object-to-array/index.js

@@ -0,0 +1,41 @@
+import {types, operator} from 'putout';
+
+const {replaceWith} = operator;
+const {
+    isObjectProperty,
+    arrayPattern,
+} = types;
+
+export const report = () => `Use array destructuring instead of object destructuring`;
+
+export const fix = (path) => {
+    const elements = [];
+    
+    for (const {value} of path.node.properties) {
+        elements.push(value);
+    }
+    
+    const array = arrayPattern(elements);
+    replaceWith(path, array);
+};
+
+export const traverse = ({push}) => ({
+    ObjectPattern(path) {
+        const properties = path.get('properties');
+        
+        if (!properties.length)
+            return;
+        
+        for (const [i, prop] of properties.entries()) {
+            if (!isObjectProperty(prop))
+                return;
+            
+            const {key} = prop.node;
+            
+            if (i !== key.value)
+                return;
+        }
+        
+        push(path);
+    },
+});

package/lib/falsy/index.js

@@ -0,0 +1,17 @@
+const FIRST_PROPERTY = 'declarations.0.id.properties.0';
+
+export const report = (path) => {
+    const {name} = path.get(`${FIRST_PROPERTY}.key`).node;
+    return `Use destructuring instead of setting '${name}' to 'undefined'`;
+};
+
+export const match = () => ({
+    'const {__a} = {__b}': (vars, path) => {
+        const prop = path.get(FIRST_PROPERTY);
+        return !prop.node.computed;
+    },
+});
+
+export const replace = () => ({
+    'const {__a} = {__b}': 'const {__a} = __b',
+});

package/lib/index.js

@@ -0,0 +1,17 @@
+import * as convertObjectToArray from './convert-object-to-array/index.js';
+import * as object from './object/index.js';
+import * as array from './array/index.js';
+import * as falsy from './falsy/index.js';
+import * as splitNested from './split-nested/index.js';
+import * as splitCall from './split-call/index.js';
+import * as mergeProperties from './merge-properties/index.js';
+
+export const rules = {
+    'apply-object': object,
+    'apply-array': array,
+    'remove-useless-object': falsy,
+    'convert-object-to-array': convertObjectToArray,
+    'split-nested': splitNested,
+    'split-call': splitCall,
+    'merge-properties': mergeProperties,
+};

package/lib/merge-properties/index.js

@@ -0,0 +1,152 @@
+import {types, operator} from 'putout';
+
+const {remove, compare} = operator;
+
+const {
+    isObjectPattern,
+    isRestElement,
+    isAssignmentExpression,
+    isVariableDeclaration,
+    isExpressionStatement,
+} = types;
+
+const notEmptyPlaces = (a) => a.places.length;
+
+const LEFT = {
+    VariableDeclarator: 'id',
+    AssignmentExpression: 'left',
+};
+
+const RIGHT = {
+    VariableDeclarator: 'init',
+    AssignmentExpression: 'right',
+};
+
+export const report = () => 'Merge object properties when destructuring';
+
+export const fix = ({path, places}) => {
+    merge(path, places);
+};
+
+export const traverse = ({push, store}) => {
+    const add = addVariable({
+        store,
+    });
+    
+    return {
+        'VariableDeclarator|AssignmentExpression'(path) {
+            const {left, right} = split(path);
+            
+            if (!right)
+                return;
+            
+            if (!isObjectPattern(left))
+                return;
+            
+            for (const property of left.properties) {
+                if (isRestElement(property))
+                    return;
+            }
+            
+            add(path, right);
+        },
+        Program: {
+            exit() {
+                store()
+                    .filter(notEmptyPlaces)
+                    .filter(checkPlaces)
+                    .map(push);
+            },
+        },
+    };
+};
+
+function checkPlaces({places}) {
+    return places.filter(hasParentNode).length;
+}
+
+const hasParentNode = ({parentPath}) => {
+    if (!parentPath.node)
+        return false;
+    
+    return isVariableDeclaration(parentPath) || isExpressionStatement(parentPath);
+};
+
+const createUID = (path) => {
+    const {uid} = path.scope;
+    const {type} = path;
+    const name = RIGHT[type];
+    
+    const str = `${uid}-${path.get(name).toString()}`;
+    
+    return str.replace(/['"`]/g, '*');
+};
+
+const addVariable = ({store}) => (path, node) => {
+    const str = createUID(path);
+    const currentVar = store(str);
+    
+    if (!currentVar) {
+        store(str, {
+            path,
+            places: [],
+        });
+        
+        return;
+    }
+    
+    const currentPath = currentVar.path;
+    
+    if (path === currentPath)
+        return;
+    
+    const {parentPath, type} = currentPath;
+    
+    if (currentPath.removed || !currentPath.node)
+        return;
+    
+    if (parentPath.removed || !parentPath.node)
+        return;
+    
+    const name = RIGHT[type];
+    
+    if (isAssignmentExpression(currentPath) && compare(currentPath.node[name], node))
+        return currentVar.places.push(path);
+    
+    if (sameKind(path, currentPath))
+        return currentVar.places.push(path);
+};
+
+function sameKind(path1, path2) {
+    const kind1 = path1.parentPath.node.kind;
+    const kind2 = path2.parentPath.node.kind;
+    
+    return kind1 === kind2;
+}
+
+function split(path) {
+    const {type} = path;
+    const leftName = LEFT[type];
+    const rightName = RIGHT[type];
+    const left = path.node[leftName];
+    const right = path.node[rightName];
+    
+    return {
+        left,
+        right,
+    };
+}
+
+function merge(path, places) {
+    const {node, type} = path;
+    const name = LEFT[type];
+    
+    for (const place of places) {
+        node[name].properties = [
+            ...node[name].properties,
+            ...place.node[name].properties,
+        ];
+        
+        remove(place);
+    }
+}

package/lib/object/index.js

@@ -0,0 +1,15 @@
+import {types} from 'putout';
+
+const {isExpressionStatement} = types;
+
+export const report = () => 'Use object destructuring';
+
+export const match = () => ({
+    '__a = __b.__a': (vars, {parentPath}) => isExpressionStatement(parentPath),
+});
+
+export const replace = () => ({
+    'const __a = __b.__a': 'const {__a} = __b',
+    'let __a = __b.__a': 'let {__a} = __b',
+    '__a = __b.__a': '({__a} = __b)',
+});

package/lib/split-call/index.js

@@ -0,0 +1,28 @@
+import {types} from 'putout';
+
+const {isIdentifier} = types;
+
+export const report = () => `Split call with destructuring`;
+
+export const replace = () => ({
+    '__a(__args)({__c} = __d)': `{
+        __a(__args);
+        ({__c} = __d);
+    }`,
+    '__a(__args)[__c] = __d': ({__c}) => {
+        if (isIdentifier(__c))
+            return `{
+                __a(__args);
+                [__c] = __d;
+            }`;
+        
+        __c.elements = __c.expressions;
+        __c.type = 'ArrayPattern';
+        delete __c.expressions;
+        
+        return `{
+            __a(__args);
+            __c = __d;
+        }`;
+    },
+});

package/lib/split-nested/index.js

@@ -0,0 +1,54 @@
+import {types, template} from 'putout';
+
+const {
+    objectProperty,
+    isObjectPattern,
+    objectPattern,
+} = types;
+
+const buildDeclaration = template(`
+    const %%__b%% = %%__a%%
+`);
+
+export const report = () => 'Avoid nested destructuring';
+
+export const match = () => ({
+    'const {__a: {__b}} = __c': matchConst,
+    'const {__a: {__b: __c}} = __d': matchConst,
+    'const {__a: {__b = __c}} = __d': matchConst,
+});
+
+export const replace = () => ({
+    'const {__a: {__b}} = __c': 'const {__a} = __c, {__b} = __a',
+    'const {__a: {__b: __c}} = __d': 'const {__a} = __d, {__b: __c} = __a',
+    'const {__a: {__b = __c}} = __d': 'const {__a} = __d, {__b = __c} = __a',
+    'function f({ __a: { __b } }) {}': replaceArg,
+    'function f({ __a: { __b: __c } }) {}': replaceArg,
+});
+
+function matchConst({__a, __c}, path) {
+    const bindings = path.scope.getAllBindings();
+    
+    if (bindings[__a.name])
+        return false;
+    
+    return !isObjectPattern(__c);
+}
+
+function replaceArg({__a, __b, __c}, path) {
+    const {properties} = path.node.params[0];
+    const [first] = properties;
+    
+    first.value = first.key;
+    
+    const declaration = buildDeclaration({
+        __a,
+        __b: objectPattern([
+            objectProperty(__b, __c || __b),
+        ]),
+    });
+    
+    path.node.body.body.unshift(declaration);
+    
+    return path;
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@putout/plugin-destructuring",
+  "version": "1.0.0",
+  "type": "module",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "🐊Putout plugin adds ability to transform destructuring",
+  "homepage": "https://github.com/coderaiser/putout/tree/master/packages/plugin-destructuring#readme",
+  "main": "lib/index.js",
+  "release": false,
+  "tag": false,
+  "changelog": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/coderaiser/putout.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report"
+  },
+  "dependencies": {},
+  "keywords": [
+    "putout",
+    "putout-plugin",
+    "plugin",
+    "destructuring"
+  ],
+  "devDependencies": {
+    "@putout/plugin-declare": "*",
+    "@putout/plugin-declare-before-reference": "*",
+    "@putout/plugin-esm": "*",
+    "@putout/plugin-minify": "*",
+    "@putout/plugin-nodejs": "*",
+    "@putout/plugin-printer": "*",
+    "@putout/plugin-putout": "*",
+    "@putout/plugin-tape": "*",
+    "@putout/test": "^14.0.0",
+    "c8": "^10.0.0",
+    "eslint": "v10.0.0-alpha.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^29.0.0",
+    "madrun": "^11.0.0",
+    "nodemon": "^3.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=41"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}