@putout/printer 2.55.0 → 2.57.0

package/ChangeLog

@@ -1,3 +1,16 @@
+2023.07.08, v2.57.0
+
+feature:
+- 0e980f4 @putout/printer: ObjectProperty: improve support of multiline comments
+
+2023.07.08, v2.56.0
+
+feature:
+- 90bd7fb @putout/printer: comments: after directive
+- ec4bebd @putout/printer: program
+- e95e634 @putout/printer: comments: directives
+- 7ecc615 @putout/printer: comments
+
 2023.07.07, v2.55.0
 
 feature:

package/README.md

@@ -41,14 +41,14 @@ And update `.putout.json`:
 
 To benefit from it.
 
-## API
+## Example
 
 ```js
 const {print} = require('@putout/printer');
 const {parse} = require('@babel/parser');
 const ast = parse('const a = (b, c) => {const d = 5; return a;}');
 
-write(ast);
+print(ast);
 // returns
 `
 const a = (b, c) => {
@@ -90,9 +90,9 @@ print(ast, {
         maxPropertiesInOneLine: 2,
     },
     visitors: {
-        AssignmentPattern(path, {write}) {
-            write('/* [hello world] */= ');
-            write('__right');
+        AssignmentPattern(path, {print}) {
+            print('/* [hello world] */= ');
+            print('__right');
         },
     },
 });
@@ -157,11 +157,17 @@ if(a>3)console.log('ok');else console.log('not ok');
 
 Options used to configure logic of output, similar to ESLint rules:
 
-- `maxElementsInOneLine` - count of `ArrayExpression` and `ArrayPattern` elements placed in one line.
+- ✅ `maxElementsInOneLine` - count of `ArrayExpression` and `ArrayPattern` elements placed in one line.
+- ✅ `maxVariablesInOneLine` - count of `VariableDeclarators` in one line.
+- ✅ `maxPropertiesInOneLine` - count of `ObjectProperties` in one line.
 
-### `write`
+## Visitors API
+
+When you want to improve support of existing visitor or extend **Printer** with a new ones, you need next base operations:
 
-Used in previous example `write` can be used for a couple purposes:
+### `print`
+
+Used in previous example `print` can be used for a couple purposes:
 
 - to write `string`;
 - to write `node` when `object` passed;
@@ -170,10 +176,10 @@ Used in previous example `write` can be used for a couple purposes:
 ```js
 print(ast, {
     visitors: {
-        AssignmentPattern(path, {write, maybe}) {
+        AssignmentPattern(path, {print, maybe}) {
             maybe.write.newline(path.parentPath.isCallExpression());
-            write('/* [hello world] */= ');
-            write('__right');
+            print('/* [hello world] */= ');
+            print('__right');
         },
     },
 });
@@ -198,7 +204,7 @@ print(ast, {
 
 ### `write`
 
-When are you going to output string you can use low-level function `write`:
+When you going to output string you can use low-level function `write`:
 
 ```js
 print(ast, {
@@ -232,7 +238,7 @@ print(ast, {
 
 ### `traverse`
 
-When are you needing to traverse node, you can use `traverse`:
+When you need to traverse node path, you can use `traverse`:
 
 ```js
 print(ast, {
@@ -251,8 +257,9 @@ This is the same as `write('__left')` but more low-level, and supports only obje
 About speed, for file `speed.js`:
 
 ```js
-const putout = require('putout');
 const {readFileSync} = require('fs');
+
+const putout = require('putout');
 const parser = require('@babel/parser');
 
 const code = readFileSync('./lib/tokenize/tokenize.js', 'utf8');

package/lib/tokenize/comments/comments.js

@@ -1,126 +1,10 @@
 'use strict';
 
-const {
-    hasTrailingComment,
-    isLast,
-} = require('../is');
+const {parseLeadingComments} = require('./parse-leading-comments');
+const {parseTrailingComments} = require('./parse-trailing-comments');
+const {parseComments} = require('./parse-comments');
 
-const {markBefore} = require('../mark');
-const {isVariableDeclarator} = require('@babel/types');
+module.exports.parseLeadingComments = parseLeadingComments;
+module.exports.parseTrailingComments = parseTrailingComments;
+module.exports.parseComments = parseComments;
 
-module.exports.parseLeadingComments = (path, {print, maybe, indent}, semantics) => {
-    if (!semantics.comments)
-        return;
-    
-    const {leadingComments} = path.node;
-    
-    if (!leadingComments?.length)
-        return;
-    
-    if (hasTrailingComment(path.getPrevSibling()))
-        return;
-    
-    const insideFn = path.parentPath.isFunction();
-    const isProperty = path.isObjectProperty() || isVariableDeclarator(path);
-    const isIndent = !path.isClassMethod() && !insideFn && !isProperty;
-    
-    for (const {type, value} of leadingComments) {
-        maybe.indent(isIndent);
-        
-        if (type === 'CommentLine') {
-            maybeInsideFn(insideFn, {
-                print,
-                indent,
-            });
-            
-            maybe.print.space(isProperty);
-            print(`//${value}`);
-            
-            maybe.print.breakline(isProperty);
-            maybe.print.newline(!isProperty);
-            continue;
-        }
-        
-        if (type === 'CommentBlock') {
-            print(`/*${value}*/`);
-            
-            if (path.isStatement() || path.isClassMethod()) {
-                print.newline();
-                markBefore(path);
-                maybe.indent(path.isClassMethod());
-            }
-            
-            continue;
-        }
-    }
-};
-
-module.exports.parseTrailingComments = (path, {write, maybe}, semantics) => {
-    if (!semantics.comments)
-        return;
-    
-    const {trailingComments} = path.node;
-    
-    if (!trailingComments?.length)
-        return;
-    
-    for (const {type, value, loc} of trailingComments) {
-        const sameLine = isSameLine(path, loc);
-        
-        if (type === 'CommentLine') {
-            maybe.write.space(sameLine);
-            maybe.indent(!sameLine);
-            
-            write(`//${value}`);
-            maybe.write.newline(!isLast(path));
-            continue;
-        }
-        
-        if (type === 'CommentBlock') {
-            maybe.write.space(sameLine);
-            write(`/*${value}*/`);
-            maybe.write.newline(!sameLine);
-        }
-    }
-};
-
-module.exports.parseComments = (path, {write}, semantics) => {
-    if (!semantics.comments)
-        return;
-    
-    const comments = path.node.comments || path.node.innerComments;
-    
-    if (!comments)
-        return;
-    
-    for (const {type, value} of comments) {
-        if (type === 'CommentLine') {
-            write.breakline();
-            write('//');
-            write(value);
-            write.newline();
-            continue;
-        }
-        
-        if (type === 'CommentBlock') {
-            write('/*');
-            write(value);
-            write('*/');
-        }
-    }
-};
-
-function isSameLine(path, loc) {
-    return path.node.loc?.start.line === loc.start.line || path.node.loc?.end.line === loc.end.line;
-}
-
-function maybeInsideFn(insideFn, {print, indent}) {
-    if (!insideFn)
-        return;
-    
-    indent.inc();
-    indent.inc();
-    print.breakline();
-    indent.dec();
-    indent.dec();
-}

package/lib/tokenize/comments/maybe-inside-fn.js

@@ -0,0 +1,13 @@
+'use strict';
+
+module.exports.maybeInsideFn = (insideFn, {print, indent}) => {
+    if (!insideFn)
+        return;
+    
+    indent.inc();
+    indent.inc();
+    print.breakline();
+    indent.dec();
+    indent.dec();
+};
+

package/lib/tokenize/comments/parse-comments.js

@@ -0,0 +1,28 @@
+'use strict';
+
+module.exports.parseComments = (path, {write}, semantics) => {
+    if (!semantics.comments)
+        return;
+    
+    const comments = path.node.comments || path.node.innerComments;
+    
+    if (!comments)
+        return;
+    
+    for (const {type, value} of comments) {
+        if (type === 'CommentLine') {
+            write.breakline();
+            write('//');
+            write(value);
+            write.newline();
+            continue;
+        }
+        
+        if (type === 'CommentBlock') {
+            write('/*');
+            write(value);
+            write('*/');
+        }
+    }
+};
+

package/lib/tokenize/comments/parse-leading-comments.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const {hasTrailingComment} = require('../is');
+const {isVariableDeclarator} = require('@babel/types');
+const {markBefore} = require('../mark');
+const {maybeInsideFn} = require('./maybe-inside-fn');
+
+module.exports.parseLeadingComments = (path, {print, maybe, indent}, semantics) => {
+    if (!semantics.comments)
+        return;
+    
+    const {leadingComments} = path.node;
+    
+    if (!leadingComments?.length)
+        return;
+    
+    if (hasTrailingComment(path.getPrevSibling()))
+        return;
+    
+    const insideFn = path.parentPath.isFunction();
+    const isProperty = path.isObjectProperty() || isVariableDeclarator(path);
+    const isIndent = !path.isClassMethod() && !insideFn && !isProperty;
+    
+    for (const {type, value} of leadingComments) {
+        maybe.indent(isIndent);
+        
+        if (type === 'CommentLine') {
+            maybeInsideFn(insideFn, {
+                print,
+                indent,
+            });
+            
+            maybe.print.space(isProperty);
+            print(`//${value}`);
+            
+            maybe.print.breakline(isProperty);
+            maybe.print.newline(!isProperty);
+            continue;
+        }
+        
+        if (type === 'CommentBlock') {
+            const looksLikeMethod = path.isClassMethod();
+            const looksLikeDirective = path.isDirective();
+            const looksLikeProp = path.isObjectProperty();
+            
+            if (looksLikeProp)
+                print.breakline();
+            
+            print(`/*${value}*/`);
+            
+            if (path.isStatement() || looksLikeDirective || looksLikeMethod || looksLikeProp) {
+                print.newline();
+                markBefore(path);
+                maybe.indent(looksLikeMethod || looksLikeProp);
+            }
+            
+            continue;
+        }
+    }
+};
+

package/lib/tokenize/comments/parse-trailing-comments.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const {isLast} = require('../is');
+
+function isSameLine(path, loc) {
+    return path.node.loc?.start.line === loc.start.line || path.node.loc?.end.line === loc.end.line;
+}
+
+module.exports.parseTrailingComments = (path, {write, maybe}, semantics) => {
+    if (!semantics.comments)
+        return;
+    
+    const {trailingComments} = path.node;
+    
+    if (!trailingComments?.length)
+        return;
+    
+    if (path.isDirective())
+        return;
+    
+    for (const {type, value, loc} of trailingComments) {
+        const sameLine = isSameLine(path, loc);
+        
+        if (type === 'CommentLine') {
+            maybe.write.space(sameLine);
+            maybe.indent(!sameLine);
+            
+            write(`//${value}`);
+            maybe.write.newline(!isLast(path));
+            continue;
+        }
+        
+        if (type === 'CommentBlock') {
+            maybe.write.space(sameLine);
+            write(`/*${value}*/`);
+            maybe.write.newline(!sameLine);
+        }
+    }
+};
+

package/lib/tokenize/literals/index.js

@@ -21,7 +21,8 @@ module.exports = {
         
         write(raw || extra?.raw || value);
     },
-    Directive(path, {print}) {
+    Directive(path, {print, maybe}) {
+        maybe.print.breakline(path.node.leadingComments?.length);
         print('__value');
     },
     DirectiveLiteral(path, {write}) {

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

@@ -15,15 +15,12 @@ const {
 const {markAfter} = require('../../mark');
 const {parseComments} = require('../../comments/comments');
 const {insideIfWithNoBody} = require('./inside-if-with-no-body');
+const {getDirectives} = require('./get-directives');
 
 const isFirstStatement = (path) => path.node.body[0];
 const isFirstDirective = (path) => path.node.directives?.[0];
 const isMethodOrArrow = (path) => isArrowFunctionExpression(path) || isObjectMethod(path);
 
-const getDirectives = (path) => !path.node.directives ? [] : path.get('directives');
-
-module.exports._getDirectives = getDirectives;
-
 module.exports.BlockStatement = {
     print(path, {indent, maybe, write, traverse}, semantics) {
         const body = path.get('body');

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

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports.getDirectives = (path) => !path.node.directives ? [] : path.get('directives');

package/lib/tokenize/statements/index.js

@@ -19,7 +19,7 @@ const {ForInStatement} = require('./for-in-statement');
 const {ExportDefaultDeclaration} = require('./export-declaration/export-default-declaration');
 const {BreakStatement} = require('./break-statement');
 const {DoWhileStatement} = require('./do-while-statement');
-const {Program} = require('./program');
+const {Program} = require('./program/program');
 
 const {
     ExportNamespaceSpecifier,

package/lib/tokenize/statements/program/program.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const {parseComments} = require('../../comments/comments');
+const {getDirectives} = require('../block-statement/get-directives');
+
+module.exports.Program = (path, {print, write, traverse, maybe}, semantics) => {
+    const {body} = path.node;
+    print('__interpreter');
+    parseComments(path, {write}, semantics);
+    
+    const directives = getDirectives(path);
+    
+    for (const directive of directives) {
+        traverse(directive);
+        maybe.print.newline(body.length);
+    }
+    
+    path
+        .get('body')
+        .forEach(print);
+    
+    if (directives.length && !body.length)
+        return;
+    
+    print.newline();
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "2.55.0",
+  "version": "2.57.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",

package/lib/tokenize/statements/program.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const {parseComments} = require('../comments/comments');
-
-module.exports.Program = (path, {print, write}, semantics) => {
-    print('__interpreter');
-    parseComments(path, {write}, semantics);
-    
-    path
-        .get('body')
-        .forEach(print);
-    
-    print.newline();
-};