@putout/printer 1.3.0 → 1.4.0

package/ChangeLog

@@ -0,0 +1,4 @@
+2023.03.17, v1.4.0
+
+feature:
+- 1faf3ff @putout/printer: add support of leadingComments

package/README.md

@@ -3,7 +3,7 @@
 [NPMIMGURL]: https://img.shields.io/npm/v/@putout/printer.svg?style=flat&longCache=true
 [NPMURL]: https://npmjs.org/package/@putout/printer "npm"
 
-**EasyPrint** prints [**Babel AST**](https://github.com/coderaiser/estree-to-babel) to readable **JavaScript**.
+**@putout/printer** prints [**Babel AST**](https://github.com/coderaiser/estree-to-babel) to readable **JavaScript**.
 
 - ☝️ Similar to **Recast**, but simpler and easier in maintenance, since it supports only **Babel**.
 - ☝️ As opinionated as **Prettier**, but has more user-friendly output and works directly with **AST**.

package/lib/tokenize/comments.js

@@ -0,0 +1,17 @@
+'use strict';
+
+module.exports.parseComments = (path, {write}) => {
+    const {leadingComments} = path.node;
+    
+    if (leadingComments)
+        parseLeadingComments(path, {write});
+};
+
+function parseLeadingComments(path, {write}) {
+    const {leadingComments} = path.node;
+    
+    for (const {value}of leadingComments) {
+        write(`//${value}`);
+        write.newline();
+    }
+}

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

@@ -1,13 +1,16 @@
 'use strict';
 
-const {hasPrevNewline} = require('../mark');
+const {
+    hasPrevNewline,
+    isMarkedParentBefore,
+} = require('../mark');
 
 const {entries} = Object;
 
 module.exports.CallExpression = (path, {traverse, indent, write, incIndent, decIndent, maybeWrite}) => {
     const isParentCall = toLong(path) && path.parentPath.isCallExpression();
     
-    if (shouldAddNewLine(path) && !hasPrevNewline(path.parentPath)) {
+    if (shouldAddNewLine(path) && !hasPrevNewline(path.parentPath) && !isMarkedParentBefore(path)) {
         write.newline();
         write.indent();
     }

package/lib/tokenize/expressions/functions.js

@@ -1,5 +1,6 @@
 'use strict';
 
+const {isMarkedPrevAfter} = require('../mark');
 const isFirst = (path) => path.node === path.parentPath.node.body[0];
 
 module.exports.ArrowFunctionExpression = (path, {write, traverse}) => {
@@ -38,7 +39,7 @@ module.exports.ObjectMethod = (path, {write, traverse}) => {
 };
 
 module.exports.FunctionDeclaration = (path, {write, traverse}) => {
-    if (!isFirst(path))
+    if (!isFirst(path) && !isMarkedPrevAfter(path))
         write('\n');
     
     write('function ');

package/lib/tokenize/expressions/index.js

@@ -13,8 +13,8 @@ const {AssignmentExpression} = require('./assignment-expression');
 const {ArrayExpression} = require('./array-expression');
 const {ArrayPattern} = require('./array-pattern');
 const {AssignmentPattern} = require('./assignment-pattern');
-const {RestElement} = require('./RestElement');
-const {SpreadElement} = require('./SpreadElement');
+const {RestElement} = require('./rest-element');
+const {SpreadElement} = require('./spread-element');
 
 module.exports = {
     ...functions,

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

@@ -11,48 +11,58 @@ const isForOf = (path) => {
     return false;
 };
 
-module.exports.ObjectExpression = (path, {traverse, write, maybeWrite, maybeIndent, incIndent, decIndent}) => {
-    incIndent();
+const isFirstMethod = (path) => path.get('properties.0').isObjectMethod();
+
+module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
+    indent.inc();
     
     const properties = path.get('properties');
     const parens = isBodyOfArrow(path);
     const isCall = path.parentPath.isCallExpression();
-    const isOneLine = isCall && properties.length < 2 || isForOf(path);
+    const {length} = properties;
+    const isOneLine = !length || isCall && length < 2 && !isFirstMethod(path) || isForOf(path);
     
-    maybeWrite(parens, '(');
+    maybe.write(parens, '(');
     write('{');
     
-    maybeWrite(!isOneLine, '\n');
+    maybe.write(!isOneLine, '\n');
     
     for (const property of properties) {
         if (property.isSpreadElement()) {
+            maybe.indent(properties.length > 1);
             traverse(property);
+            
+            if (properties.length > 1) {
+                write(',');
+                write.newline();
+            }
+            
             continue;
         }
         
         const {shorthand, computed} = property.node;
         
-        maybeIndent(!isOneLine);
+        maybe.indent(!isOneLine);
         
         if (property.isObjectMethod()) {
             traverse(property);
             continue;
         }
         
-        maybeWrite(computed, '[');
+        maybe.write(computed, '[');
         traverse(property.get('key'));
-        maybeWrite(computed, ']');
+        maybe.write(computed, ']');
         
         if (!shorthand) {
             write(': ');
             traverse(property.get('value'));
         }
         
-        maybeWrite(!isOneLine, ',\n');
+        maybe.write(!isOneLine, ',\n');
     }
     
-    decIndent();
-    maybeIndent(!isOneLine);
+    indent.dec();
+    maybe.indent(!isOneLine);
     write('}');
-    maybeWrite(parens, ')');
+    maybe.write(parens, ')');
 };

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

@@ -9,6 +9,9 @@ function unaryExpressions(path, {traverse, write}) {
     if (prefix)
         write(operator);
     
+    if (operator === 'typeof')
+        write(' ');
+    
     traverse(path.get('argument'));
     
     if (!prefix)

package/lib/tokenize/is.js

@@ -2,4 +2,3 @@
 
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 module.exports.isNext = (path) => path.getNextSibling().node;
-

package/lib/tokenize/mark.js

@@ -1,21 +1,40 @@
 'use strict';
 
-const WATER_MARK = '__putout_newline';
+const WATER_MARK_BEFORE = '__putout_newline_before';
+const WATER_MARK_AFTER = '__putout_newline_after';
 
-module.exports.mark = mark;
+module.exports.markBefore = markBefore;
+module.exports.markAfter = markAfter;
 
-function mark(path) {
-    path[WATER_MARK] = true;
+function markBefore(path) {
+    path[WATER_MARK_BEFORE] = true;
 }
 
-module.exports.isMarked = isMarked;
+function markAfter(path) {
+    path[WATER_MARK_AFTER] = true;
+}
+
+module.exports.isMarkedBefore = isMarkedBefore;
+module.exports.isMarkedAfter = isMarkedAfter;
+
+function isMarkedBefore(path) {
+    return path[WATER_MARK_BEFORE];
+}
 
-function isMarked(path) {
-    return path[WATER_MARK];
+function isMarkedAfter(path) {
+    return path[WATER_MARK_AFTER];
 }
 
 module.exports.hasPrevNewline = (path) => {
-    return isMarked(path.getPrevSibling());
+    return isMarkedAfter(path.getPrevSibling());
 };
 
-module.exports.maybeMark = (a, path) => a && mark(path);
+module.exports.maybeMarkAfter = (a, path) => a && markAfter(path);
+
+module.exports.isMarkedParentBefore = (path) => {
+    return isMarkedBefore(path.parentPath);
+};
+
+module.exports.isMarkedPrevAfter = (path) => {
+    return isMarkedAfter(path.getPrevSibling());
+};

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

@@ -1,8 +1,16 @@
 'use strict';
 
+const {
+    markBefore,
+    markAfter,
+    isMarkedPrevAfter,
+} = require('../mark');
+const {isNext} = require('../is');
+
 module.exports.ExpressionStatement = (path, {write, indent, traverse}) => {
-    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path)) {
+    if (isCoupleLinesExpression(path) && !isFirst(path) && shouldAddNewLine(path) && !isMarkedPrevAfter(path)) {
         write.linebreak();
+        markBefore(path);
     }
     
     const expressionPath = path.get('expression');
@@ -12,8 +20,10 @@ module.exports.ExpressionStatement = (path, {write, indent, traverse}) => {
     write(';');
     write.newline();
     
-    if (isStrictMode(path))
+    if (isStrictMode(path) || isCoupleLinesExpression(path) && isNext(path)) {
         write.newline();
+        markAfter(path);
+    }
 };
 
 function isCoupleLinesExpression(path) {

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

@@ -1,12 +1,13 @@
 'use strict';
 
+const {isMarkedAfter} = require('../mark');
 const isPrevNewLine = (path) => {
     const prev = path.getPrevSibling();
     
     if (!prev.node)
         return true;
     
-    return prev.__putout_newline;
+    return isMarkedAfter(prev);
 };
 
 module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
@@ -36,9 +37,4 @@ module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
         write(' ');
         traverse(bodyPath);
     }
-    
-    if (path.getNextSibling().node) {
-        //write.newline();
-        //path.__putout_newline = true;
-    }
 };

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

@@ -31,7 +31,7 @@ module.exports.VariableDeclaration = (path, {write, maybe, maybeIndent, traverse
     
     maybe.indent(is);
     maybe.write(is, '\n');
-    maybe.mark(is, path);
+    maybe.markAfter(is, path);
 };
 function isCoupleLinesExpression(path) {
     const start = path.node?.loc?.start.line;

package/lib/tokenize/tokenize.js

@@ -6,7 +6,11 @@ const statements = require('./statements');
 const literals = require('./literals');
 const {TYPES} = require('../types');
 const {createDebug} = require('./debug');
-const {maybeMark} = require('./mark');
+const {
+    maybeMarkAfter,
+    maybeMarkBefore,
+} = require('./mark');
+const {parseComments} = require('./comments');
 
 const {assign} = Object;
 
@@ -68,7 +72,8 @@ module.exports.tokenize = (ast) => {
     const maybe = {
         write: maybeWrite,
         indent: maybeIndent,
-        mark: maybeMark,
+        markBefore: maybeMarkBefore,
+        markAfter: maybeMarkAfter,
     };
     
     const printer = {
@@ -101,6 +106,7 @@ module.exports.tokenize = (ast) => {
         if (!currentTraverse)
             throw Error(`Node type '${type}' is not supported yet: '${path}'`);
         
+        parseComments(path, printer);
         currentTraverse(path, printer);
         debug(path.type);
     }

package/package.json

@@ -1,14 +1,11 @@
 {
   "name": "@putout/printer",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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",
   "homepage": "https://github.com/putoutjs/printer#readme",
   "main": "./lib/printer.js",
-  "release": false,
-  "tag": false,
-  "changelog": false,
   "exports": {
     ".": "./lib/printer.js"
   },
@@ -25,6 +22,7 @@
     "lint:fresh": "madrun lint:fresh",
     "fix:lint": "madrun fix:lint",
     "coverage": "madrun coverage",
+    "coverage:html": "madrun coverage:html",
     "report": "madrun report"
   },
   "dependencies": {