@putout/printer 1.5.4 → 1.6.1

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.20, v1.6.1
+
+fix:
+- 7e8d47c @putout/printer: visitors
+
+2023.03.20, v1.6.0
+
+feature:
+- f0ef762 @putout/printer: add ability to override syntax visitors
+
 2023.03.20, v1.5.4
 
 feature:

package/README.md

@@ -32,6 +32,35 @@ const a = (b, c) => {
 `;
 ```
 
+## Overrides
+
+When you need to extend syntax of `@putout/printer` just pass a function which receives:
+
+- `path`, Babel Path
+- `print`, a function to output result of printing into token array;
+
+When `path` contains to dashes `__` and name, it is the same as: `print(path.get('right'))`, and this is
+actually `traverse(path.get('right'))` shortened to simplify read and process.
+
+Here is how you can override `AssignmentPattern`:
+
+```js
+const ast = parse('const {a = 5} = b');
+
+print(ast, {
+    indent: '    ',
+    visitors: {
+        AssignmentPattern(path, {print}) {
+            print(' /* [hello world] */= ');
+            print('__right');
+        },
+    },
+});
+
+// returns
+'const {a /* [hello world] */= 5} = b;\n';
+```
+
 ## License
 
 MIT

package/lib/printer.js

@@ -3,7 +3,7 @@
 const {tokenize} = require('./tokenize/tokenize');
 const {printTokens} = require('./print-tokens');
 
-module.exports.print = (ast) => {
-    const tokens = tokenize(ast);
+module.exports.print = (ast, overrides) => {
+    const tokens = tokenize(ast, overrides);
     return printTokens(tokens);
 };

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

@@ -4,31 +4,31 @@ const {isObjectProperty} = require('@babel/types');
 const {entries} = Object;
 const isForOf = ({parentPath}) => parentPath.isForOfStatement();
 
-module.exports.ArrayExpression = (path, {write, maybe, traverse}) => {
+module.exports.ArrayExpression = (path, {print, maybe}) => {
     const elements = path.get('elements');
     const elementIsObject = isElementObject(path);
     
-    write('[');
+    print('[');
     maybe.indent.inc(!elementIsObject);
     
     const isNewLine = !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path);
     const n = elements.length - 1;
     
-    maybe.write(isNewLine && elements.length, '\n');
+    maybe.print(isNewLine && elements.length, '\n');
     
     for (const [index, element] of entries(elements)) {
         maybe.indent(isNewLine);
         
-        traverse(element);
+        print(element);
         
-        maybe.write(isNewLine, ',\n');
-        maybe.write(!isNewLine && index < n, ', ');
+        maybe.print(isNewLine, ',\n');
+        maybe.print(!isNewLine && index < n, ', ');
     }
     
     maybe.indent.dec(!elementIsObject);
     maybe.indent(elements.length && isNewLine);
     
-    write(']');
+    print(']');
 };
 
 function isNumbers(elements) {

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

@@ -3,8 +3,8 @@
 const {entries} = Object;
 const isForOf = ({parentPath}) => parentPath.parentPath.parentPath.isForOfStatement();
 
-module.exports.ArrayPattern = (path, {write, indent, maybe, traverse}) => {
-    write('[');
+module.exports.ArrayPattern = (path, {indent, maybe, print}) => {
+    print('[');
     
     const elements = path.get('elements');
     
@@ -13,21 +13,21 @@ module.exports.ArrayPattern = (path, {write, indent, maybe, traverse}) => {
     const isNewLine = !isForOf(path) && elements.length > 2;
     const n = elements.length - 1;
     
-    maybe.write(isNewLine && elements.length, '\n');
+    maybe.print(isNewLine && elements.length, '\n');
     
     for (const [index, element] of entries(elements)) {
         maybe.indent(isNewLine);
         
-        traverse(element);
+        print(element);
         
-        maybe.write(isNewLine, ',\n');
-        maybe.write(!isNewLine && index < n, ', ');
+        maybe.print(isNewLine, ',\n');
+        maybe.print(!isNewLine && index < n, ', ');
     }
     
     indent.dec();
     
     maybe.indent(elements.length && isNewLine);
     
-    write(']');
+    print(']');
 };
 

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

@@ -1,12 +1,18 @@
 'use strict';
 
-module.exports.AssignmentExpression = (path, {traverse, write}) => {
+module.exports.AssignmentExpression = (path, {print}) => {
+    const {operator} = path.node;
+    const left = path.get('left');
+    const right = path.get('right');
+    
     if (shouldAddNewLine(path))
-        write('\n');
+        print('\n');
     
-    traverse(path.get('left'));
-    write(` ${path.node.operator} `);
-    traverse(path.get('right'));
+    print(left);
+    print(' ');
+    print(operator);
+    print(' ');
+    print(right);
 };
 
 function shouldAddNewLine({parentPath}) {

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

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

package/lib/tokenize/expressions/functions.js

@@ -3,7 +3,7 @@
 const {isMarkedPrevAfter} = require('../mark');
 const isFirst = (path) => path.node === path.parentPath.node.body[0];
 
-module.exports.FunctionExpression = (path, {write, maybe, traverse}) => {
+module.exports.FunctionExpression = (path, {print, maybe}) => {
     const {node} = path;
     
     const {
@@ -11,105 +11,105 @@ module.exports.FunctionExpression = (path, {write, maybe, traverse}) => {
         async,
     } = node;
     
-    maybe.write(async, 'async ');
-    write('function');
-    maybe.write(generator, '*');
-    write(' (');
+    maybe.print(async, 'async ');
+    print('function');
+    maybe.print(generator, '*');
+    print(' (');
     
     const params = path.get('params');
     const n = params.length;
     
     for (let i = 0; i < n; i++) {
-        traverse(params[i]);
+        print(params[i]);
         
         if (i < n - 1)
-            write(', ');
+            print(', ');
     }
     
-    write(') ');
-    traverse(path.get('body'));
+    print(') ');
+    print('__body');
 };
 
 module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
-function ArrowFunctionExpression(path, {write, maybe, traverse}) {
+function ArrowFunctionExpression(path, {print, maybe}) {
     const {async} = path.node;
-    maybe.write(async, 'async ');
+    maybe.print(async, 'async ');
     
-    write('(');
+    print('(');
     
     const params = path.get('params');
     const n = params.length;
     
     for (let i = 0; i < n; i++) {
-        traverse(params[i]);
+        print(params[i]);
         
         if (i < n - 1)
-            write(', ');
+            print(', ');
     }
     
-    write(') => ');
-    traverse(path.get('body'));
+    print(') => ');
+    print('__body');
 }
 
-module.exports.ObjectMethod = (path, {write, traverse}) => {
-    traverse(path.get('key'));
-    write('(');
+module.exports.ObjectMethod = (path, {print}) => {
+    print(path.get('key'));
+    print('(');
     
     const params = path.get('params');
     const n = params.length - 1;
     
     for (let i = 0; i <= n; i++) {
-        traverse(params[i]);
+        print(params[i]);
         
         if (i < n)
-            write(', ');
+            print(', ');
     }
     
-    write(') ');
-    traverse(path.get('body'));
+    print(') ');
+    print(path.get('body'));
 };
 
-module.exports.FunctionDeclaration = (path, {write, maybe, traverse}) => {
+module.exports.FunctionDeclaration = (path, {print, maybe}) => {
     const {async} = path.node;
     
     if (!isFirst(path) && !isMarkedPrevAfter(path))
-        write('\n');
+        print('\n');
     
-    maybe.write(async, 'async ');
+    maybe.print(async, 'async ');
     
-    write('function ');
-    traverse(path.get('id'));
-    write('(');
+    print('function ');
+    print(path.get('id'));
+    print('(');
     
     const params = path.get('params');
     const n = params.length - 1;
     
     for (let i = 0; i <= n; i++) {
-        traverse(params[i]);
+        print(params[i]);
         
         if (i < n)
-            write(', ');
+            print(', ');
     }
     
-    write(') ');
-    traverse(path.get('body'));
+    print(') ');
+    print(path.get('body'));
 };
 
-module.exports.ClassMethod = (path, {write, traverse}) => {
-    traverse(path.get('key'));
-    write('(');
+module.exports.ClassMethod = (path, {print}) => {
+    print(path.get('key'));
+    print('(');
     
     const params = path.get('params');
     const n = params.length;
     
     for (let i = 0; i < n; i++) {
-        traverse(params[i]);
+        print(params[i]);
         
         if (i < n - 1)
-            write(', ');
+            print(', ');
     }
     
-    write(') ');
-    traverse(path.get('body'));
+    print(') ');
+    print(path.get('body'));
 };
 

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

@@ -14,7 +14,10 @@ module.exports.BlockStatement = (path, {indent, maybe, print}) => {
     if (body.length > 1 || isFirstStatement(path))
         print.newline();
     
-    body.forEach(print);
+    for (const element of body) {
+        print(element);
+    }
+    
     indent.dec();
     
     maybe.indent(body.length);

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

@@ -3,31 +3,32 @@
 const {isMarkedPrevAfter} = require('../mark');
 const {isFirst} = require('../is');
 
-module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
+module.exports.ForOfStatement = (path, {indent, print}) => {
     if (!isFirst(path) && !isMarkedPrevAfter(path)) {
-        write.indent();
-        write.newline();
+        print.indent();
+        print.newline();
     }
     
     indent();
-    write('for (');
-    traverse(path.get('left'));
-    write(' of ');
-    traverse(path.get('right'));
-    write(')');
+    print('for (');
+    print('__left');
+    print(' of ');
+    print('__right');
+    print(')');
     
     const bodyPath = path.get('body');
     
     if (bodyPath.isExpressionStatement()) {
         indent.inc();
-        write.newline();
-        traverse(bodyPath);
+        print.newline();
+        print(bodyPath);
         indent.dec();
-        write.newline();
+        print.newline();
     }
     
     if (bodyPath.isBlockStatement()) {
-        write(' ');
-        traverse(bodyPath);
+        print(' ');
+        print(bodyPath);
     }
 };
+

package/lib/tokenize/tokenize.js

@@ -22,7 +22,10 @@ const traversers = {
     ...literals,
 };
 
-module.exports.tokenize = (ast) => {
+const GET = '__';
+const get = (path, command) => path.get(command.replace(GET, ''));
+
+module.exports.tokenize = (ast, overrides = {}) => {
     const tokens = [];
     const debug = createDebug(tokens);
     const write = (value) => {
@@ -81,21 +84,12 @@ module.exports.tokenize = (ast) => {
         linebreak,
         breakline,
     });
-    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, {
@@ -103,12 +97,6 @@ module.exports.tokenize = (ast) => {
         dec: maybeIndentDec,
     });
     
-    assign(print, write);
-    assign(maybePrint, {
-        newline: maybeNewline,
-        breakline: maybeBreakline,
-    });
-    
     const printer = {
         incIndent,
         decIndent,
@@ -119,7 +107,11 @@ module.exports.tokenize = (ast) => {
         maybeIndent,
         traverse,
         maybe,
-        print,
+    };
+    
+    const currentTraversers = {
+        ...traversers,
+        ...overrides.visitors,
     };
     
     babelTraverse(ast, {
@@ -131,11 +123,27 @@ module.exports.tokenize = (ast) => {
     
     function traverse(path) {
         const {type} = path;
-        const currentTraverse = traversers[type];
+        const currentTraverse = currentTraversers[type];
         
         if (!path.node)
             return;
         
+        const print = createPrint(path, {write, traverse});
+        assign(print, write);
+        assign(printer, {
+            print,
+        });
+        
+        const maybePrint = (a, b) => a && print(b);
+        
+        assign(maybePrint, {
+            newline: maybeNewline,
+            breakline: maybeBreakline,
+        });
+        assign(printer.maybe, {
+            print: maybePrint,
+        });
+        
         if (!currentTraverse)
             throw Error(`Node type '${type}' is not supported yet: '${path}'`);
         
@@ -158,3 +166,15 @@ function printIndent(i) {
     return result;
 }
 
+const createPrint = (path, {traverse, write}) => (maybeLine) => {
+    if (maybeLine === path)
+        return null;
+    
+    if (!isString(maybeLine))
+        return traverse(maybeLine);
+    
+    if (maybeLine.startsWith(GET))
+        return traverse(get(path, maybeLine));
+    
+    return write(maybeLine);
+};

package/package.json

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