@putout/printer 6.12.0 → 6.14.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.12.03, v6.14.0
+
+feature:
+- a00d8cb @putout/printer: comment: chain
+
+2023.12.03, v6.13.0
+
+feature:
+- bc106c1 @putout/printer: ArrayExpression: object after spread
+
 2023.12.01, v6.12.0
 
 feature:

package/lib/tokenize/comment/parse-trailing-comments.js

@@ -15,13 +15,26 @@ function isSameLine(path, loc) {
 
 const isTrailingIsLeading = (path) => path.node.trailingComments === path.getNextSibling().node?.leadingComments;
 
+const isNewlineAfter = (path) => {
+    const {parentPath} = path;
+    
+    if (parentPath.isMemberExpression())
+        return false;
+    
+    return !isLast(path) && !isDecorator(path);
+};
+
 module.exports.isTrailingIsLeading = isTrailingIsLeading;
 
 function isCommentOnNextLine(path) {
+    const {node, parentPath} = path;
     const {
         loc,
         trailingComments,
-    } = path.node;
+    } = node;
+    
+    if (parentPath.isMemberExpression())
+        return false;
     
     if (isTrailingIsLeading(path))
         return false;
@@ -69,7 +82,7 @@ module.exports.parseTrailingComments = (path, {write, maybe}, semantics) => {
             }
             
             write(`//${value}`);
-            maybe.write.newline(!isLast(path) && !isDecorator(path));
+            maybe.write.newline(isNewlineAfter(path));
             
             continue;
         }

package/lib/tokenize/expressions/array-expression/array-expression.js

@@ -8,22 +8,26 @@ const {
 } = require('../../is');
 
 const {
-    isMultiLine,
     isIncreaseIndent,
     isCurrentNewLine,
+    isMultiLine,
 } = require('./newline');
 
-const {types} = require('@putout/babel');
-
 const {
     isInsideArray,
     isArrayInsideArray,
     isArrayIndented,
 } = require('./indent');
 
-const {isObjectExpression} = types;
+const {types} = require('@putout/babel');
+const {
+    isObjectExpression,
+    isSpreadElement,
+} = types;
 
 const isNextObject = (a) => a.getNextSibling().isObjectExpression();
+const isPrevObject = (a) => a.getPrevSibling().isObjectExpression();
+const isObjectAfterSpread = (a) => isSpreadElement(a) && isNextObject(a) && !isPrevObject(a);
 
 const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.length === 1;
 
@@ -53,7 +57,7 @@ module.exports.ArrayExpression = {
         } = semantics;
         
         const elements = path.get('elements');
-        const shouldIncreaseIndent = isIncreaseIndent(path);
+        const shouldIncreaseIndent = !isIncreaseIndent(path);
         
         print('[');
         
@@ -80,7 +84,7 @@ module.exports.ArrayExpression = {
                 maybe.print(is, ',');
             
             maybe.print.newline(is && !isNextObject(element));
-            maybe.print.space(element.isSpreadElement() && isNextObject(element));
+            maybe.print.space(isObjectAfterSpread(element));
             
             if (!is && index < n) {
                 print(',');

package/lib/tokenize/expressions/array-expression/newline.js

@@ -1,40 +1,6 @@
 'use strict';
 
 const {isSimple} = require('@putout/operate');
-const isTwoStringsTupleAndParentIsArrayWithFirstArrayElement = (path) => {
-    const {elements} = path.node;
-    
-    if (!isStringAndString(elements))
-        return false;
-    
-    return isParentIsArrayWithFirstArrayElement(path);
-};
-
-const isLotsOfElementsFirstNotObject = (path) => {
-    const {elements} = path.node;
-    const [first] = elements;
-    
-    return elements.length > 3 && !isObjectExpression(first);
-};
-
-const isTwoSimplesInsideObjectProperty = (path) => {
-    const {node, parentPath} = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (length > 2)
-        return false;
-    
-    if (!parentPath.isObjectProperty())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return !isCoupleLines(path);
-};
 
 const {
     isObjectExpression,
@@ -46,7 +12,6 @@ const {
     isNullLiteral,
     isStringLiteral,
     isSpreadElement,
-    isNumericLiteral,
 } = require('@putout/babel').types;
 
 const {
@@ -56,7 +21,6 @@ const {
     isCoupleLines,
     isStringAndArray,
     isIdentifierAndIdentifier,
-    satisfy,
 } = require('../../is');
 
 const {round} = Math;
@@ -83,70 +47,68 @@ const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
 const ONE_LINE = false;
 const MULTI_LINE = true;
 
-const isOneLineElements = satisfy([
-    isOneSimple,
-    isOneSpread,
-    isIdentifierAndIdentifier,
-    isBooleanAndSimple,
-    isNullAndSimple,
-    isSimpleAndCall,
-    isTwoStringsDifferentLength,
-    isStringAndArray,
-    isStringAndMember,
-    isStringAndIdentifier,
-    isIdentifierAndString,
-    isSimpleAndObject,
-]);
-
-const isOneLinePath = satisfy([
-    isCallInsideArrow,
-    notIncreaseIndent,
-    isInsideLoop,
-    isTwoSimplesInsideObjectProperty,
-    isTwoStringsTupleAndParentIsArrayWithFirstArrayElement,
-]);
-
-const isMultiLinePath = satisfy([
-    tooLong,
-    isCoupleLines,
-    notNumbersInsideForOf,
-]);
-
 module.exports.isMultiLine = (path, {elements, maxElementsInOneLine}) => {
-    if (isLotsOfElementsFirstNotObject(path))
+    if (elements.length > 3 && !isObjectExpression(elements[0]))
         return MULTI_LINE;
     
-    if (isOneLineElements(elements))
+    if (isOneSimple(path))
+        return ONE_LINE;
+    
+    if (isOneSpread(elements))
+        return ONE_LINE;
+    
+    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
+        return ONE_LINE;
+    
+    if (isCallInsideArrow(path))
         return ONE_LINE;
     
-    if (isOneLinePath(path))
+    if (isIncreaseIndent(path))
+        return ONE_LINE;
+    
+    if (isInsideLoop(path))
+        return ONE_LINE;
+    
+    if (isBooleanAndSimple(elements))
+        return ONE_LINE;
+    
+    if (isNullAndSimple(elements))
+        return ONE_LINE;
+    
+    if (isSimpleAndCall(elements))
         return ONE_LINE;
     
     if (isShortTwoSimplesInsideCall(path, maxElementsInOneLine))
         return ONE_LINE;
     
-    if (isMultiLinePath(path))
-        return MULTI_LINE;
+    if (isTwoStringsDifferentLength(elements))
+        return ONE_LINE;
     
-    return ONE_LINE;
-};
-
-function notNumbersInsideForOf(path) {
-    const {elements} = path.node;
+    if (isTwoSimplesInsideObjectProperty(path))
+        return ONE_LINE;
     
-    if (isNumbers(elements))
-        return false;
+    if (isStringAndArray(elements))
+        return ONE_LINE;
     
-    return !isForOf(path) && isLastArg(path) && !isParentProperty(path);
-}
-
-const isParentIsArrayWithFirstArrayElement = ({parentPath}) => {
-    if (!isArrayExpression(parentPath))
-        return false;
+    if (isStringAndMember(elements))
+        return ONE_LINE;
+    
+    if (isStringAndIdentifier(elements))
+        return ONE_LINE;
+    
+    if (isIdentifierAndString(elements))
+        return ONE_LINE;
+    
+    if (isSimpleAndObject(elements))
+        return ONE_LINE;
+    
+    if (isStringAndString(elements) && path.parentPath.isArrayExpression() && isArrayExpression(path.parentPath.node.elements[0]))
+        return ONE_LINE;
     
-    const [first] = parentPath.node.elements;
+    if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
+        return MULTI_LINE;
     
-    return isArrayExpression(first);
+    return ONE_LINE;
 };
 
 const isForOf = ({parentPath}) => parentPath.isForOfStatement();
@@ -169,7 +131,28 @@ const isShortTwoSimplesInsideCall = (path, short) => {
     return length < short;
 };
 
-function isOneSimple(elements) {
+const isTwoSimplesInsideObjectProperty = (path) => {
+    const {node, parentPath} = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (length > 2)
+        return false;
+    
+    if (!parentPath.isObjectProperty())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return !isCoupleLines(path);
+};
+
+function isOneSimple(path) {
+    const elements = path.get('elements');
+    
     if (elements.length !== 1)
         return false;
     
@@ -237,7 +220,7 @@ function isCallInsideArrow(path) {
 
 function isNumbers(elements) {
     for (const element of elements) {
-        if (isNumericLiteral(element))
+        if (element.isNumericLiteral())
             return true;
     }
     
@@ -252,31 +235,23 @@ function isParentProperty(path) {
     return path.find(isObjectProperty);
 }
 
-const not = (fn) => (...a) => !fn(...a);
-
-const isFirstObject = (path) => isObjectExpression(path.node.elements[0]);
-const isSecondSpread = (path) => isSpreadElement(path.node.elements[1]);
-
-const isStringAndObject = (path) => {
-    const {elements} = path.node;
-    const first = elements.at(0);
-    const last = elements.at(-1);
+module.exports.isIncreaseIndent = isIncreaseIndent;
+function isIncreaseIndent(path) {
+    const elements = path.get('elements');
     
-    return isStringLiteral(first) && isObjectExpression(last);
-};
-
-module.exports.isIncreaseIndent = not(notIncreaseIndent);
-function notIncreaseIndent(path) {
-    if (isInsideCallLoop(path))
+    if (!elements.length)
         return false;
     
-    if (isSecondSpread(path))
+    if (isInsideCallLoop(path))
         return false;
     
-    if (isStringAndObject(path))
+    if (elements[0].isObjectExpression())
         return true;
     
-    return isFirstObject(path);
+    if (isSpreadElement(elements[1]))
+        return false;
+    
+    return isStringAndObject(elements);
 }
 
 function isInsideCallLoop(path) {
@@ -286,6 +261,13 @@ function isInsideCallLoop(path) {
     return path.parentPath.parentPath.isForOfStatement();
 }
 
+const isStringAndObject = (elements) => {
+    const first = elements.at(0);
+    const last = elements.at(-1);
+    
+    return isStringLiteral(first) && isObjectExpression(last);
+};
+
 module.exports.isCurrentNewLine = (path) => {
     if (path.isSpreadElement())
         return true;

package/lib/tokenize/is.js

@@ -60,12 +60,7 @@ function isStringAndIdentifier([a, b]) {
     return isStringLiteral(a) && isIdentifier(b);
 }
 
-module.exports.isIdentifierAndIdentifier = (elements) => {
-    if (elements.length !== 2)
-        return false;
-    
-    const [a, b] = elements;
-    
+module.exports.isIdentifierAndIdentifier = ([a, b]) => {
     return isIdentifier(a) && isIdentifier(b);
 };
 module.exports.isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "6.12.0",
+  "version": "6.14.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",