@putout/printer 2.56.0 → 2.58.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.07.08, v2.58.0
+
+feature:
+- 3af1546 @putout/printer: Function: innerComments
+
+2023.07.08, v2.57.0
+
+feature:
+- 0e980f4 @putout/printer: ObjectProperty: improve support of multiline comments
+
 2023.07.08, v2.56.0
 
 feature:

package/lib/tokenize/comment/comment.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const {parseLeadingComments} = require('./parse-leading-comments');
+const {parseTrailingComments} = require('./parse-trailing-comments');
+const {parseComments} = require('./parse-comments');
+
+module.exports.parseLeadingComments = parseLeadingComments;
+module.exports.parseTrailingComments = parseTrailingComments;
+module.exports.parseComments = parseComments;

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

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

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

@@ -0,0 +1,27 @@
+'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/comment/parse-leading-comments.js

@@ -0,0 +1,60 @@
+'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/comment/parse-trailing-comments.js

@@ -0,0 +1,39 @@
+'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/expressions/functions/arrow-function-expression.js

@@ -10,15 +10,19 @@ module.exports.ArrowFunctionExpression = {
     before(path, {write}) {
         write('(');
     },
-    print(path, {print, maybe, write, traverse}) {
+    print(path, printer, semantics) {
+        const {
+            print,
+            maybe,
+            write,
+            traverse,
+        } = printer;
+        
         const {async} = path.node;
         
         maybe.print(async, 'async ');
         
-        printParams(path, {
-            print,
-            traverse,
-        });
+        printParams(path, printer, semantics);
         
         const returnType = path.get('returnType');
         

package/lib/tokenize/expressions/functions/class-method.js

@@ -4,7 +4,9 @@ const {isNext} = require('../../is');
 const {printParams} = require('./params');
 
 const ClassMethod = {
-    print(path, {print, maybe, traverse}) {
+    print(path, printer, semantics) {
+        const {print, maybe} = printer;
+        
         const {kind, computed} = path.node;
         const isConstructor = kind === 'constructor';
         const isMethod = kind === 'method';
@@ -24,10 +26,7 @@ const ClassMethod = {
             print('__key');
         }
         
-        printParams(path, {
-            print,
-            traverse,
-        });
+        printParams(path, printer, semantics);
         
         print.space();
         print('__body');

package/lib/tokenize/expressions/functions/function-declaration.js

@@ -7,7 +7,9 @@ const {isNext, isNextParent} = require('../../is');
 const {printParams} = require('./params');
 
 module.exports.FunctionDeclaration = {
-    print(path, {print, maybe, traverse}) {
+    print(path, printer, semantics) {
+        const {print, maybe} = printer;
+        
         const {async, generator} = path.node;
         
         maybe.print(async, 'async ');
@@ -18,10 +20,7 @@ module.exports.FunctionDeclaration = {
         print('__id');
         print('__typeParameters');
         
-        printParams(path, {
-            print,
-            traverse,
-        });
+        printParams(path, printer, semantics);
         
         print.space();
         

package/lib/tokenize/expressions/functions/function-expression.js

@@ -3,9 +3,15 @@
 const {exists} = require('../../is');
 const {printParams} = require('./params');
 
-module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
-    const {node} = path;
+module.exports.FunctionExpression = (path, printer, semantics) => {
+    const {
+        print,
+        maybe,
+        write,
+        traverse,
+    } = printer;
     
+    const {node} = path;
     const {generator, async} = node;
     
     maybe.write(async, 'async ');
@@ -19,10 +25,7 @@ module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
         traverse(id);
     }
     
-    printParams(path, {
-        print,
-        traverse,
-    });
+    printParams(path, printer, semantics);
     
     print.space();
     print('__body');

package/lib/tokenize/expressions/functions/object-method.js

@@ -10,7 +10,9 @@ module.exports.ObjectMethod = {
     before(path, {write}) {
         write('async ');
     },
-    print(path, {print, maybe, traverse}) {
+    print(path, printer, semantics) {
+        const {print, maybe} = printer;
+        
         const {
             kind,
             generator,
@@ -26,10 +28,7 @@ module.exports.ObjectMethod = {
         print('__key');
         maybe.print(computed, ']');
         
-        printParams(path, {
-            print,
-            traverse,
-        });
+        printParams(path, printer, semantics);
         
         print.space();
         print('__body');

package/lib/tokenize/expressions/functions/params.js

@@ -1,10 +1,16 @@
 'use strict';
 
-module.exports.printParams = (path, {print, traverse}) => {
+const {parseComments} = require('../../comment/comment');
+
+module.exports.printParams = (path, printer, semantics) => {
+    const {print, traverse} = printer;
+    
     printBraceOpen(path, {
         print,
     });
     
+    parseComments(path, printer, semantics);
+    
     const params = path.get('params');
     const n = params.length;
     

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

@@ -11,7 +11,7 @@ const {
     exists,
 } = require('../../is');
 
-const {parseComments} = require('../../comments/comments');
+const {parseComments} = require('../../comment/comment');
 const {isSpreadElement} = require('@babel/types');
 
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;

package/lib/tokenize/jsx/index.js

@@ -6,7 +6,7 @@ const {isCoupleLines} = require('../is');
 const {JSXOpeningElement} = require('./jsx-opening-element');
 const fragments = require('./jsx-fragment');
 const {JSXText} = require('./jsx-text');
-const {parseComments} = require('../comments/comments');
+const {parseComments} = require('../comment/comment');
 
 module.exports = {
     ...fragments,

package/lib/tokenize/literals/index.js

@@ -72,4 +72,3 @@ module.exports = {
         write('super');
     },
 };
-

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

@@ -13,7 +13,7 @@ const {
 } = require('@babel/types');
 
 const {markAfter} = require('../../mark');
-const {parseComments} = require('../../comments/comments');
+const {parseComments} = require('../../comment/comment');
 const {insideIfWithNoBody} = require('./inside-if-with-no-body');
 const {getDirectives} = require('./get-directives');
 

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

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

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const {parseComments} = require('../../comments/comments');
+const {parseComments} = require('../../comment/comment');
 const {getDirectives} = require('../block-statement/get-directives');
 
 module.exports.Program = (path, {print, write, traverse, maybe}, semantics) => {
@@ -24,4 +24,3 @@ module.exports.Program = (path, {print, write, traverse, maybe}, semantics) => {
     
     print.newline();
 };
-

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

@@ -13,7 +13,7 @@ const {isExportDeclaration} = require('@babel/types');
 const {maybeSpaceAfterKeyword} = require('./maybe-space-after-keyword');
 
 const {isConcatenation} = require('../../expressions/binary-expression/concatanate');
-const {parseLeadingComments} = require('../../comments/comments');
+const {parseLeadingComments} = require('../../comment/comment');
 
 const isParentBlock = (path) => /Program|BlockStatement|Export/.test(path.parentPath.type);
 const isInsideBlock = (path) => /^(Program|BlockStatement)$/.test(path.parentPath.type);

package/lib/tokenize/tokenize.js

@@ -27,7 +27,7 @@ const {
 const {
     parseLeadingComments,
     parseTrailingComments,
-} = require('./comments/comments');
+} = require('./comment/comment');
 
 const {parseOverrides} = require('./overrides');
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "2.56.0",
+  "version": "2.58.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -53,7 +53,6 @@
     "@putout/plugin-promises": "^11.0.0",
     "@putout/plugin-react-hook-form": "^3.4.1",
     "@putout/plugin-react-hooks": "^5.0.0",
-    "@putout/test": "^6.0.1",
     "acorn": "^8.8.2",
     "c8": "^8.0.0",
     "escover": "^3.0.0",

package/lib/tokenize/comments/comments.js

@@ -1,129 +0,0 @@
-'use strict';
-
-const {
-    hasTrailingComment,
-    isLast,
-} = require('../is');
-
-const {markBefore} = require('../mark');
-const {isVariableDeclarator} = require('@babel/types');
-
-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() || path.isDirective()) {
-                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;
-    
-    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);
-        }
-    }
-};
-
-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();
-}