@putout/printer 1.4.2 → 1.5.1

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.18, v1.5.1
+
+feature:
+- a79e4f6 @putout/printer: print, indent, maybe
+
+2023.03.18, v1.5.0
+
+feature:
+- db7c503 @putout/printer: add support of YieldExpression, SequenceExpressions, FunctionExpression + generator
+
 2023.03.18, v1.4.2
 
 feature:

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

@@ -7,44 +7,43 @@ const {
 
 const {entries} = Object;
 
-module.exports.CallExpression = (path, {traverse, indent, write, incIndent, decIndent, maybeWrite}) => {
+module.exports.CallExpression = (path, {indent, print, maybe}) => {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
     if (shouldAddNewLine(path) && !isMarkedParentBefore(path) && !isMarkedPrevAfter(path.parentPath))
-        write.linebreak();
+        print.linebreak();
     
-    traverse(path.get('callee'));
-    write('(');
+    print(path.get('callee'));
+    print('(');
     
     const args = path.get('arguments');
     const n = args.length - 1;
     
-    if (isParentCall)
-        incIndent();
+    maybe.indent.inc(isParentCall);
     
     for (const [i, arg] of entries(args)) {
         if (isParentCall) {
-            write.newline();
+            print.newline();
             indent();
         }
         
-        traverse(arg);
+        print(arg);
         
         if (isParentCall) {
-            write(',');
+            print(',');
             continue;
         }
         
-        maybeWrite(i < n, ', ');
+        maybe.print(i < n, ', ');
     }
     
     if (isParentCall) {
-        decIndent();
-        write.newline();
-        write.indent();
+        indent.dec();
+        print.newline();
+        print.indent();
     }
     
-    write(')');
+    print(')');
 };
 
 function shouldAddNewLine({parentPath}) {

package/lib/tokenize/expressions/class-declaration.js

@@ -4,27 +4,27 @@ const {entries} = Object;
 
 const isFirst = (path) => path.node === path.parentPath.node.body[0];
 
-module.exports.ClassDeclaration = (path, {write, maybeWrite, writeEmptyLine, indent, incIndent, decIndent, traverse}) => {
+module.exports.ClassDeclaration = (path, {maybe, print, indent}) => {
     if (!isFirst(path)) {
-        writeEmptyLine();
+        print.linebreak();
     }
     
     indent();
-    write('class ');
-    traverse(path.get('id'));
-    write(' {\n');
-    incIndent();
+    print('class ');
+    print(path.get('id'));
+    print(' {\n');
+    indent.inc();
     
     const body = path.get('body.body');
     const n = body.length - 1;
     
     for (const [i, item] of entries(body)) {
         indent();
-        traverse(item);
-        maybeWrite(i < n, '\n');
+        print(item);
+        maybe.print(i < n, '\n');
     }
     
-    decIndent();
-    write('}');
+    indent.dec();
+    print('}');
 };
 

package/lib/tokenize/expressions/functions.js

@@ -3,7 +3,35 @@
 const {isMarkedPrevAfter} = require('../mark');
 const isFirst = (path) => path.node === path.parentPath.node.body[0];
 
-module.exports.ArrowFunctionExpression = (path, {write, maybe, traverse}) => {
+module.exports.FunctionExpression = (path, {write, maybe, traverse}) => {
+    const {node} = path;
+    
+    const {
+        generator,
+        async,
+    } = node;
+    
+    maybe.write(async, 'async ');
+    write('function');
+    maybe.write(generator, '*');
+    write(' (');
+    
+    const params = path.get('params');
+    const n = params.length;
+    
+    for (let i = 0; i < n; i++) {
+        traverse(params[i]);
+        
+        if (i < n - 1)
+            write(', ');
+    }
+    
+    write(') ');
+    traverse(path.get('body'));
+};
+
+module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
+function ArrowFunctionExpression(path, {write, maybe, traverse}) {
     const {async} = path.node;
     maybe.write(async, 'async ');
     
@@ -21,7 +49,7 @@ module.exports.ArrowFunctionExpression = (path, {write, maybe, traverse}) => {
     
     write(') => ');
     traverse(path.get('body'));
-};
+}
 
 module.exports.ObjectMethod = (path, {write, traverse}) => {
     traverse(path.get('key'));
@@ -84,3 +112,4 @@ module.exports.ClassMethod = (path, {write, traverse}) => {
     write(') ');
     traverse(path.get('body'));
 };
+

package/lib/tokenize/expressions/index.js

@@ -15,6 +15,7 @@ const {ArrayPattern} = require('./array-pattern');
 const {AssignmentPattern} = require('./assignment-pattern');
 const {RestElement} = require('./rest-element');
 const {SpreadElement} = require('./spread-element');
+const {SequenceExpression} = require('./sequence-expression');
 
 module.exports = {
     ...functions,
@@ -31,6 +32,7 @@ module.exports = {
     ObjectPattern,
     RestElement,
     SpreadElement,
+    SequenceExpression,
     BinaryExpression(path, {traverse, write}) {
         traverse(path.get('left'));
         write(` ${path.node.operator} `);

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

@@ -3,20 +3,19 @@
 const {entries} = Object;
 const isForOf = (path) => path.parentPath?.parentPath?.parentPath?.isForOfStatement();
 
-module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite, incIndent, decIndent}) => {
-    incIndent();
-    
-    write('{');
+module.exports.ObjectPattern = (path, {indent, print, maybe}) => {
+    indent.inc();
+    print('{');
     
     const properties = path.get('properties');
     const n = properties.length - 1;
     
     const is = !isForOf(path) && !path.parentPath.isFunction() && n && checkLength(properties);
-    maybeWrite(is, '\n');
+    maybe.print(is, '\n');
     
     for (const [i, property] of entries(properties)) {
         if (property.isRestElement()) {
-            traverse(property);
+            print(property);
             continue;
         }
         
@@ -24,29 +23,29 @@ module.exports.ObjectPattern = (path, {traverse, maybeIndent, write, maybeWrite,
         const keyPath = property.get('key');
         const {shorthand} = property.node;
         
-        maybeIndent(is);
-        traverse(keyPath);
+        maybe.indent(is);
+        print(keyPath);
         
         if (!shorthand) {
-            write(': ');
-            traverse(valuePath);
+            print(': ');
+            print(valuePath);
         }
         
         if (valuePath.isAssignmentPattern())
-            traverse(valuePath);
+            print(valuePath);
         
         if (is) {
-            write(',\n');
+            print(',');
+            print.newline();
             continue;
         }
         
-        if (i < n)
-            write(', ');
+        maybe.print(i < n, ', ');
     }
     
-    decIndent();
-    maybeIndent(is);
-    write('}');
+    indent.dec();
+    maybe.indent(is);
+    print('}');
 };
 
 function checkLength(properties) {
@@ -57,3 +56,4 @@ function checkLength(properties) {
     
     return false;
 }
+

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

@@ -0,0 +1,15 @@
+'use strict';
+
+const {entries} = Object;
+
+module.exports.SequenceExpression = (path, {maybe, traverse}) => {
+    const expressions = path.get('expressions');
+    const n = expressions.length - 1;
+    
+    for (const [index, expression] of entries(expressions)) {
+        traverse(expression);
+        maybe.write(index < n, ',');
+        maybe.write(index < n, ' ');
+    }
+};
+

package/lib/tokenize/expressions/unary-expressions.js

@@ -3,10 +3,35 @@
 module.exports.UnaryExpression = unaryExpressions;
 module.exports.UpdateExpression = unaryExpressions;
 module.exports.AwaitExpression = (path, {write, traverse}) => {
-    write('await ');
-    traverse(path.get('argument'));
+    printUnary(path, 'await', {
+        write,
+        traverse,
+    });
+};
+module.exports.YieldExpression = (path, {write, traverse}) => {
+    printUnary(path, 'yield', {
+        write,
+        traverse,
+    });
+};
+
+module.exports.ThrowStatement = (path, {write, indent, traverse}) => {
+    indent();
+    
+    printUnary(path, 'throw', {
+        write,
+        traverse,
+    });
+    
+    write(';');
+    write.newline();
 };
 
+function printUnary(path, name, {write, traverse}) {
+    write(`${name} `);
+    traverse(path.get('argument'));
+}
+
 const isWord = (a) => /delete|typeof/.test(a);
 
 function unaryExpressions(path, {traverse, write, maybe}) {
@@ -21,3 +46,4 @@ function unaryExpressions(path, {traverse, write, maybe}) {
     if (!prefix)
         write(operator);
 }
+

package/lib/tokenize/literals/index.js

@@ -5,8 +5,9 @@ const {TemplateLiteral} = require('./template-literal');
 module.exports = {
     TemplateLiteral,
     NumericLiteral(path, {write}) {
-        const {extra, raw} = path.node;
-        write(raw || extra.raw);
+        const {raw} = path.node;
+        write(raw);
+        //write(raw || extra.raw);
     },
     BooleanLiteral(path, {write}) {
         write(path.node.value);

package/lib/tokenize/tokenize.js

@@ -12,6 +12,8 @@ const {
 } = require('./mark');
 const {parseComments} = require('./comments');
 
+const isString = (a) => typeof a === 'string';
+
 const {assign} = Object;
 
 const traversers = {
@@ -69,12 +71,21 @@ module.exports.tokenize = (ast) => {
         newline,
         linebreak: writeEmptyLine,
     });
+    const print = (maybeLine) => {
+        if (isString(maybeLine))
+            return write(maybeLine);
+        
+        return traverse(maybeLine);
+    };
+    
+    const maybePrint = (a, b) => a && print(b);
     
     const maybe = {
         write: maybeWrite,
         indent: maybeIndent,
         markBefore: maybeMarkBefore,
         markAfter: maybeMarkAfter,
+        print: maybePrint,
     };
     
     assign(maybe.indent, {
@@ -82,6 +93,8 @@ module.exports.tokenize = (ast) => {
         dec: maybeIndentDec,
     });
     
+    assign(print, write);
+    
     const printer = {
         incIndent,
         decIndent,
@@ -93,6 +106,7 @@ module.exports.tokenize = (ast) => {
         traverse,
         writeEmptyLine,
         maybe,
+        print,
     };
     
     babelTraverse(ast, {

package/package.json

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