@putout/printer 1.20.0 → 1.22.0

package/ChangeLog

@@ -1,3 +1,15 @@
+2023.04.04, v1.22.0
+
+feature:
+- c8fc7b7 @putout/printer: improve support of tuples
+- 599bd93 @putout/printer: set @putout/printer as putout printer
+
+2023.04.04, v1.21.0
+
+feature:
+- d5716be @putout/printer: ForOfStatement: convert
+- 5bd0fe5 @putout/printer: improve newlines formatting
+
 2023.04.03, v1.20.0
 
 feature:

package/lib/tokenize/debug.js

@@ -52,8 +52,10 @@ module.exports.createLog = ({newline = '\n', store = createStore()} = {}) => ({t
 function createStore() {
     let chunks = [];
     
-    return (chunk) => {
-        if (chunk) {
+    return (...args) => {
+        const [chunk] = args;
+        
+        if (args.length) {
             chunks.push(chunk);
             return;
         }

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

@@ -8,6 +8,7 @@ const isForOf = ({parentPath}) => parentPath.isForOfStatement();
 const SECOND = 1;
 
 const isStringAndArray = ([a, b]) => a?.isStringLiteral() && b?.isArrayExpression();
+const isStringAndIdentifier = ([a, b]) => a?.isStringLiteral() && b?.isIdentifier();
 const isArrayParent = (path) => path.parentPath.isArrayExpression();
 const isTwoLongStrings = ([a, b]) => {
     const LONG_STRING = 20;
@@ -27,9 +28,8 @@ module.exports.ArrayExpression = (path, {print, maybe, indent}) => {
     
     print('[');
     
-    if (!isTwoLongStrings(elements) && !shouldIncreaseIndent) {
-        indent.inc();
-    }
+    if (!isTwoLongStrings(elements))
+        maybe.indent.inc(!shouldIncreaseIndent);
     
     const isNewLine = isNewlineBetweenElements(path, {elements});
     const n = elements.length - 1;
@@ -133,13 +133,21 @@ function isNewlineBetweenElements(path, {elements}) {
     if (isStringAndArray(elements))
         return false;
     
+    if (isStringAndIdentifier(elements))
+        return false;
+    
     if (tooLong(path) || isCoupleLines(path) || !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path))
         return true;
     
     return false;
 }
 
-function isTwoStringsDifferentLength([a, b]) {
+function isTwoStringsDifferentLength(strings) {
+    const [a, b] = strings;
+    
+    if (strings.length > 2)
+        return false;
+    
     if (!a?.isStringLiteral() || !b?.isStringLiteral())
         return false;
     

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

@@ -6,7 +6,6 @@ module.exports.ArrayPattern = (path, {indent, maybe, print}) => {
     print('[');
     
     const elements = path.get('elements');
-    
     indent.inc();
     
     const isNewLine = !isForOf(path) && elements.length > 2;

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

@@ -1,17 +1,6 @@
 'use strict';
 
-const {
-    isMarkedParentBefore,
-    hasPrevNewline,
-} = require('../mark');
-
 const CallExpression = {
-    beforeIf(path) {
-        return isNewLineBefore(path) && !isMarkedParentBefore(path) && !hasPrevNewline(path.parentPath);
-    },
-    before(path, {print}) {
-        print.breakline();
-    },
     print(path, {indent, print, maybe}) {
         const isParentCall = toLong(path) && path.parentPath.isCallExpression();
         print('__callee');
@@ -57,27 +46,6 @@ const CallExpression = {
 module.exports.OptionalCallExpression = CallExpression;
 module.exports.CallExpression = CallExpression;
 
-function isNewLineBefore({parentPath}) {
-    if (!parentPath.isExpressionStatement())
-        return false;
-    
-    const prevPath = parentPath.getPrevSibling();
-    const prevPrevPath = prevPath.getPrevSibling();
-    
-    if (prevPath.isStatement() && !prevPath.isExpressionStatement() && !prevPath.isVariableDeclaration())
-        return true;
-    
-    const twoPrev = prevPath.node && prevPrevPath.node;
-    
-    if (!twoPrev)
-        return false;
-    
-    if (prevPath.isExpressionStatement() && prevPath.get('expression').isCallExpression())
-        return false;
-    
-    return true;
-}
-
 function toLong(path) {
     const args = path.get('arguments');
     

package/lib/tokenize/expressions/class.js

@@ -5,6 +5,7 @@ module.exports.ClassDeclaration = classVisitor;
 
 module.exports.ClassDeclaration = (path, {print, indent}) => {
     indent();
+    
     classVisitor(path, {
         print,
         indent,

package/lib/tokenize/expressions/functions.js

@@ -16,7 +16,6 @@ module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     maybe.print(generator, '*');
     
     const id = path.get('id');
-    
     write.space();
     
     if (id.node) {

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

@@ -6,7 +6,6 @@ module.exports.NewExpression = (path, {indent, print, maybe}) => {
     print('__callee');
     
     const args = path.get('arguments');
-    
     print('(');
     
     const n = args.length - 1;

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

@@ -52,10 +52,16 @@ module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
     indent.dec();
     maybe.indent(manyLines);
     print('}');
-    maybe.print.newline(path.parentPath.isLogicalExpression());
+    maybe.print.newline(shouldAddNewline(path));
     maybe.print(parens, ')');
 };
 
+function shouldAddNewline(path) {
+    if (!path.parentPath.isLogicalExpression())
+        return false;
+    
+    return path.parentPath.parentPath.isSpreadElement();
+}
 module.exports.ObjectProperty = (path, {print, maybe}) => {
     const {
         shorthand,

package/lib/tokenize/is.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {isMarkedAfter} = require('./mark');
 const isParentProgram = (path) => path.parentPath?.isProgram();
 const isParentBlock = (path) => path.parentPath.isBlockStatement();
 
@@ -9,6 +10,9 @@ const isNext = (path) => {
     if (!next.node)
         return false;
     
+    if (isMarkedAfter(path.get('body')))
+        return false;
+    
     return !next.isEmptyStatement();
 };
 

package/lib/tokenize/mark.js

@@ -14,20 +14,11 @@ function markBefore(path) {
 function markAfter(path) {
     path[WATER_MARK_AFTER] = true;
 }
-module.exports.isMarkedBefore = isMarkedBefore;
 module.exports.isMarkedAfter = isMarkedAfter;
 
-function isMarkedBefore(path) {
-    return path[WATER_MARK_BEFORE];
-}
-
 function isMarkedAfter(path) {
     return path[WATER_MARK_AFTER];
 }
 module.exports.hasPrevNewline = (path) => {
     return isMarkedAfter(path.getPrevSibling());
 };
-
-module.exports.isMarkedParentBefore = (path) => {
-    return isMarkedBefore(path.parentPath);
-};

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

@@ -1,7 +1,6 @@
 'use strict';
 
 const {
-    isNext,
     isParentBlock,
     isNextParent,
 } = require('../is');
@@ -15,9 +14,12 @@ module.exports.BreakStatement = {
         print('break;');
     },
     afterIf(path) {
-        if (!isNext(path) && !isParentBlock(path) && !isNextParent(path))
-            return false;
+        if (isParentBlock(path))
+            return true;
         
-        return true;
+        if (isNextParent(path))
+            return true;
+        
+        return false;
     },
 };

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

@@ -72,7 +72,7 @@ function shouldAddNewLineAfter(path) {
     if (isNext(path))
         return true;
     
-    return false;
+    return path.findParent(isNext);
 }
 
 function isStrictMode(path) {

package/lib/tokenize/statements/for-of-statement.js

@@ -11,40 +11,44 @@ const {
     isNext,
 } = require('../is');
 
-module.exports.ForOfStatement = (path, {indent, print, maybe}) => {
-    if (!isFirst(path) && !hasPrevNewline(path)) {
+module.exports.ForOfStatement = {
+    beforeIf(path) {
+        return !isFirst(path) && !hasPrevNewline(path);
+    },
+    before(path, {print}) {
         print.indent();
         print.newline();
         markBefore(path);
-    }
-    
-    indent();
-    print('for (');
-    print('__left');
-    print(' of ');
-    print('__right');
-    print(')');
-    
-    const bodyPath = path.get('body');
-    
-    if (bodyPath.isExpressionStatement()) {
-        indent.inc();
-        print.newline();
-        print('__body');
-        indent.dec();
-        maybe.print.newline(isNext(path));
+    },
+    print(path, {indent, print, maybe}) {
+        indent();
+        print('for (');
+        print('__left');
+        print(' of ');
+        print('__right');
+        print(')');
+        
+        const bodyPath = path.get('body');
+        
+        if (bodyPath.isExpressionStatement()) {
+            indent.inc();
+            print.newline();
+            print('__body');
+            indent.dec();
+            maybe.print.newline(isNext(path));
+            
+            return;
+        }
         
-        return;
-    }
-    
-    if (bodyPath.isBlockStatement()) {
-        print(' ');
-        print('__body');
-    }
-    
-    if (isNext(path)) {
+        if (bodyPath.isBlockStatement()) {
+            print(' ');
+            print('__body');
+        }
+    },
+    afterIf: isNext,
+    after(path, {print}) {
         print.indent();
         print.newline();
         markAfter(path);
-    }
+    },
 };

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

@@ -37,23 +37,17 @@ module.exports.IfStatement = {
             write(' else ');
             traverse(alternate);
         } else if (alternate.isIfStatement()) {
-            print.space();
+            write.space();
             write('else');
-            print.space();
+            write.space();
             traverse(alternate);
         } else if (alternate.node) {
-            print.breakline();
             write('else');
             print.newline();
             indent.inc();
             traverse(alternate);
             indent.dec();
         }
-        
-        const next = path.getNextSibling();
-        
-        if (next.isExpressionStatement() && !next.get('expression').isCallExpression())
-            print.newline();
     },
     afterIf: (path) => {
         const next = path.getNextSibling();

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

@@ -18,7 +18,6 @@ module.exports.SwitchStatement = (path, {print, maybe}) => {
         print(':');
         
         const isBlock = switchCase.get('consequent.0').isBlockStatement();
-        
         maybe.indent.inc(!isBlock);
         maybe.print.newline(!isBlock);
         

package/lib/tokenize/statements/try-statements.js

@@ -14,9 +14,9 @@ module.exports.TryStatement = (path, {print, maybe}) => {
         print('finally');
         print(' ');
         print(finalizer);
-        print.newline();
     }
     
+    print.newline();
     maybe.print.breakline(isNext(path));
 };
 

package/lib/tokenize/statements/variable-declaration.js

@@ -23,9 +23,8 @@ module.exports.VariableDeclaration = {
         print('__declarations.0.id');
         
         const initPath = path.get('declarations.0.init');
-        
         maybe.print(initPath.node, ' = ');
-        print(initPath);
+        print('__declarations.0.init');
         maybe.print(isParentBlock(path), ';');
         
         let wasNewline = false;
@@ -60,10 +59,14 @@ function shouldAddNewlineAfter(path) {
         return true;
     
     const next = path.getNextSibling();
+    const prev = path.getPrevSibling();
     
     if (isCoupleLines(next))
         return true;
     
+    if (prev.isVariableDeclaration() && !next.isVariableDeclaration())
+        return true;
+    
     return false;
 }
 const isLast = (path) => path.parentPath.isProgram() && !isNext(path);

package/lib/tokenize/tokenize.js

@@ -243,4 +243,3 @@ const computePath = (path, maybeLine) => {
     
     return maybeLine;
 };
-

package/lib/tokenize/typescript/index.js

@@ -59,6 +59,7 @@ module.exports = {
         write('{');
         write.newline();
         indent.inc();
+        
         for (const member of path.get('members')) {
             indent();
             traverse(member);
@@ -78,4 +79,3 @@ module.exports = {
         print('__typeAnnotation');
     },
 };
-

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Easiest possible opinionated Babel AST printer made with ❤️  to use in 🐊Putout",