@putout/printer 1.1.0 → 1.1.1

package/lib/print-tokens/cook.js

@@ -0,0 +1,29 @@
+'use strict';
+
+module.exports.cook = (tokens) => {
+    const cookedTokens = [];
+    
+    for (const [i, {
+        value,
+    }] of tokens.entries()) {
+        /*
+        if (type !== TYPES.TOKEN)
+            console.log(type);
+        
+        if (type === TYPES.NEWLINE && next?.type === TYPES.LINEBREAK) {
+            console.log('[skipped]');
+            continue;
+        }
+        
+        if (type === TYPES.LINEBREAK && next?.type === TYPES.LINEBREAK) {
+            console.log('[skipped]');
+            continue;
+        }
+         */
+        
+        cookedTokens.push(value);
+    }
+    
+    return cookedTokens;
+};
+

package/lib/print-tokens/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const {cook} = require('./cook');
+
+module.exports.printTokens = (tokens) => {
+    const cookedTokens = cook(tokens);
+    return cookedTokens.join('');
+};

package/lib/printer.js

@@ -1,86 +1,9 @@
 'use strict';
 
-const babelTraverse = require('@babel/traverse').default;
-const expressions = require('./expressions');
-const statements = require('./statements');
-const literals = require('./literals');
-const toSnakeCase = require('just-snake-case');
+const {tokenize} = require('./tokenize/tokenize');
+const {printTokens} = require('./print-tokens');
 
-const traversers = {
-    ...expressions,
-    ...statements,
-    ...literals,
+module.exports.print = (ast) => {
+    const tokens = tokenize(ast);
+    return printTokens(tokens);
 };
-
-const {DEBUG} = process.env;
-
-module.exports.print = function print(ast) {
-    const tokens = [];
-    const write = (a) => {
-        tokens.push(a);
-    };
-    
-    const indent = () => {
-        write(printIndent(i));
-    };
-    
-    const debug = (a) => maybeWrite(DEBUG, `/*__${toSnakeCase(a)}*/`);
-    const maybeWrite = (a, b) => a && write(b);
-    const maybeIndent = (a) => a && indent();
-    
-    let i = 0;
-    const incIndent = () => ++i;
-    const decIndent = () => --i;
-    
-    const writeEmptyLine = () => {
-        write('\n');
-        indent();
-    };
-    
-    const printer = {
-        incIndent,
-        decIndent,
-        indent,
-        write,
-        maybeWrite,
-        debug,
-        maybeIndent,
-        traverse,
-        writeEmptyLine,
-    };
-    
-    babelTraverse(ast, {
-        Program(path) {
-            traverse(path);
-            path.stop();
-        },
-    });
-    
-    function traverse(path) {
-        const {type} = path;
-        const currentTraverse = traversers[type];
-        
-        if (!path.node)
-            return;
-        
-        if (!currentTraverse)
-            throw Error(`Node type '${type}' is not supported yet: '${path}'`);
-        
-        currentTraverse(path, printer);
-        debug(path.type);
-    }
-    
-    return tokens.join('');
-};
-
-function printIndent(i) {
-    let result = '';
-    ++i;
-    
-    while (--i) {
-        result += '    ';
-    }
-    
-    return result;
-}
-

package/lib/tokenize/debug.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const {TYPES} = require('../types');
+const toSnakeCase = require('just-snake-case');
+
+const {DEBUG} = process.env;
+
+module.exports.createDebug = (tokens) => (a) => {
+    if (!DEBUG)
+        return;
+    
+    tokens.push({
+        type: TYPES.DEBUG,
+        value: `/*__${toSnakeCase(a)}*/`,
+    });
+};
+

package/lib/tokenize/expressions/arrays.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const {entries} = Object;
+const isForOf = ({parentPath}) => parentPath.parentPath.parentPath.isForOfStatement();
+
+module.exports.ArrayPattern = (path, {write, indent, maybe, traverse}) => {
+    write('[');
+    
+    const elements = path.get('elements');
+    
+    indent.inc();
+    const isNewLine = !isForOf(path) && elements.length > 2;
+    const n = elements.length - 1;
+    
+    maybe.write(isNewLine && elements.length, '\n');
+    
+    for (const [index, element] of entries(elements)) {
+        maybe.indent(isNewLine);
+        
+        traverse(element);
+        
+        maybe.write(isNewLine, ',\n');
+        maybe.write(!isNewLine && index < n, ', ');
+    }
+    
+    indent.dec();
+    
+    maybe.indent(elements.length && isNewLine);
+    
+    write(']');
+};
+
+module.exports.ArrayExpression = (path, {write, indent, maybe, traverse}) => {
+    write('[');
+    
+    const elements = path.get('elements');
+    
+    indent.inc();
+    const isNewLine = !isNumbers(elements);
+    const n = elements.length - 1;
+    
+    maybe.write(isNewLine && elements.length, '\n');
+    
+    for (const [index, element] of entries(elements)) {
+        maybe.indent(isNewLine);
+        
+        traverse(element);
+        
+        maybe.write(isNewLine, ',\n');
+        maybe.write(!isNewLine && index < n, ', ');
+    }
+    
+    indent.dec();
+    
+    maybe.indent(elements.length && isNewLine);
+    
+    write(']');
+};
+
+function isNumbers(elements) {
+    for (const element of elements) {
+        if (element.isNumericLiteral())
+            return true;
+    }
+    
+    return false;
+}
+

package/lib/{expressions → tokenize/expressions}/call-expression.js

@@ -2,11 +2,13 @@
 
 const {entries} = Object;
 
-module.exports.CallExpression = (path, {traverse, indent, write, writeEmptyLine, incIndent, decIndent, maybeWrite}) => {
+module.exports.CallExpression = (path, {traverse, indent, write, incIndent, decIndent, maybeWrite}) => {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
-    if (shouldAddNewLine(path))
-        writeEmptyLine();
+    if (shouldAddNewLine(path)) {
+        write.newline();
+        write.indent();
+    }
     
     traverse(path.get('callee'));
     write('(');
@@ -19,7 +21,7 @@ module.exports.CallExpression = (path, {traverse, indent, write, writeEmptyLine,
     
     for (const [i, arg] of entries(args)) {
         if (isParentCall) {
-            write('\n');
+            write.newline();
             indent();
         }
         
@@ -35,7 +37,8 @@ module.exports.CallExpression = (path, {traverse, indent, write, writeEmptyLine,
     
     if (isParentCall) {
         decIndent();
-        writeEmptyLine();
+        write.newline();
+        write.indent();
     }
     
     write(')');

package/lib/{statements → tokenize/statements}/block-statement.js

@@ -2,17 +2,17 @@
 
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
-module.exports.BlockStatement = (path, {write, indent, incIndent, decIndent, traverse}) => {
+module.exports.BlockStatement = (path, {write, indent, traverse}) => {
     const body = path.get('body');
     
-    incIndent();
+    indent.inc();
     write('{');
     
     if (body.length > 1 || isFirstStatement(path))
-        write('\n');
+        write.newline();
     
     body.forEach(traverse);
-    decIndent();
+    indent.dec();
     
     if (body.length)
         indent();
@@ -24,6 +24,5 @@ module.exports.BlockStatement = (path, {write, indent, incIndent, decIndent, tra
     }
     
     if (!/FunctionExpression/.test(path.parentPath.type))
-        write('\n');
+        write.newline();
 };
-

package/lib/{statements → tokenize/statements}/expression-statement.js

@@ -2,18 +2,18 @@
 
 module.exports.ExpressionStatement = (path, {write, indent, traverse}) => {
     if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path)) {
-        write('\n');
-        indent();
+        write.linebreak();
     }
     
     const expressionPath = path.get('expression');
     
     indent();
     traverse(expressionPath);
-    write(';\n');
+    write(';');
+    write.newline();
     
     if (isStrictMode(path))
-        write('\n');
+        write.newline();
 };
 
 function isCoupleLinesExpression(path) {

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

@@ -0,0 +1,44 @@
+'use strict';
+
+const isPrevNewLine = (path) => {
+    const prev = path.getPrevSibling();
+    
+    if (!prev.node)
+        return true;
+    
+    return prev.__putout_newline;
+};
+
+module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
+    if (!isPrevNewLine(path)) {
+        write.indent();
+        write.newline();
+    }
+    
+    indent();
+    write('for (');
+    traverse(path.get('left'));
+    write(' of ');
+    traverse(path.get('right'));
+    write(')');
+    
+    const bodyPath = path.get('body');
+    
+    if (bodyPath.isExpressionStatement()) {
+        indent.inc();
+        write.newline();
+        traverse(bodyPath);
+        indent.dec();
+        write.newline();
+    }
+    
+    if (bodyPath.isBlockStatement()) {
+        write(' ');
+        traverse(bodyPath);
+    }
+    
+    if (path.getNextSibling().node) {
+        //write.newline();
+        //path.__putout_newline = true;
+    }
+};

package/lib/{statements → tokenize/statements}/index.js

@@ -20,14 +20,14 @@ module.exports = {
         write('continue;\n');
     },
     ReturnStatement(path, {indent, write, traverse}) {
-        indent();
-        
         if (path?.parentPath?.node?.body?.length > 2) {
-            write('\n');
-            indent();
+            write.indent();
+            write.newline();
         }
         
+        indent();
         write('return');
+        
         const argPath = path.get('argument');
         
         if (argPath.node) {
@@ -36,7 +36,7 @@ module.exports = {
         }
         
         write(';');
-        write('\n');
+        write.newline();
     },
 };
 

package/lib/{statements → tokenize/statements}/variable-declaration.js

@@ -9,9 +9,9 @@ const isNextAssign = (path) => {
     return nextPath.get('expression').isAssignmentExpression();
 };
 
-module.exports.VariableDeclaration = (path, {write, maybeWrite, maybeIndent, traverse}) => {
+module.exports.VariableDeclaration = (path, {write, maybe, maybeIndent, traverse}) => {
     if (!isFirst(path) && shouldAddNewLine(path)) {
-        write('\n');
+        write.linebreak();
     }
     
     const isParentBlock = /Program|BlockStatement/.test(path.parentPath.type);
@@ -22,14 +22,14 @@ module.exports.VariableDeclaration = (path, {write, maybeWrite, maybeIndent, tra
     
     const initPath = path.get('declarations.0.init');
     
-    maybeWrite(initPath.node, ' = ');
+    maybe.write(initPath.node, ' = ');
     traverse(initPath);
-    maybeWrite(isParentBlock, ';\n');
+    maybe.write(isParentBlock, ';\n');
     
     const is = isCoupleLinesExpression(path) && !isNextAssign(path);
     
-    maybeIndent(is);
-    maybeWrite(is, '\n');
+    maybe.indent(is);
+    maybe.write(is, '\n');
 };
 function isCoupleLinesExpression(path) {
     const start = path.node?.loc?.start.line;

package/lib/tokenize/tokenize.js

@@ -0,0 +1,119 @@
+'use strict';
+
+const babelTraverse = require('@babel/traverse').default;
+const expressions = require('./expressions');
+const statements = require('./statements');
+const literals = require('./literals');
+const {TYPES} = require('../types');
+const {createDebug} = require('./debug');
+
+const {assign} = Object;
+
+const traversers = {
+    ...expressions,
+    ...statements,
+    ...literals,
+};
+
+module.exports.tokenize = (ast) => {
+    const tokens = [];
+    const debug = createDebug(tokens);
+    const write = (value) => {
+        tokens.push({
+            type: TYPES.TOKEN,
+            value,
+        });
+    };
+    
+    const maybeWrite = (a, b) => a && write(b);
+    const maybeIndent = (a) => a && indent();
+    
+    let i = 0;
+    const incIndent = () => ++i;
+    const decIndent = () => --i;
+    
+    const indent = () => {
+        tokens.push({
+            type: TYPES.INDENT,
+            value: printIndent(i),
+        });
+    };
+    
+    assign(indent, {
+        inc: incIndent,
+        dec: decIndent,
+    });
+    
+    const writeEmptyLine = () => {
+        tokens.push({
+            type: TYPES.NEWLINE,
+            value: `\n${printIndent(i)}`,
+        });
+    };
+    
+    const newline = () => {
+        tokens.push({
+            type: TYPES.NEWLINE,
+            value: '\n',
+        });
+    };
+    
+    assign(write, {
+        indent,
+        newline,
+        linebreak: writeEmptyLine,
+    });
+    
+    const maybe = {
+        write: maybeWrite,
+        indent: maybeIndent,
+    };
+    
+    const printer = {
+        incIndent,
+        decIndent,
+        indent,
+        write,
+        maybeWrite,
+        debug,
+        maybeIndent,
+        traverse,
+        writeEmptyLine,
+        maybe,
+    };
+    
+    babelTraverse(ast, {
+        Program(path) {
+            traverse(path);
+            path.stop();
+        },
+    });
+    
+    function traverse(path) {
+        const {type} = path;
+        const currentTraverse = traversers[type];
+        
+        if (!path.node)
+            return;
+        
+        if (!currentTraverse)
+            throw Error(`Node type '${type}' is not supported yet: '${path}'`);
+        
+        currentTraverse(path, printer);
+        debug(path.type);
+    }
+    
+    return tokens;
+};
+
+function printIndent(i) {
+    let result = '';
+    ++i;
+    
+    while (--i) {
+        result += '    ';
+    }
+    
+    return result;
+}
+

package/lib/types.js

@@ -0,0 +1,10 @@
+'use strict';
+
+module.exports.TYPES = {
+    TOKEN: 'Token',
+    NEWLINE: 'Newline',
+    LINEBREAK: 'Linebreak',
+    INDENT: 'Indent',
+    DEBUG: 'Debug',
+};
+

package/package.json

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

package/lib/expressions/arrays.js

@@ -1,51 +0,0 @@
-'use strict';
-
-const {entries} = Object;
-
-module.exports.ArrayPattern = (path, {write, traverse}) => {
-    write('[');
-    
-    for (const element of path.get('elements')) {
-        traverse(element);
-    }
-    
-    write(']');
-};
-
-module.exports.ArrayExpression = (path, {write, maybeWrite, indent, maybeIndent, incIndent, decIndent, traverse}) => {
-    write('[');
-    
-    const elements = path.get('elements');
-    
-    incIndent();
-    const isNewLine = !isNumbers(elements);
-    const n = elements.length - 1;
-    
-    maybeWrite(isNewLine && elements.length, '\n');
-    
-    for (const [index, element] of entries(elements)) {
-        maybeIndent(isNewLine);
-        
-        traverse(element);
-        
-        maybeWrite(isNewLine, ',\n');
-        maybeWrite(!isNewLine && index < n, ', ');
-    }
-    
-    decIndent();
-    
-    if (elements.length)
-        indent();
-    
-    write(']');
-};
-
-function isNumbers(elements) {
-    for (const element of elements) {
-        if (element.isNumericLiteral())
-            return true;
-    }
-    
-    return false;
-}
-

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

@@ -1,31 +0,0 @@
-'use strict';
-
-module.exports.ForOfStatement = (path, {write, indent, incIndent, traverse}) => {
-    if (!isFirst(path)) {
-        indent();
-        write('\n');
-    }
-    
-    indent();
-    write('for (');
-    traverse(path.get('left'));
-    write(' of ');
-    traverse(path.get('right'));
-    write(')');
-    
-    const bodyPath = path.get('body');
-    
-    if (bodyPath.isExpressionStatement()) {
-        incIndent();
-        write('\n');
-        traverse(bodyPath);
-        
-        return;
-    }
-    
-    write(' ');
-    traverse(bodyPath);
-};
-function isFirst(path) {
-    return path.node === path.parentPath.node.body[0];
-}