@putout/printer 1.6.1 → 1.6.3

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.20, v1.6.3
+
+feature:
+- 052b966 @putout/printer: write -> print
+
+2023.03.20, v1.6.2
+
+feature:
+- eb7ba9c @putout/printer: add format
+
 2023.03.20, v1.6.1
 
 fix:

package/README.md

@@ -48,7 +48,9 @@ Here is how you can override `AssignmentPattern`:
 const ast = parse('const {a = 5} = b');
 
 print(ast, {
-    indent: '    ',
+    format: {
+        indent: '    ',
+    },
     visitors: {
         AssignmentPattern(path, {print}) {
             print(' /* [hello world] */= ');

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/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');
@@ -25,7 +27,15 @@ const traversers = {
 const GET = '__';
 const get = (path, command) => path.get(command.replace(GET, ''));
 
+function initFormat(format) {
+    return {
+        ...format,
+        indent: '    ',
+    };
+}
+
 module.exports.tokenize = (ast, overrides = {}) => {
+    const format = initFormat(overrides.format);
     const tokens = [];
     const debug = createDebug(tokens);
     const write = (value) => {
@@ -35,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();
@@ -48,7 +57,7 @@ module.exports.tokenize = (ast, overrides = {}) => {
     const indent = () => {
         tokens.push({
             type: TYPES.INDENT,
-            value: printIndent(i),
+            value: printIndent(i, format.indent),
         });
     };
     
@@ -60,14 +69,14 @@ module.exports.tokenize = (ast, overrides = {}) => {
     const linebreak = () => {
         tokens.push({
             type: TYPES.NEWLINE,
-            value: `${printIndent(i)}\n`,
+            value: `${printIndent(i, format.indent)}\n`,
         });
     };
     
     const breakline = () => {
         tokens.push({
             type: TYPES.NEWLINE,
-            value: `\n${printIndent(i)}`,
+            value: `\n${printIndent(i, format.indent)}`,
         });
     };
     
@@ -86,7 +95,6 @@ module.exports.tokenize = (ast, overrides = {}) => {
     });
     
     const maybe = {
-        write: maybeWrite,
         indent: maybeIndent,
         markBefore: maybeMarkBefore,
         markAfter: maybeMarkAfter,
@@ -102,7 +110,6 @@ module.exports.tokenize = (ast, overrides = {}) => {
         decIndent,
         indent,
         write,
-        maybeWrite,
         debug,
         maybeIndent,
         traverse,
@@ -155,12 +162,12 @@ module.exports.tokenize = (ast, overrides = {}) => {
     return tokens;
 };
 
-function printIndent(i) {
+function printIndent(i, indent) {
     let result = '';
     ++i;
     
     while (--i) {
-        result += '    ';
+        result += indent;
     }
     
     return result;
@@ -170,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.1",
+  "version": "1.6.3",
   "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",