@putout/printer 1.5.1 → 1.5.3

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.03.20, v1.5.3
+
+feature:
+- 9dc85e4 @putout/printer: IfStatement: add support of alternate
+
+2023.03.19, v1.5.2
+
+feature:
+- 5354616 @putout/printer: add support of TryCatchStatement
+
 2023.03.18, v1.5.1
 
 feature:

package/lib/tokenize/mark.js

@@ -29,8 +29,6 @@ module.exports.hasPrevNewline = (path) => {
     return isMarkedAfter(path.getPrevSibling());
 };
 
-module.exports.maybeMarkAfter = (a, path) => a && markAfter(path);
-
 module.exports.isMarkedParentBefore = (path) => {
     return isMarkedBefore(path.parentPath);
 };

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

@@ -2,30 +2,52 @@
 
 const isFirstStatement = (path) => path.get('body.0')?.isStatement();
 
-module.exports.BlockStatement = (path, {write, indent, traverse}) => {
+module.exports.BlockStatement = (path, {indent, maybe, print}) => {
     const body = path.get('body');
     
     if (path.parentPath.isBlockStatement())
         indent();
     
     indent.inc();
-    write('{');
+    print('{');
     
     if (body.length > 1 || isFirstStatement(path))
-        write.newline();
+        print.newline();
     
-    body.forEach(traverse);
+    body.forEach(print);
     indent.dec();
     
-    if (body.length)
-        indent();
-    
-    write('}');
+    maybe.indent(body.length);
+    print('}');
     
     if (path.parentPath.isObjectMethod()) {
-        write(',');
+        print(',');
     }
     
-    if (!/FunctionExpression/.test(path.parentPath.type))
-        write.newline();
+    const shouldAddNewLine = !isNewLineAdded(path);
+    
+    maybe.print.newline(shouldAddNewLine);
 };
+
+function isNewLineAdded(path) {
+    const {parentPath} = path;
+    
+    if (isTry(path) || /FunctionExpression/.test(path.parentPath.type))
+        return true;
+    
+    if (parentPath.isIfStatement() && parentPath.get('consequent').node === path.node && parentPath.node.alternate)
+        return true;
+    
+    return false;
+}
+
+function isTry({parentPath}) {
+    if (parentPath.isTryStatement())
+        return true;
+    
+    if (parentPath.parentPath?.isTryStatement())
+        return true;
+    
+    return false;
+}
+

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

@@ -0,0 +1,8 @@
+'use strict';
+
+module.exports.DebuggerStatement = (path, {print, indent}) => {
+    indent();
+    print('debugger;');
+    print.newline();
+};
+

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

@@ -1,39 +1,50 @@
 'use strict';
 
-const {hasPrevNewline} = require('../mark');
+const {hasPrevNewline, markAfter} = require('../mark');
 const {isFirst} = require('../is');
 
-module.exports.IfStatement = (path, {write, indent, traverse, incIndent, decIndent}) => {
+module.exports.IfStatement = (path, {indent, print}) => {
     if (!isFirst(path) && !hasPrevNewline(path)) {
-        indent();
-        write('\n');
+        print.indent();
+        print.newline();
     }
     
     indent();
-    write('if (');
-    traverse(path.get('test'));
-    write(')');
+    print('if (');
+    print(path.get('test'));
+    print(')');
     
     const consequent = path.get('consequent');
+    const alternate = path.get('alternate');
     
     if (consequent.isBlockStatement()) {
-        write(' ');
-        traverse(consequent);
-        
-        return;
+        print(' ');
+        print(consequent);
+    } else {
+        print.newline();
+        indent.inc();
+        print(consequent);
+        indent.dec();
     }
     
-    write('\n');
-    incIndent();
-    traverse(consequent);
-    decIndent();
+    if (alternate.isBlockStatement()) {
+        print(' else ');
+        print(alternate);
+    } else if (alternate.node) {
+        print('else');
+        print.newline();
+        indent.inc();
+        print(alternate);
+        indent.dec();
+    }
     
     const next = path.getNextSibling();
     
-    if (!next.node || next.isIfStatement() || next.isExpressionStatement() || next.isReturnStatement())
+    if (!next.node || next.isExpressionStatement() || next.isReturnStatement())
         return;
     
-    indent();
-    write('\n');
+    print.indent();
+    print.newline();
+    markAfter(path);
 };
 

package/lib/tokenize/statements/index.js

@@ -6,6 +6,8 @@ const {IfStatement} = require('./if-statement');
 const {ForOfStatement} = require('./for-of-statement');
 const {BlockStatement} = require('./block-statement');
 const {ReturnStatement} = require('./return-statement');
+const TryStatements = require('./try-statements');
+const {DebuggerStatement} = require('./debugger-statement');
 
 module.exports = {
     BlockStatement,
@@ -14,9 +16,11 @@ module.exports = {
     IfStatement,
     ForOfStatement,
     ReturnStatement,
+    DebuggerStatement,
     Program(path, {traverse}) {
         path.get('body').forEach(traverse);
     },
+    ...TryStatements,
     ContinueStatement(path, {write, indent}) {
         indent();
         write('continue;\n');

package/lib/tokenize/statements/try-statements.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const {isNext} = require('../is');
+module.exports.TryStatement = (path, {print, maybe}) => {
+    const finalizer = path.get('finalizer');
+    
+    print('try ');
+    print(path.get('block'));
+    print(path.get('handler'));
+    
+    if (finalizer.node) {
+        print(' ');
+        print('finally');
+        print(' ');
+        print(finalizer);
+        print.newline();
+    }
+    
+    maybe.print.linebreak(isNext(path));
+};
+
+module.exports.CatchClause = (path, {print}) => {
+    const param = path.get('param');
+    const body = path.get('body');
+    
+    print(' ');
+    print('catch ');
+    
+    if (param.node) {
+        print('(');
+        print(param);
+        print(') ');
+    }
+    
+    print(body);
+};
+

package/lib/tokenize/statements/variable-declaration.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const {isNext, isCoupleLines} = require('../is');
+const {hasPrevNewline, markAfter} = require('../mark');
 const isNextAssign = (path) => {
     const nextPath = path.getNextSibling();
     
@@ -10,28 +11,30 @@ const isNextAssign = (path) => {
     return nextPath.get('expression').isAssignmentExpression();
 };
 
-module.exports.VariableDeclaration = (path, {write, maybe, maybeIndent, traverse}) => {
-    if (!isFirst(path) && shouldAddNewLine(path)) {
-        write.linebreak();
-    }
+module.exports.VariableDeclaration = (path, {maybe, print}) => {
+    if (!isFirst(path) && shouldAddNewLine(path) && !hasPrevNewline(path))
+        print.linebreak();
     
     const isParentBlock = /Program|BlockStatement/.test(path.parentPath.type);
     
-    maybeIndent(isParentBlock);
-    write(`${path.node.kind} `);
-    traverse(path.get('declarations.0.id'));
+    maybe.indent(isParentBlock);
+    print(`${path.node.kind} `);
+    print(path.get('declarations.0.id'));
     
     const initPath = path.get('declarations.0.init');
     
-    maybe.write(initPath.node, ' = ');
-    traverse(initPath);
-    maybe.write(isParentBlock, ';\n');
+    maybe.print(initPath.node, ' = ');
+    print(initPath);
+    maybe.print(isParentBlock, ';');
+    maybe.print.newline(isParentBlock);
     
     const is = isNext(path) && isCoupleLines(path) && !isNextAssign(path);
     
-    maybe.indent(is);
-    maybe.write(is, '\n');
-    maybe.markAfter(is, path);
+    if (is) {
+        print.indent();
+        print.newline();
+        markAfter(path);
+    }
 };
 
 function shouldAddNewLine(path) {
@@ -60,3 +63,4 @@ function shouldAddNewLine(path) {
 function isFirst(path) {
     return path.node === path.parentPath.node.body[0];
 }
+

package/lib/tokenize/tokenize.js

@@ -36,6 +36,8 @@ module.exports.tokenize = (ast) => {
     const maybeIndent = (a) => a && indent();
     const maybeIndentInc = (a) => a && indent.inc();
     const maybeIndentDec = (a) => a && indent.dec();
+    const maybeNewline = (a) => a && newline();
+    const maybeLinebreak = (a) => a && linebreak();
     
     let i = 0;
     const incIndent = () => ++i;
@@ -52,7 +54,7 @@ module.exports.tokenize = (ast) => {
         dec: decIndent,
     });
     
-    const writeEmptyLine = () => {
+    const linebreak = () => {
         tokens.push({
             type: TYPES.NEWLINE,
             value: `\n${printIndent(i)}`,
@@ -69,7 +71,7 @@ module.exports.tokenize = (ast) => {
     assign(write, {
         indent,
         newline,
-        linebreak: writeEmptyLine,
+        linebreak,
     });
     const print = (maybeLine) => {
         if (isString(maybeLine))
@@ -94,6 +96,10 @@ module.exports.tokenize = (ast) => {
     });
     
     assign(print, write);
+    assign(maybePrint, {
+        newline: maybeNewline,
+        linebreak: maybeLinebreak,
+    });
     
     const printer = {
         incIndent,
@@ -104,7 +110,6 @@ module.exports.tokenize = (ast) => {
         debug,
         maybeIndent,
         traverse,
-        writeEmptyLine,
         maybe,
         print,
     };

package/package.json

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