@putout/plugin-optional-chaining 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,137 @@
+# @putout/plugin-optional-chaining [![NPM version][NPMIMGURL]][NPMURL]
+
+[NPMIMGURL]: https://img.shields.io/npm/v/@putout/plugin-apply-optional-chaining.svg?style=flat&longCache=true
+[NPMURL]: https://npmjs.org/package/@putout/plugin-apply-optional-chaining "npm"
+
+> The **optional chaining operator** (`?.`) enables you to read the value of a property located deep within a chain of connected objects without having to check that each reference in the chain is valid.
+>
+> The `?.` operator is like the `.` chaining operator, except that instead of causing an error if a reference is nullish (`null` or `undefined`), the expression short-circuits with a return value of `undefined`. When used with function calls, it returns `undefined` if the given function does not exist.
+>
+> This results in shorter and simpler expressions when accessing chained properties when the possibility exists that a reference may be missing. It can also be helpful while exploring the content of an object when there's no known guarantee as to which properties are required.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining)
+
+🐊[**Putout**](https://github.com/coderaiser/putout) plugin related to **Optional Chaining**.
+
+## Install
+
+```
+npm i @putout/plugin-optional-chaining
+```
+
+## Rules
+
+- ✅ [convert-logical-to-optional][#convert-logical-to-optional];
+- ✅ [convert-optional-to-logical][#convert-optional-to-logical];
+- ✅ [convert-logical-assign-to-optional][#convert-logical-assign-to-optional];
+- ✅ [convert-optional-assign-to-logical][#convert-logical-assign-to-optional];
+
+## Config
+
+```json
+{
+    "rules": {
+        "optional-chaining/convert-logical-to-optional": "on",
+        "optional-chaining/convert-optional-assign-to-logical": "on",
+        "optional-chaining/convert-logical-assign-to-optional": "off",
+        "optional-chaining/convert-optional-to-logical": "off"
+    }
+}
+```
+
+## convert-logical-to-optional
+
+> The logical **AND** (`&&`) (logical conjunction) operator for a set of boolean operands will be true if and only if all the operands are true. Otherwise it will be false.
+>
+> More generally, the operator returns the value of the first falsy operand encountered when evaluating from left to right, or the value of the last operand if they are all truthy.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND)
+
+
+Checkout out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/d308302b95800920d324b799f1a948e3/99d03cb297d17446885829e8583b3cc7777367c5).
+
+### ❌ Example of incorrect code
+
+```js
+const result = hello && hello.world;
+
+if (typeof a === 'function' && a(1, 2))
+    alert();
+```
+
+### ✅ Example of correct code
+
+```js
+const result = hello?.world;
+
+if (a?.(1, 2))
+    alert();
+```
+
+## convert-logical-assign-to-optional
+
+> Proposal to add support for optional chaining on the left of assignment operators: `a?.b = c`.
+>
+> (c) [Proposal of Optional Chaining Assignment](https://github.com/tc39/proposal-optional-chaining-assignment)
+
+Disabled by default. Checkout out in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/74bde454f909b7f9d13e80da10e12a15/d31bd20ca18fefe474bb8ab73f963e47dffb89e7).
+
+### ❌ Example of incorrect code
+
+```js
+if (a) {
+    a.b = 5;
+}
+
+if (a)
+    a.b = 5;
+
+a && (a.b = 5);
+```
+
+### ✅ Example of correct code
+
+```js
+a?.b = 5;
+```
+
+## convert-optional-assign-to-logical
+
+> The JavaScript exception "invalid assignment left-hand side" occurs when there was an unexpected assignment somewhere. It may be triggered when a single `=` sign was used instead of `==` or `===`.
+>
+> (c) [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side)
+
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/29c00f1b02b592a3dcd7b7e185dfd354/50a1a416da21b02df3a76954b4d7a1ff7dac1eaf).
+
+### ❌ Example of incorrect code
+
+```js
+maybeAnObj?.prop = theValue;
+```
+
+### ✅ Example of correct code
+
+```js
+maybeAnObj && (maybeAnObj.prop = theValue);
+```
+
+## convert-optioanl-to-logical
+
+Disabled by default.
+Checkout in 🐊[**Putout Editor**](https://putout.cloudcmd.io/#/gist/e0a4ccb41708ad37e34d527a978ebb88/482f15c954cdaa35e37da7a1dddb82338d7e93a2).
+
+### ❌ Example of incorrect code
+
+```js
+hello?.world?.();
+```
+
+### ✅ Example of correct code
+
+```js
+hello && hello.world && hello.world();
+```
+
+## License
+
+MIT

package/lib/convert-assign-to-optional/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports.report = () => `Use optional expression ('a?.b = c') instead of 'condition' ('a && a.b = c')`;
+
+module.exports.replace = () => ({
+    'if (__a) {__a.__b = __c}': '__a?.__b = __c',
+    'if (__a) __a.__b = __c': '__a?.__b = __c',
+    '__a && (__a.__b = __c)': '__a?.__b = __c',
+});

package/lib/convert-logical-to-optional/index.js

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports.report = () => 'Use optional chaining';
+
+module.exports.replace = () => ({
+    '__a && __a.__b && __a.__b.__c && __a.__b.__c.__d && __a.__b.__c.__d.__e': '__a?.__b?.__c?.__d?.__e',
+    '__a && __a.__b && __a.__b.__c && __a.__b.__c.__d': '__a?.__b?.__c?.__d',
+    '__a && __a.__b && __a.__b.__c': '__a?.__b?.__c',
+    '__a && __a.__b': '__a?.__b',
+    '__a && __a.__b.__c': '__a?.__b.__c',
+    '__a && __a[__b]': '__a?.[__b]',
+    '__a[__b] && __a[__b][__c]': '__a[__b]?.[__c]',
+    'typeof __a === "function" && __a(__args)': '__a?.(__args)',
+    'isFn(__a) && __a(__args)': '__a?.(__args)',
+    'if (typeof __a === "function") __a(__args)': '__a?.(__args)',
+    'if (typeof __a === "function") {__a(__args)}': '__a?.(__args)',
+    '__a && __a.__b(__args)': '__a?.__b(__args)',
+    '__a.__b && __a.__b[__c] && __a.__b[__c].__d(__args)': '__a.__b?.[__c]?.__d(__args)',
+});

package/lib/convert-optiional-assign-to-logical/index.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const {template, operator} = require('putout');
+
+const {getLogical} = require('../get-logical');
+const {replaceWith} = operator;
+
+module.exports.report = () => `Use Logical Expression ('a && a.b = c') instead of Optional Chaining ('a?.b = c')`;
+
+module.exports.fix = (path) => {
+    const logical = getLogical(path, {
+        assign: true,
+    });
+    
+    const logicalNode = template.ast(logical);
+    
+    logicalNode.right.right = path.parentPath.node.right;
+    replaceWith(path.parentPath, logicalNode);
+};
+
+module.exports.traverse = ({push, listStore}) => ({
+    'OptionalMemberExpression|OptionalCallExpression'(path) {
+        if (!path.parentPath.isAssignmentExpression())
+            return;
+        
+        const rightPath = path.parentPath.get('right');
+        
+        if (path === rightPath)
+            return;
+        
+        listStore(path);
+    },
+    Program: {
+        exit() {
+            for (const path of listStore().reverse())
+                push(path);
+        },
+    },
+});

package/lib/convert-optional-to-logical/index.js

@@ -0,0 +1,28 @@
+'use strict';
+
+const {template, operator} = require('putout');
+const {getLogical} = require('../get-logical');
+
+module.exports.report = () => `Use Logical Expression instead of Optional Chaining`;
+
+const {replaceWith} = operator;
+
+module.exports.fix = (path) => {
+    const logical = getLogical(path);
+    replaceWith(path, template.ast(logical));
+};
+
+module.exports.include = () => [
+    'OptionalMemberExpression',
+    'OptionalCallExpression',
+];
+
+module.exports.filter = ({parentPath}) => {
+    if (parentPath.isOptionalMemberExpression())
+        return false;
+    
+    if (parentPath.isAssignmentExpression())
+        return false;
+    
+    return !parentPath.isOptionalCallExpression();
+};

package/lib/get-logical.js

@@ -0,0 +1,34 @@
+'use strict';
+
+module.exports.getLogical = (path, {assign} = {}) => {
+    const list = path
+        .toString()
+        .split('?.');
+    
+    const n = list.length;
+    let [member] = list;
+    let i = assign ? 1 : 0;
+    const logical = [member];
+    
+    while (++i < n) {
+        member += compute(member, list[i]);
+        logical.push(member);
+    }
+    
+    const fullLogical = logical.join(' && ');
+    
+    if (!assign)
+        return fullLogical;
+    
+    return `${fullLogical} && (${logical.at(-1)} = __a)`;
+};
+
+function compute(member, current) {
+    if (current[0] === '(')
+        return current;
+    
+    if (current[0] === '[')
+        return current;
+    
+    return `.${current}`;
+}

package/lib/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const convertAssignToOptional = require('./convert-assign-to-optional');
+const convertLogicalToOptional = require('./convert-logical-to-optional');
+const convertOptionalAssignToLogical = require('./convert-optiional-assign-to-logical');
+const convertOptionalToLogical = require('./convert-optional-to-logical');
+
+module.exports.rules = {
+    'convert-assign-to-optional': ['off', convertAssignToOptional],
+    'convert-logical-to-optional': convertLogicalToOptional,
+    'convert-optiional-assign-to-logical': convertOptionalAssignToLogical,
+    'convert-optional-to-logical': ['off', convertOptionalToLogical],
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@putout/plugin-optional-chaining",
+  "version": "1.0.0",
+  "type": "commonjs",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "🐊Putout plugin adds ability apply optional chaining",
+  "homepage": "https://github.com/coderaiser/putout/tree/master/packages/plugin-apply-optional-chaining#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",
+    "optional-chaining"
+  ],
+  "devDependencies": {
+    "@putout/test": "^11.0.0",
+    "c8": "^10.0.0",
+    "eslint": "^9.0.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^23.0.0",
+    "lerna": "^6.0.1",
+    "madrun": "^10.0.0",
+    "nodemon": "^3.0.1"
+  },
+  "peerDependencies": {
+    "putout": ">=36"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}