@putout/printer 1.6.2 → 1.6.4

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.21, v1.6.4
+
+feature:
+- aa1590c @putout/printer: add support of ForStatement
+
+2023.03.20, v1.6.3
+
+feature:
+- 052b966 @putout/printer: write -> print
+
 2023.03.20, v1.6.2
 
 feature:

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

@@ -1,28 +1,25 @@
 'use strict';
 
-module.exports.MemberExpression = (path, {traverse, write}) => {
+module.exports.MemberExpression = (path, {print}) => {
     const {computed} = path.node;
-    const propertyPath = path.get('property');
     
-    traverse(path.get('object'));
+    print('__object');
     
     if (computed) {
-        write('[');
-        traverse(propertyPath);
-        write(']');
+        print('[');
+        print('__property');
+        print(']');
         
         return;
     }
     
-    write('.');
-    traverse(propertyPath);
+    print('.');
+    print('__property');
 };
 
-module.exports.OptionalMemberExpression = (path, {traverse, write}) => {
-    const propertyPath = path.get('property');
-    
-    traverse(path.get('object'));
-    
-    write('?.');
-    traverse(propertyPath);
+module.exports.OptionalMemberExpression = (path, {print}) => {
+    print('__object');
+    print('?.');
+    print('__property');
 };
+

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

@@ -2,21 +2,21 @@
 
 const {entries} = Object;
 
-module.exports.NewExpression = (path, {write, maybeWrite, traverse, indent}) => {
+module.exports.NewExpression = (path, {indent, print, maybe}) => {
     indent();
-    write('new ');
-    traverse(path.get('callee'));
+    print('new ');
+    print('__callee');
     
     const args = path.get('arguments');
-    write('(');
+    print('(');
     
     const n = args.length - 1;
     
     for (const [i, arg] of entries(args)) {
-        traverse(arg);
-        maybeWrite(i < n, ', ');
+        print(arg);
+        maybe.print(i < n, ', ');
     }
     
-    write(')');
+    print(')');
 };
 

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

@@ -9,7 +9,7 @@ const isForOf = (path) => {
     return path.parentPath?.parentPath?.isForOfStatement();
 };
 
-module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
+module.exports.ObjectExpression = (path, {print, maybe, indent}) => {
     indent.inc();
     
     const properties = path.get('properties');
@@ -17,19 +17,19 @@ module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
     const parens = isBodyOfArrow(path);
     const manyLines = !isOneLine(path);
     
-    maybe.write(parens, '(');
-    write('{');
+    maybe.print(parens, '(');
+    print('{');
     
-    maybe.write(manyLines, '\n');
+    maybe.print(manyLines, '\n');
     
     for (const property of properties) {
         if (property.isSpreadElement()) {
             maybe.indent(length > 1);
-            traverse(property);
+            print(property);
             
             if (length > 1) {
-                write(',');
-                write.newline();
+                print(',');
+                print.newline();
             }
             
             continue;
@@ -40,27 +40,27 @@ module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
         maybe.indent(manyLines);
         
         if (property.isObjectMethod()) {
-            traverse(property);
+            print(property);
             continue;
         }
         
-        maybe.write(computed, '[');
-        traverse(property.get('key'));
-        maybe.write(computed, ']');
+        maybe.print(computed, '[');
+        print(property.get('key'));
+        maybe.print(computed, ']');
         
         if (!shorthand) {
-            write(': ');
-            traverse(property.get('value'));
+            print(': ');
+            print(property.get('value'));
         }
         
-        maybe.write(manyLines, ',\n');
+        maybe.print(manyLines, ',\n');
     }
     
     indent.dec();
     
     maybe.indent(manyLines);
-    write('}');
-    maybe.write(parens, ')');
+    print('}');
+    maybe.print(parens, ')');
 };
 function isOneLine(path) {
     const isCall = path.parentPath.isCallExpression();

package/lib/tokenize/expressions/rest-element.js

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

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

@@ -2,14 +2,14 @@
 
 const {entries} = Object;
 
-module.exports.SequenceExpression = (path, {maybe, traverse}) => {
+module.exports.SequenceExpression = (path, {maybe, print}) => {
     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, ' ');
+        print(expression);
+        maybe.print(index < n, ',');
+        maybe.print(index < n, ' ');
     }
 };
 

package/lib/tokenize/expressions/spread-element.js

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

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

@@ -1,49 +1,46 @@
 'use strict';
 
-module.exports.UnaryExpression = unaryExpressions;
-module.exports.UpdateExpression = unaryExpressions;
-module.exports.AwaitExpression = (path, {write, traverse}) => {
+module.exports.UnaryExpression = unaryExpression;
+module.exports.UpdateExpression = unaryExpression;
+module.exports.AwaitExpression = (path, {print}) => {
     printUnary(path, 'await', {
-        write,
-        traverse,
+        print,
     });
 };
-module.exports.YieldExpression = (path, {write, traverse}) => {
+module.exports.YieldExpression = (path, {print}) => {
     printUnary(path, 'yield', {
-        write,
-        traverse,
+        print,
     });
 };
 
-module.exports.ThrowStatement = (path, {write, indent, traverse}) => {
+module.exports.ThrowStatement = (path, {print, indent}) => {
     indent();
     
     printUnary(path, 'throw', {
-        write,
-        traverse,
+        print,
     });
     
-    write(';');
-    write.newline();
+    print(';');
+    print.newline();
 };
 
-function printUnary(path, name, {write, traverse}) {
-    write(`${name} `);
-    traverse(path.get('argument'));
+function printUnary(path, name, {print}) {
+    print(`${name} `);
+    print('__argument');
 }
 
 const isWord = (a) => /delete|typeof/.test(a);
 
-function unaryExpressions(path, {traverse, write, maybe}) {
+function unaryExpression(path, {print, maybe}) {
     const {prefix, operator} = path.node;
     
     if (prefix)
-        write(operator);
+        print(operator);
     
-    maybe.write(isWord(operator), ' ');
-    traverse(path.get('argument'));
+    maybe.print(isWord(operator), ' ');
+    print('__argument');
     
     if (!prefix)
-        write(operator);
+        print(operator);
 }
 

package/lib/tokenize/literals/index.js

@@ -4,17 +4,16 @@ const {TemplateLiteral} = require('./template-literal');
 
 module.exports = {
     TemplateLiteral,
-    NumericLiteral(path, {write}) {
-        const {raw} = path.node;
-        write(raw);
-        //write(raw || extra.raw);
+    NumericLiteral(path, {print}) {
+        const {raw, extra} = path.node;
+        print(raw || extra.raw);
     },
-    BooleanLiteral(path, {write}) {
-        write(path.node.value);
+    BooleanLiteral(path, {print}) {
+        print(path.node.value);
     },
-    StringLiteral(path, {write}) {
+    StringLiteral(path, {print}) {
         const {value} = path.node;
-        write(`'${value}'`);
+        print(`'${value}'`);
     },
     Identifier(path, {write}) {
         write(path.node.name);

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

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports.ForStatement = (path, {print, maybe, indent}) => {
+    const {
+        test,
+        update,
+        body,
+    } = path.node;
+    
+    print('for (');
+    print('__init');
+    print(';');
+    maybe.print(test, ' ');
+    print('__test');
+    print(';');
+    maybe.print(update, ' ');
+    print('__update');
+    print(')');
+    
+    if (body.body) {
+        print(' ');
+        print('__body');
+        print.newline();
+        
+        return;
+    }
+    
+    if (!body.body) {
+        print.newline();
+        indent.inc();
+        print('__body');
+        indent.dec();
+        print.newline();
+    }
+};
+

package/lib/tokenize/statements/index.js

@@ -8,12 +8,14 @@ const {BlockStatement} = require('./block-statement');
 const {ReturnStatement} = require('./return-statement');
 const TryStatements = require('./try-statements');
 const {DebuggerStatement} = require('./debugger-statement');
+const {ForStatement} = require('./for-statement');
 
 module.exports = {
     BlockStatement,
     ExpressionStatement,
     VariableDeclaration,
     IfStatement,
+    ForStatement,
     ForOfStatement,
     ReturnStatement,
     DebuggerStatement,

package/lib/tokenize/tokenize.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const isObject = (a) => a && typeof a === 'object';
+
 const babelTraverse = require('@babel/traverse').default;
 const expressions = require('./expressions');
 const statements = require('./statements');
@@ -43,7 +45,6 @@ module.exports.tokenize = (ast, overrides = {}) => {
         });
     };
     
-    const maybeWrite = (a, b) => a && write(b);
     const maybeIndent = (a) => a && indent();
     const maybeIndentInc = (a) => a && indent.inc();
     const maybeIndentDec = (a) => a && indent.dec();
@@ -94,7 +95,6 @@ module.exports.tokenize = (ast, overrides = {}) => {
     });
     
     const maybe = {
-        write: maybeWrite,
         indent: maybeIndent,
         markBefore: maybeMarkBefore,
         markAfter: maybeMarkAfter,
@@ -110,7 +110,6 @@ module.exports.tokenize = (ast, overrides = {}) => {
         decIndent,
         indent,
         write,
-        maybeWrite,
         debug,
         maybeIndent,
         traverse,
@@ -178,11 +177,12 @@ const createPrint = (path, {traverse, write}) => (maybeLine) => {
     if (maybeLine === path)
         return null;
     
-    if (!isString(maybeLine))
-        return traverse(maybeLine);
-    
-    if (maybeLine.startsWith(GET))
+    if (isString(maybeLine) && maybeLine.startsWith(GET))
         return traverse(get(path, maybeLine));
     
+    if (isObject(maybeLine))
+        return traverse(maybeLine);
+    
     return write(maybeLine);
 };
+

package/package.json

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