@putout/printer 2.10.0 → 2.12.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2023.06.13, v2.12.0
+
+feature:
+- a264001 @putout/printer: ArrayExpression: newline
+- cbe69f6 @putout/printer: BlockStatement
+
+2023.06.13, v2.11.0
+
+feature:
+- e7a9a98 @putout/printer: TSDeclare: add support of declare
+
 2023.06.13, v2.10.0
 
 feature:

package/lib/tokenize/comments.js

@@ -104,7 +104,7 @@ module.exports.parseComments = (path, {write}, semantics) => {
 };
 
 function isSameLine(path, loc) {
-    return path.node.loc.start.line === loc.start.line || path.node.loc.end.line === loc.end.line;
+    return path.node.loc?.start.line === loc.start.line || path.node.loc?.end.line === loc.end.line;
 }
 
 function maybeInsideFn(insideFn, {print, indent}) {

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

@@ -1,84 +1,20 @@
 'use strict';
 
-const {round} = Math;
-
-const {
-    isObjectProperty,
-    isStringLiteral,
-    isArrayExpression,
-    isIdentifier,
-    isCallExpression,
-    isBooleanLiteral,
-    isNullLiteral,
-    isObjectExpression,
-    isAwaitExpression,
-} = require('@babel/types');
-
-const {isSimple} = require('@putout/operate');
-
 const {
     isCoupleLines,
     isStringAndIdentifier,
-    isIdentifierAndString,
-    isStringAndMember,
+    isIdentifierAndIdentifier,
+    isStringAndArray,
 } = require('../../is');
 
-const isForOf = ({parentPath}) => parentPath.isForOfStatement();
+const {
+    isNewlineBetweenElements,
+    isIncreaseIndent,
+} = require('./new-line');
 
 const isInsideOneElementArray = ({parentPath}) => parentPath.node.elements.length === 1;
-
-const isStringAndArray = ([a, b]) => {
-    if (!isStringLiteral(a))
-        return false;
-    
-    if (!isArrayExpression(b))
-        return false;
-    
-    return !isStringAndIdentifier(b.node.elements);
-};
-
-const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
-
-const isShortTwoSimplesInsideCall = (path, short) => {
-    const {
-        node,
-        parentPath,
-    } = path;
-    
-    const {elements} = node;
-    const {length} = elements;
-    const [a, b] = elements;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return length < short;
-};
-
-const isIdentifierAndIdentifier = ([a, b]) => isIdentifier(a) && isIdentifier(b);
 const isInsideArray = (path) => path.parentPath.isArrayExpression();
 
-const isSimpleAndCall = ([a, b]) => {
-    if (!isSimple(a))
-        return;
-    
-    return isCallExpression(b) || isAwaitExpression(b);
-};
-
-const isBooleanAndSimple = ([a, b]) => isBooleanLiteral(a) && isSimple(b);
-const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
-const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
-
-const isStringAndObject = (elements) => {
-    const first = elements.at(0);
-    const last = elements.at(-1);
-    
-    return isStringLiteral(first) && isObjectExpression(last);
-};
-
 const isTwoLongStrings = ([a, b]) => {
     const LONG_STRING = 20;
     
@@ -177,184 +113,3 @@ module.exports.ArrayExpression = {
         indent.inc();
     },
 };
-
-function isNumbers(elements) {
-    for (const element of elements) {
-        if (element.isNumericLiteral())
-            return true;
-    }
-    
-    return false;
-}
-
-function isLastArg({parentPath}) {
-    return !parentPath.isCallExpression();
-}
-
-function isParentProperty(path) {
-    return path.find(isObjectProperty);
-}
-
-function isIncreaseIndent(path) {
-    const elements = path.get('elements');
-    
-    if (!elements.length)
-        return false;
-    
-    if (isInsideCallLoop(path))
-        return false;
-    
-    if (elements[0].isObjectExpression())
-        return true;
-    
-    if (isStringAndObject(elements))
-        return true;
-    
-    return false;
-}
-
-function tooLong(path) {
-    const elements = path.get('elements');
-    
-    if (elements.length < 2)
-        return false;
-    
-    for (const el of path.get('elements')) {
-        if (el.isStringLiteral() && el.node.value.length > 4)
-            return true;
-    }
-    
-    return false;
-}
-
-function isCallInsideArrow(path) {
-    const {parentPath} = path;
-    
-    if (!parentPath.isCallExpression())
-        return false;
-    
-    if (!parentPath.parentPath.isFunction())
-        return false;
-    
-    return path.node.elements.length < 4;
-}
-
-function isOneSimple(path) {
-    const elements = path.get('elements');
-    
-    if (elements.length !== 1)
-        return false;
-    
-    const [first] = elements;
-    
-    if (first.isIdentifier() && first.node.name.length < 5)
-        return true;
-    
-    if (first.isCallExpression())
-        return false;
-    
-    return first.isMemberExpression();
-}
-
-function isNewlineBetweenElements(path, {elements, maxElementsInOneLine}) {
-    if (elements.length > 3 && !isObjectExpression(elements[0]))
-        return true;
-    
-    if (isOneSimple(path))
-        return false;
-    
-    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
-        return false;
-    
-    if (isCallInsideArrow(path))
-        return false;
-    
-    if (isOneElementCall(path, {elements}))
-        return false;
-    
-    if (isIncreaseIndent(path))
-        return false;
-    
-    if (isInsideLoop(path))
-        return false;
-    
-    if (isBooleanAndSimple(elements))
-        return false;
-    
-    if (isNullAndSimple(elements))
-        return false;
-    
-    if (isSimpleAndCall(elements))
-        return false;
-    
-    if (isShortTwoSimplesInsideCall(path, maxElementsInOneLine))
-        return false;
-    
-    if (isTwoStringsDifferentLength(elements))
-        return false;
-    
-    if (isStringAndArray(elements))
-        return false;
-    
-    if (isStringAndMember(elements))
-        return false;
-    
-    if (isStringAndIdentifier(elements))
-        return false;
-    
-    if (isIdentifierAndString(elements))
-        return false;
-    
-    if (isSimpleAndObject(elements))
-        return false;
-    
-    if (isStringAndString(elements) && path.parentPath.isArrayExpression() && isArrayExpression(path.parentPath.node.elements[0]))
-        return false;
-    
-    if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
-        return true;
-    
-    return false;
-}
-
-function isTwoStringsDifferentLength(strings) {
-    const [a, b] = strings;
-    
-    if (strings.length > 2)
-        return false;
-    
-    if (!a?.isStringLiteral() || !b?.isStringLiteral())
-        return false;
-    
-    const aLength = a.node.value.length;
-    const bLength = b.node.value.length;
-    
-    return round(bLength / aLength) > 2;
-}
-
-function isInsideCallLoop(path) {
-    if (!path.parentPath.isCallExpression())
-        return false;
-    
-    if (!path.parentPath.parentPath.isForOfStatement())
-        return false;
-    
-    return true;
-}
-
-function isInsideLoop(path) {
-    if (!path.parentPath.isForOfStatement())
-        return false;
-    
-    return true;
-}
-
-const isOneElementCall = (path, {elements}) => {
-    if (!path.parentPath.isCallExpression())
-        return false;
-    
-    if (elements.length !== 1)
-        return false;
-    
-    return !isCallExpression(elements[0]);
-};

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

@@ -0,0 +1,239 @@
+'use strict';
+
+const {isSimple} = require('@putout/operate');
+const {
+    isObjectExpression,
+    isArrayExpression,
+    isObjectProperty,
+    isCallExpression,
+    isAwaitExpression,
+    isBooleanLiteral,
+    isNullLiteral,
+    isStringLiteral,
+
+} = require('@babel/types');
+const {
+    isStringAndMember,
+    isStringAndIdentifier,
+    isIdentifierAndString,
+    isCoupleLines,
+    isStringAndArray,
+    isIdentifierAndIdentifier,
+
+} = require('../../is');
+
+const {round} = Math;
+
+const isSimpleAndCall = ([a, b]) => {
+    if (!isSimple(a))
+        return;
+    
+    return isCallExpression(b) || isAwaitExpression(b);
+};
+
+const isBooleanAndSimple = ([a, b]) => isBooleanLiteral(a) && isSimple(b);
+const isNullAndSimple = ([a, b]) => isNullLiteral(a) && isSimple(b);
+const isSimpleAndObject = ([a, b]) => isSimple(a) && isObjectExpression(b);
+const ONE_LINE = false;
+const MULTI_LINE = true;
+
+module.exports.isNewlineBetweenElements = (path, {elements, maxElementsInOneLine}) => {
+    if (elements.length > 3 && !isObjectExpression(elements[0]))
+        return MULTI_LINE;
+    
+    if (isOneSimple(path))
+        return ONE_LINE;
+    
+    if (elements.length === 2 && isIdentifierAndIdentifier(elements))
+        return ONE_LINE;
+    
+    if (isCallInsideArrow(path))
+        return ONE_LINE;
+    
+    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 (isTwoStringsDifferentLength(elements))
+        return ONE_LINE;
+    
+    if (isStringAndArray(elements))
+        return ONE_LINE;
+    
+    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;
+    
+    if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
+        return MULTI_LINE;
+    
+    return ONE_LINE;
+};
+
+const isForOf = ({parentPath}) => parentPath.isForOfStatement();
+
+const isStringAndString = ([a, b]) => isStringLiteral(a) && isStringLiteral(b);
+
+const isShortTwoSimplesInsideCall = (path, short) => {
+    const {
+        node,
+        parentPath,
+    } = path;
+    
+    const {elements} = node;
+    const {length} = elements;
+    const [a, b] = elements;
+    
+    if (!parentPath.isCallExpression())
+        return false;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return length < short;
+};
+
+function isOneSimple(path) {
+    const elements = path.get('elements');
+    
+    if (elements.length !== 1)
+        return false;
+    
+    const [first] = elements;
+    
+    if (first.isIdentifier() && first.node.name.length < 5)
+        return true;
+    
+    if (!first.isIdentifier() && isSimple(first))
+        return true;
+    
+    if (first.isCallExpression())
+        return false;
+    
+    return first.isMemberExpression();
+}
+
+function isTwoStringsDifferentLength(strings) {
+    const [a, b] = strings;
+    
+    if (strings.length > 2)
+        return false;
+    
+    if (!a?.isStringLiteral() || !b?.isStringLiteral())
+        return false;
+    
+    const aLength = a.node.value.length;
+    const bLength = b.node.value.length;
+    
+    return round(bLength / aLength) > 2;
+}
+
+function isInsideLoop(path) {
+    if (!path.parentPath.isForOfStatement())
+        return false;
+    
+    return true;
+}
+
+function tooLong(path) {
+    const elements = path.get('elements');
+    
+    if (elements.length < 2)
+        return false;
+    
+    for (const el of path.get('elements')) {
+        if (el.isStringLiteral() && el.node.value.length > 4)
+            return true;
+    }
+    
+    return false;
+}
+
+function isCallInsideArrow(path) {
+    const {parentPath} = path;
+    
+    if (!parentPath.isCallExpression())
+        return false;
+    
+    if (!parentPath.parentPath.isFunction())
+        return false;
+    
+    return path.node.elements.length < 4;
+}
+
+function isNumbers(elements) {
+    for (const element of elements) {
+        if (element.isNumericLiteral())
+            return true;
+    }
+    
+    return false;
+}
+
+function isLastArg({parentPath}) {
+    return !parentPath.isCallExpression();
+}
+
+function isParentProperty(path) {
+    return path.find(isObjectProperty);
+}
+module.exports.isIncreaseIndent = isIncreaseIndent;
+function isIncreaseIndent(path) {
+    const elements = path.get('elements');
+    
+    if (!elements.length)
+        return false;
+    
+    if (isInsideCallLoop(path))
+        return false;
+    
+    if (elements[0].isObjectExpression())
+        return true;
+    
+    if (isStringAndObject(elements))
+        return true;
+    
+    return false;
+}
+
+function isInsideCallLoop(path) {
+    if (!path.parentPath.isCallExpression())
+        return false;
+    
+    if (!path.parentPath.parentPath.isForOfStatement())
+        return false;
+    
+    return true;
+}
+
+const isStringAndObject = (elements) => {
+    const first = elements.at(0);
+    const last = elements.at(-1);
+    
+    return isStringLiteral(first) && isObjectExpression(last);
+};

package/lib/tokenize/is.js

@@ -8,6 +8,8 @@ const {
     isForOfStatement,
     isVariableDeclaration,
     isMemberExpression,
+    isArrayExpression,
+
 } = require('@babel/types');
 
 const isParentProgram = (path) => path.parentPath?.isProgram();
@@ -43,9 +45,23 @@ function isCoupleLines(path) {
 }
 
 module.exports.exists = (a) => a.node;
-module.exports.isStringAndIdentifier = ([a, b]) => isStringLiteral(a) && isIdentifier(b);
+module.exports.isStringAndIdentifier = isStringAndIdentifier;
+function isStringAndIdentifier([a, b]) {
+    return isStringLiteral(a) && isIdentifier(b);
+}
+
+module.exports.isIdentifierAndIdentifier = ([a, b]) => isIdentifier(a) && isIdentifier(b);
 module.exports.isStringAndMember = ([a, b]) => isStringLiteral(a) && isMemberExpression(b);
 module.exports.isIdentifierAndString = ([a, b]) => isIdentifier(a) && isStringLiteral(b);
+module.exports.isStringAndArray = ([a, b]) => {
+    if (!isStringLiteral(a))
+        return false;
+    
+    if (!isArrayExpression(b))
+        return false;
+    
+    return !isStringAndIdentifier(b.node.elements);
+};
 
 const isIfOrStatement = (a) => isIfStatement(a) || isStatement(a);
 const isForOfOrStatement = (a) => isForOfStatement(a) || isStatement(a);

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

@@ -36,9 +36,7 @@ module.exports.BlockStatement = {
             print(element);
         }
         
-        parseComments(path, {
-            write,
-        }, semantics);
+        parseComments(path, {write}, semantics);
         
         indent.dec();
         maybe.indent(body.length);

package/lib/tokenize/typescript/ts-declare-function.js

@@ -1,6 +1,9 @@
 'use strict';
 
 module.exports.TSDeclareFunction = (path, {print, maybe}) => {
+    const {declare} = path.node;
+    
+    maybe.print(declare, 'declare ');
     print('function ');
     print('__id');
     print('(');

package/package.json

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