@putout/printer 1.2.0 → 1.3.1

package/lib/tokenize/expressions/RestElement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports.RestElement = (path, {write, traverse}) => {
+    write('...');
+    traverse(path.get('argument'));
+};

package/lib/tokenize/expressions/SpreadElement.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports.SpreadElement = (path, {write, traverse}) => {
+    write('...');
+    traverse(path.get('argument'));
+};

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

@@ -1,13 +1,13 @@
 'use strict';
 
-const {hasPrevNewline} = require('../mark');
+const {hasPrevNewline, isMarkedParent} = require('../mark');
 
 const {entries} = Object;
 
 module.exports.CallExpression = (path, {traverse, indent, write, incIndent, decIndent, maybeWrite}) => {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
-    if (shouldAddNewLine(path) && !hasPrevNewline(path.parentPath)) {
+    if (shouldAddNewLine(path) && !hasPrevNewline(path.parentPath) && !isMarkedParent(path)) {
         write.newline();
         write.indent();
     }

package/lib/tokenize/expressions/index.js

@@ -13,6 +13,8 @@ const {AssignmentExpression} = require('./assignment-expression');
 const {ArrayExpression} = require('./array-expression');
 const {ArrayPattern} = require('./array-pattern');
 const {AssignmentPattern} = require('./assignment-pattern');
+const {RestElement} = require('./RestElement');
+const {SpreadElement} = require('./SpreadElement');
 
 module.exports = {
     ...functions,
@@ -27,6 +29,8 @@ module.exports = {
     NewExpression,
     ObjectExpression,
     ObjectPattern,
+    RestElement,
+    SpreadElement,
     BinaryExpression(path, {traverse, write}) {
         traverse(path.get('left'));
         write(` ${path.node.operator} `);

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

@@ -1,45 +1,66 @@
 'use strict';
 
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
-const isForOf = (path) => path.parentPath?.parentPath?.isForOfStatement();
+const isForOf = (path) => {
+    if (path.parentPath.isForOfStatement())
+        return true;
+    
+    if (path.parentPath?.parentPath?.isForOfStatement())
+        return true;
+    
+    return false;
+};
 
-module.exports.ObjectExpression = (path, {traverse, write, maybeWrite, maybeIndent, incIndent, decIndent}) => {
-    incIndent();
+module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
+    indent.inc();
     
     const properties = path.get('properties');
     const parens = isBodyOfArrow(path);
     const isCall = path.parentPath.isCallExpression();
-    const isOneLine = isCall && properties.length < 2 || isForOf(path);
+    const {length} = properties;
+    const isOneLine = !length || (isCall && length < 2 || isForOf(path));
     
-    maybeWrite(parens, '(');
+    maybe.write(parens, '(');
     write('{');
     
-    maybeWrite(!isOneLine, '\n');
+    maybe.write(!isOneLine, '\n');
     
     for (const property of properties) {
+        if (property.isSpreadElement()) {
+            maybe.indent(properties.length > 1);
+            traverse(property);
+            
+            if (properties.length > 1) {
+                write(',');
+                write.newline();
+            }
+            
+            continue;
+        }
+        
         const {shorthand, computed} = property.node;
         
-        maybeIndent(!isOneLine);
+        maybe.indent(!isOneLine);
         
         if (property.isObjectMethod()) {
             traverse(property);
             continue;
         }
         
-        maybeWrite(computed, '[');
+        maybe.write(computed, '[');
         traverse(property.get('key'));
-        maybeWrite(computed, ']');
+        maybe.write(computed, ']');
         
         if (!shorthand) {
             write(': ');
             traverse(property.get('value'));
         }
         
-        maybeWrite(!isOneLine, ',\n');
+        maybe.write(!isOneLine, ',\n');
     }
     
-    decIndent();
-    maybeIndent(!isOneLine);
+    indent.dec();
+    maybe.indent(!isOneLine);
     write('}');
-    maybeWrite(parens, ')');
+    maybe.write(parens, ')');
 };

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

@@ -2,7 +2,6 @@
 
 const {entries} = Object;
 const isForOf = (path) => path.parentPath?.parentPath?.parentPath?.isForOfStatement();
-const isAssign = (path) => path.isAssignmentPattern();
 
 module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite, incIndent, decIndent}) => {
     incIndent();
@@ -16,6 +15,11 @@ module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite,
     maybeWrite(is, '\n');
     
     for (const [i, property] of entries(properties)) {
+        if (property.isRestElement()) {
+            traverse(property);
+            continue;
+        }
+        
         const valuePath = property.get('value');
         const keyPath = property.get('key');
         const {shorthand} = property.node;
@@ -28,7 +32,7 @@ module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite,
             traverse(valuePath);
         }
         
-        if (isAssign(valuePath))
+        if (valuePath.isAssignmentPattern())
             traverse(valuePath);
         
         if (is) {

package/lib/tokenize/is.js

@@ -2,4 +2,3 @@
 
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 module.exports.isNext = (path) => path.getNextSibling().node;
-

package/lib/tokenize/mark.js

@@ -19,3 +19,7 @@ module.exports.hasPrevNewline = (path) => {
 };
 
 module.exports.maybeMark = (a, path) => a && mark(path);
+
+module.exports.isMarkedParent = (path) => {
+    return isMarked(path.parentPath);
+};

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

@@ -1,8 +1,10 @@
 'use strict';
 
+const {mark} = require('../mark');
 module.exports.ExpressionStatement = (path, {write, indent, traverse}) => {
     if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path)) {
         write.linebreak();
+        mark(path);
     }
     
     const expressionPath = path.get('expression');

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

@@ -1,12 +1,13 @@
 'use strict';
 
+const {isMarked} = require('../mark');
 const isPrevNewLine = (path) => {
     const prev = path.getPrevSibling();
     
     if (!prev.node)
         return true;
     
-    return prev.__putout_newline;
+    return isMarked(prev);
 };
 
 module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
@@ -36,9 +37,4 @@ module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
         write(' ');
         traverse(bodyPath);
     }
-    
-    if (path.getNextSibling().node) {
-        //write.newline();
-        //path.__putout_newline = true;
-    }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "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",