@putout/printer 1.57.0 → 1.59.0

package/ChangeLog

@@ -1,3 +1,13 @@
+2023.04.20, v1.59.0
+
+feature:
+- 83d8323 @putout/printer: add support of Super
+
+2023.04.19, v1.58.0
+
+feature:
+- da02030 @putout/printer: improve support of comments inside JSX
+
 2023.04.19, v1.57.0
 
 feature:

package/lib/tokenize/comments.js

@@ -10,12 +10,19 @@ module.exports.parseLeadingComments = (path, {print, maybe}) => {
     if (!leadingComments || !leadingComments.length)
         return;
     
-    const isClass = !path.isClassMethod();
+    const insideFn = path.parentPath.isFunction();
+    const isIndent = !path.isClassMethod() && !insideFn;
     
     for (const {type, value} of leadingComments) {
-        maybe.indent(isClass);
+        maybe.indent(isIndent);
         
         if (type === 'CommentLine') {
+            maybe.indent.inc(insideFn);
+            maybe.indent.inc(insideFn);
+            maybe.print.breakline(insideFn);
+            maybe.indent.dec(insideFn);
+            maybe.indent.dec(insideFn);
+            
             print(`//${value}`);
             print.newline();
             

package/lib/tokenize/expressions/class.js

@@ -1,9 +1,11 @@
 'use strict';
 
+const {isNext} = require('../is');
+
 module.exports.ClassExpression = classVisitor;
 module.exports.ClassDeclaration = classVisitor;
 
-module.exports.ClassDeclaration = (path, {print, indent, maybe}) => {
+module.exports.ClassDeclaration = (path, {print, indent, maybe, write}) => {
     indent();
     
     classVisitor(path, {
@@ -11,6 +13,10 @@ module.exports.ClassDeclaration = (path, {print, indent, maybe}) => {
         indent,
         maybe,
     });
+    
+    if (!path.parentPath.isExportDeclaration() && isNext(path)) {
+        write.newline();
+    }
 };
 
 function classVisitor(path, {print, indent, maybe}) {

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

@@ -37,7 +37,14 @@ module.exports.ArrowFunctionExpression = {
         
         print.space();
         print('=>');
-        print.space();
+        
+        const body = path.get('body');
+        
+        const insideCall = path.parentPath.isCallExpression();
+        const isJSX = body.isJSXElement();
+        
+        maybe.print.space(!insideCall && isJSX);
+        maybe.print.space(!isJSX);
         print('__body');
     },
     after(path, {write}) {

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

@@ -0,0 +1,32 @@
+'use strict';
+
+module.exports.ClassMethod = (path, {print, maybe}) => {
+    const {kind} = path.node;
+    const isConstructor = kind === 'constructor';
+    const isMethod = kind === 'method';
+    const isGetter = /get|set/.test(kind);
+    
+    maybe.print(isConstructor, kind);
+    maybe.print(isMethod, '__key');
+    
+    if (isGetter) {
+        print(kind);
+        print(' ');
+        print('__key');
+    }
+    
+    print('(');
+    
+    const params = path.get('params');
+    const n = params.length;
+    
+    for (let i = 0; i < n; i++) {
+        print(params[i]);
+        
+        if (i < n - 1)
+            print(', ');
+    }
+    
+    print(') ');
+    print('__body');
+};

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

@@ -2,8 +2,20 @@
 
 const {markAfter} = require('../../mark');
 const {isNext} = require('../../is');
+const isFirst = (path) => !path.getPrevSibling().node;
 
 module.exports.FunctionDeclaration = {
+    beforeIf(path) {
+        if (isFirst(path))
+            return false;
+        
+        const prev = path.getPrevSibling();
+        
+        return prev.isClassDeclaration();
+    },
+    before(path, {write}) {
+        write.newline();
+    },
     print(path, {print, maybe}) {
         const {async} = path.node;
         

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

@@ -2,9 +2,11 @@
 
 const {ArrowFunctionExpression} = require('./arrow-function-expression');
 const {FunctionDeclaration} = require('./function-declaration');
+const {ClassMethod} = require('./class-method');
 
 module.exports.ArrowFunctionExpression = ArrowFunctionExpression;
 module.exports.FunctionDeclaration = FunctionDeclaration;
+module.exports.ClassMethod = ClassMethod;
 
 module.exports.FunctionExpression = (path, {print, maybe, write, traverse}) => {
     const {node} = path;
@@ -63,26 +65,3 @@ module.exports.ObjectMethod = (path, {print}) => {
     print(') ');
     print('__body');
 };
-
-module.exports.ClassMethod = (path, {print, maybe}) => {
-    const {kind} = path.node;
-    const notMethod = kind !== 'method';
-    const notConstructor = kind !== 'constructor';
-    
-    maybe.print(notMethod, `${kind} `);
-    maybe.print(notConstructor, '__key');
-    print('(');
-    
-    const params = path.get('params');
-    const n = params.length;
-    
-    for (let i = 0; i < n; i++) {
-        print(params[i]);
-        
-        if (i < n - 1)
-            print(', ');
-    }
-    
-    print(') ');
-    print('__body');
-};

package/lib/tokenize/jsx/jsx-element.js

@@ -7,10 +7,25 @@ module.exports.JSXElement = {
         indent.inc();
         write.breakline();
     },
-    print(path, {print, traverse}) {
+    print(path, {print, traverse, indent, maybe}) {
+        const insideFn = path.parentPath.isArrowFunctionExpression();
+        const insideCall = path.parentPath.parentPath.isCallExpression();
+        
+        if (insideFn && insideCall) {
+            indent.inc();
+            indent.inc();
+            indent();
+        }
+        
         print('__openingElement');
         path.get('children').map(traverse);
         print('__closingElement');
+        
+        if (insideFn && insideCall) {
+            indent.dec();
+            maybe.print.breakline(insideCall);
+            indent.dec();
+        }
     },
     after(path, {write, indent}) {
         indent.dec();

package/lib/tokenize/jsx/jsx-opening-element.js

@@ -2,27 +2,29 @@
 
 const {isCoupleLines} = require('../is');
 
-module.exports.JSXOpeningElement = (path, {print, maybe}) => {
-    print('<');
-    print('__name');
-    
-    const coupleLines = isCoupleLines(path);
-    const noCoupleLines = !coupleLines;
-    const shouldIndent = coupleLines && path.parentPath.parentPath.isJSXElement();
-    
-    maybe.indent.inc(shouldIndent);
-    
-    for (const attr of path.get('attributes')) {
-        maybe.print.space(noCoupleLines);
-        print(attr);
-    }
-    
-    if (isCoupleLines(path))
-        print.breakline();
-    
-    if (path.node.selfClosing)
-        print('/');
-    
-    print('>');
-    maybe.indent.dec(shouldIndent);
+module.exports.JSXOpeningElement = {
+    print(path, {print, maybe}) {
+        print('<');
+        print('__name');
+        
+        const coupleLines = isCoupleLines(path);
+        const noCoupleLines = !coupleLines;
+        const shouldIndent = coupleLines && path.parentPath.parentPath.isJSXElement();
+        
+        maybe.indent.inc(shouldIndent);
+        
+        for (const attr of path.get('attributes')) {
+            maybe.print.space(noCoupleLines);
+            print(attr);
+        }
+        
+        if (isCoupleLines(path))
+            print.breakline();
+        
+        if (path.node.selfClosing)
+            print('/');
+        
+        print('>');
+        maybe.indent.dec(shouldIndent);
+    },
 };

package/lib/tokenize/literals/index.js

@@ -42,4 +42,8 @@ module.exports = {
     Import(path, {write}) {
         write('import');
     },
+    Super(path, {write}) {
+        write('super');
+    },
 };
+

package/package.json

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