@putout/printer 1.4.0 → 1.4.1

package/ChangeLog

@@ -1,3 +1,14 @@
+2023.03.17, v1.4.1
+
+feature:
+- 1948ce5 @putout/printer: improve support of ObjectExpression
+- 09e1a5c @putout/printer: improve support of ObjectExpression
+- 2d13bc2 @putout/printer: ArrayExpression: newlines
+- 9fc6a00 @putout/printer: improve support of ArrayExpression
+- b91d908 @putout/printer: UnaryExpression: add support of delete
+- 337492b @putout/printer: improve support of NumericLiteral
+- 166085c @putout/printer: add support of hex numbers
+
 2023.03.17, v1.4.0
 
 feature:

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

@@ -1,16 +1,17 @@
 'use strict';
 
+const {isObjectProperty} = require('@babel/types');
 const {entries} = Object;
 const isForOf = ({parentPath}) => parentPath.isForOfStatement();
 
-module.exports.ArrayExpression = (path, {write, indent, maybe, traverse}) => {
-    write('[');
-    
+module.exports.ArrayExpression = (path, {write, maybe, traverse}) => {
     const elements = path.get('elements');
+    const elementIsObject = isElementObject(path);
     
-    indent.inc();
+    write('[');
+    maybe.indent.inc(!elementIsObject);
     
-    const isNewLine = !isNumbers(elements) && !isForOf(path);
+    const isNewLine = !isNumbers(elements) && !isForOf(path) && isLastArg(path) && !isParentProperty(path);
     const n = elements.length - 1;
     
     maybe.write(isNewLine && elements.length, '\n');
@@ -24,8 +25,7 @@ module.exports.ArrayExpression = (path, {write, indent, maybe, traverse}) => {
         maybe.write(!isNewLine && index < n, ', ');
     }
     
-    indent.dec();
-    
+    maybe.indent.dec(!elementIsObject);
     maybe.indent(elements.length && isNewLine);
     
     write(']');
@@ -40,3 +40,27 @@ function isNumbers(elements) {
     return false;
 }
 
+function isLastArg(path) {
+    const {parentPath} = path;
+    
+    if (!parentPath.isCallExpression())
+        return true;
+    
+    const args = parentPath.get('arguments');
+    const n = args.length - 1;
+    
+    return path === args[n];
+}
+
+function isParentProperty(path) {
+    return path.find(isObjectProperty);
+}
+
+function isElementObject(path) {
+    const elements = path.get('elements');
+    
+    if (!elements.length)
+        return false;
+    
+    return elements[0].isObjectExpression();
+}

package/lib/tokenize/expressions/array-pattern.js

@@ -9,6 +9,7 @@ module.exports.ArrayPattern = (path, {write, indent, maybe, traverse}) => {
     const elements = path.get('elements');
     
     indent.inc();
+    
     const isNewLine = !isForOf(path) && elements.length > 2;
     const n = elements.length - 1;
     

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

@@ -1,8 +1,8 @@
 'use strict';
 
 const {
-    hasPrevNewline,
     isMarkedParentBefore,
+    isMarkedPrevAfter,
 } = require('../mark');
 
 const {entries} = Object;
@@ -10,10 +10,8 @@ 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) && !isMarkedParentBefore(path)) {
-        write.newline();
-        write.indent();
-    }
+    if (shouldAddNewLine(path) && !isMarkedParentBefore(path) && !isMarkedPrevAfter(path.parentPath))
+        write.linebreak();
     
     traverse(path.get('callee'));
     write('(');

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

@@ -1,38 +1,33 @@
 'use strict';
 
+const {isCoupleLines} = require('../is');
 const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isForOf = (path) => {
     if (path.parentPath.isForOfStatement())
         return true;
     
-    if (path.parentPath?.parentPath?.isForOfStatement())
-        return true;
-    
-    return false;
+    return path.parentPath?.parentPath?.isForOfStatement();
 };
 
-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 {length} = properties;
-    const isOneLine = !length || isCall && length < 2 && !isFirstMethod(path) || isForOf(path);
+    const parens = isBodyOfArrow(path);
+    const manyLines = !isOneLine(path);
     
     maybe.write(parens, '(');
     write('{');
     
-    maybe.write(!isOneLine, '\n');
+    maybe.write(manyLines, '\n');
     
     for (const property of properties) {
         if (property.isSpreadElement()) {
-            maybe.indent(properties.length > 1);
+            maybe.indent(length > 1);
             traverse(property);
             
-            if (properties.length > 1) {
+            if (length > 1) {
                 write(',');
                 write.newline();
             }
@@ -42,7 +37,7 @@ module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
         
         const {shorthand, computed} = property.node;
         
-        maybe.indent(!isOneLine);
+        maybe.indent(manyLines);
         
         if (property.isObjectMethod()) {
             traverse(property);
@@ -58,11 +53,27 @@ module.exports.ObjectExpression = (path, {traverse, write, maybe, indent}) => {
             traverse(property.get('value'));
         }
         
-        maybe.write(!isOneLine, ',\n');
+        maybe.write(manyLines, ',\n');
     }
     
     indent.dec();
-    maybe.indent(!isOneLine);
+    
+    maybe.indent(manyLines);
     write('}');
     maybe.write(parens, ')');
 };
+function isOneLine(path) {
+    const isCall = path.parentPath.isCallExpression();
+    const {length} = path.get('properties');
+    
+    if (isCoupleLines(path))
+        return false;
+    
+    if (!length)
+        return true;
+    
+    if (isCall && length < 2)
+        return true;
+    
+    return isForOf(path);
+}

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

@@ -3,15 +3,15 @@
 module.exports.UnaryExpression = unaryExpressions;
 module.exports.UpdateExpression = unaryExpressions;
 
-function unaryExpressions(path, {traverse, write}) {
+const isWord = (a) => /delete|typeof/.test(a);
+
+function unaryExpressions(path, {traverse, write, maybe}) {
     const {prefix, operator} = path.node;
     
     if (prefix)
         write(operator);
     
-    if (operator === 'typeof')
-        write(' ');
-    
+    maybe.write(isWord(operator), ' ');
     traverse(path.get('argument'));
     
     if (!prefix)

package/lib/tokenize/is.js

@@ -1,4 +1,11 @@
 'use strict';
 
+module.exports.isFirst = (path) => path.node === path.parentPath.node.body[0];
 module.exports.isPrevBody = (path) => path.getPrevSibling().isBlockStatement();
 module.exports.isNext = (path) => path.getNextSibling().node;
+module.exports.isCoupleLines = (path) => {
+    const start = path.node?.loc?.start.line;
+    const end = path.node?.loc?.end.line;
+    
+    return end > start;
+};

package/lib/tokenize/literals/index.js

@@ -5,7 +5,8 @@ const {TemplateLiteral} = require('./template-literal');
 module.exports = {
     TemplateLiteral,
     NumericLiteral(path, {write}) {
-        write(path.node.value);
+        const {extra, raw} = path.node;
+        write(raw || extra.raw);
     },
     BooleanLiteral(path, {write}) {
         write(path.node.value);

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

@@ -1,17 +1,10 @@
 'use strict';
 
-const {isMarkedAfter} = require('../mark');
-const isPrevNewLine = (path) => {
-    const prev = path.getPrevSibling();
-    
-    if (!prev.node)
-        return true;
-    
-    return isMarkedAfter(prev);
-};
+const {isMarkedPrevAfter} = require('../mark');
+const {isFirst} = require('../is');
 
 module.exports.ForOfStatement = (path, {write, indent, traverse}) => {
-    if (!isPrevNewLine(path)) {
+    if (!isFirst(path) && !isMarkedPrevAfter(path)) {
         write.indent();
         write.newline();
     }

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

@@ -1,6 +1,7 @@
 'use strict';
 
 const {hasPrevNewline} = require('../mark');
+const {isFirst} = require('../is');
 
 module.exports.IfStatement = (path, {write, indent, traverse, incIndent, decIndent}) => {
     if (!isFirst(path) && !hasPrevNewline(path)) {
@@ -36,7 +37,3 @@ module.exports.IfStatement = (path, {write, indent, traverse, incIndent, decInde
     write('\n');
 };
 
-function isFirst(path) {
-    return path.node === path.parentPath.node.body[0];
-}
-

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const {isNext} = require('../is');
+const {isNext, isCoupleLines} = require('../is');
 const isNextAssign = (path) => {
     const nextPath = path.getNextSibling();
     
@@ -27,21 +27,25 @@ module.exports.VariableDeclaration = (path, {write, maybe, maybeIndent, traverse
     traverse(initPath);
     maybe.write(isParentBlock, ';\n');
     
-    const is = isNext(path) && isCoupleLinesExpression(path) && !isNextAssign(path);
+    const is = isNext(path) && isCoupleLines(path) && !isNextAssign(path);
     
     maybe.indent(is);
     maybe.write(is, '\n');
     maybe.markAfter(is, path);
 };
-function isCoupleLinesExpression(path) {
-    const start = path.node?.loc?.start.line;
-    const end = path.node?.loc?.end.line;
-    
-    return end > start;
-}
 
 function shouldAddNewLine(path) {
     const prevPath = path.getPrevSibling();
+    
+    if (prevPath.isStatement() && !prevPath.isExpressionStatement() && !prevPath.isBlockStatement())
+        return false;
+    
+    if (prevPath.isExpressionStatement() && prevPath.get('expression').isStringLiteral())
+        return false;
+    
+    if (isCoupleLines(path))
+        return true;
+    
     const nextPath = path.getNextSibling();
     const nextNextPath = nextPath.getNextSibling();
     
@@ -50,12 +54,6 @@ function shouldAddNewLine(path) {
     if (!twoNext)
         return false;
     
-    if (prevPath.isVariableDeclaration() || prevPath.isExpressionStatement() && prevPath.get('expression').isStringLiteral())
-        return false;
-    
-    if (prevPath.isIfStatement())
-        return false;
-    
     return true;
 }
 

package/lib/tokenize/tokenize.js

@@ -32,11 +32,12 @@ module.exports.tokenize = (ast) => {
     
     const maybeWrite = (a, b) => a && write(b);
     const maybeIndent = (a) => a && indent();
+    const maybeIndentInc = (a) => a && indent.inc();
+    const maybeIndentDec = (a) => a && indent.dec();
     
     let i = 0;
     const incIndent = () => ++i;
     const decIndent = () => --i;
-    
     const indent = () => {
         tokens.push({
             type: TYPES.INDENT,
@@ -76,6 +77,11 @@ module.exports.tokenize = (ast) => {
         markAfter: maybeMarkAfter,
     };
     
+    assign(maybe.indent, {
+        inc: maybeIndentInc,
+        dec: maybeIndentDec,
+    });
+    
     const printer = {
         incIndent,
         decIndent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "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",
@@ -28,6 +28,7 @@
   "dependencies": {
     "@babel/parser": "^7.19.0",
     "@babel/traverse": "^7.21.2",
+    "@babel/types": "^7.21.3",
     "just-snake-case": "^3.2.0"
   },
   "keywords": [
@@ -44,6 +45,7 @@
     "eslint": "^8.0.1",
     "eslint-plugin-n": "^15.2.4",
     "eslint-plugin-putout": "^17.0.0",
+    "estree-to-babel": "^5.0.1",
     "just-kebab-case": "^4.2.0",
     "lerna": "^6.0.1",
     "madrun": "^9.0.0",