@putout/printer 6.11.4 → 6.11.6

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.12.01, v6.11.6
+
+feature:
+- 60ae143 @putout/printer: BlockStatement: siplify
+
+2023.12.01, v6.11.5
+
+feature:
+- 96f6f4b @putout/printer: ArrayExpression: newline: isMultiLine
+
 2023.12.01, v6.11.4
 
 feature:

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

@@ -1,6 +1,40 @@
 '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,
@@ -49,7 +83,7 @@ const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
 const ONE_LINE = false;
 const MULTI_LINE = true;
 
-const isOneLine = satisfy([
+const isOneLineElements = satisfy([
     isOneSimple,
     isOneSpread,
     isIdentifierAndIdentifier,
@@ -64,35 +98,34 @@ const isOneLine = satisfy([
     isSimpleAndObject,
 ]);
 
+const isOneLinePath = satisfy([
+    isCallInsideArrow,
+    notIncreaseIndent,
+    isInsideLoop,
+    isTwoSimplesInsideObjectProperty,
+    isTwoStringsTupleAndParentIsArrayWithFirstArrayElement,
+]);
+
+const isMultiLinePath = satisfy([
+    tooLong,
+    isCoupleLines,
+    notNumbersInsideForOf,
+]);
+
 module.exports.isMultiLine = (path, {elements, maxElementsInOneLine}) => {
-    if (elements.length > 3 && !isObjectExpression(elements[0]))
+    if (isLotsOfElementsFirstNotObject(path))
         return MULTI_LINE;
     
-    if (isOneLine(elements))
-        return ONE_LINE;
-    
-    if (isCallInsideArrow(path))
+    if (isOneLineElements(elements))
         return ONE_LINE;
     
-    if (notIncreaseIndent(path))
-        return ONE_LINE;
-    
-    if (isInsideLoop(path))
+    if (isOneLinePath(path))
         return ONE_LINE;
     
     if (isShortTwoSimplesInsideCall(path, maxElementsInOneLine))
         return ONE_LINE;
     
-    if (isTwoSimplesInsideObjectProperty(path))
-        return ONE_LINE;
-    
-    if (isStringAndString(elements) && isParentIsArrayWithFirstArrayElement(path))
-        return ONE_LINE;
-    
-    if (tooLong(path) || isCoupleLines(path))
-        return MULTI_LINE;
-    
-    if (notNumbersInsideForOf(path))
+    if (isMultiLinePath(path))
         return MULTI_LINE;
     
     return ONE_LINE;
@@ -136,25 +169,6 @@ const isShortTwoSimplesInsideCall = (path, short) => {
     return length < short;
 };
 
-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(elements) {
     if (elements.length !== 1)
         return false;

package/lib/tokenize/statements/block-statement/block-statement.js

@@ -5,6 +5,8 @@ const {
     isParentProgram,
     isLast,
     exists,
+    satisfy,
+
 } = require('../../is');
 
 const {
@@ -12,6 +14,8 @@ const {
     isObjectMethod,
     isFunctionDeclaration,
     isExportDeclaration,
+    isDoWhileStatement,
+    isBlockStatement,
 } = require('@putout/babel').types;
 
 const {markAfter} = require('../../mark');
@@ -77,35 +81,62 @@ module.exports.BlockStatement = {
     },
 };
 
-function shouldAddNewlineAfter(path) {
-    const {parentPath} = path;
-    
-    if (parentPath.isDoWhileStatement())
+const isTopLevelWithNoNext = (path) => {
+    if (isNext(path))
         return false;
     
-    if (parentPath.isBlockStatement())
-        return true;
+    return !isNext(path.parentPath) && isParentProgram(path.parentPath);
+};
+
+const isInsideIfWithoutElseInsideFn = (path) => {
+    return parentIfWithoutElse(path) && path.find(isMethodOrArrow);
+};
+
+const isEmptyBodyNoNext = (path) => {
+    const {parentPath} = path;
+    return parentPath.isStatement() && !path.node.body.length && !isNext(parentPath);
+};
+
+const isLooksLikeInsideFn = ({parentPath}) => {
+    return /FunctionExpression/.test(parentPath.type);
+};
+
+const NEWLINE = true;
+const NO_NEWLINE = false;
+
+const isInsideDoWhile = ({parentPath}) => isDoWhileStatement(parentPath);
+const isInsideBlock = ({parentPath}) => isBlockStatement(parentPath);
+
+const isNoNewline = satisfy([
+    isInsideDoWhile,
+    isTopLevelWithNoNext,
+    insideIfWithNoBody,
+]);
+
+function shouldAddNewlineAfter(path) {
+    if (isInsideBlock(path))
+        return NEWLINE;
     
-    if (!isNext(path) && !isNext(path.parentPath) && isParentProgram(path.parentPath))
-        return false;
+    if (isNoNewline(path))
+        return NO_NEWLINE;
     
-    if (insideIfWithNoBody(path))
-        return false;
+    if (isInsideIfWithoutElseInsideFn(path))
+        return NEWLINE;
     
-    if (parentIfWithoutElse(path) && path.find(isMethodOrArrow))
-        return true;
+    if (isEmptyBodyNoNext(path))
+        return NO_NEWLINE;
     
-    if (parentPath.isStatement() && !path.node.body.length && !isNext(parentPath))
-        return false;
+    if (isTry(path))
+        return NO_NEWLINE;
     
-    if (isTry(path) || /FunctionExpression/.test(path.parentPath.type))
-        return false;
+    if (isLooksLikeInsideFn(path))
+        return NO_NEWLINE;
     
     if (isLast(path))
-        return false;
+        return NO_NEWLINE;
     
     if (isExportFunction(path))
-        return false;
+        return NO_NEWLINE;
     
     return !isNextIfAlternate(path);
 }

package/package.json

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