@putout/printer 5.2.0 → 5.4.0

package/ChangeLog

@@ -1,3 +1,14 @@
+2023.09.20, v5.4.0
+
+feature:
+- 896b185 @putout/printer: maybeTypeAnnotation
+- 74f9303 @putout/printer: ObjectExpression: maybeParens
+
+2023.09.19, v5.3.0
+
+feature:
+- c0b651a @putout/printer: ArrayPattern: typeAnnotation
+
 2023.09.19, v5.2.0
 
 feature:

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

@@ -1,8 +1,9 @@
 'use strict';
 
+const {maybeTypeAnnotation} = require('../literals/maybe-type-annotation');
 const isForOf = ({parentPath}) => parentPath.parentPath.parentPath?.isForOfStatement();
 
-module.exports.ArrayPattern = (path, {indent, maybe, print}, options) => {
+module.exports.ArrayPattern = maybeTypeAnnotation((path, {indent, maybe, print}, options) => {
     const {maxElementsInOneLine} = options;
     
     print('[');
@@ -30,4 +31,4 @@ module.exports.ArrayPattern = (path, {indent, maybe, print}, options) => {
     indent.dec();
     maybe.indent(elements.length && isNewLine);
     print(']');
-};
+});

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

@@ -13,11 +13,10 @@ const {
 
 const {parseComments} = require('../../comment/comment');
 const {likeChain} = require('../member-expression/member-expressions');
+const {maybeParens} = require('../function/parens');
 
-const isBodyOfArrow = (path) => path.parentPath.node.body === path.node;
 const isLogical = (path) => path.get('argument').isLogicalExpression();
 const isValue = (path) => path.get('properties.0.value').node;
-const isParentExpression = (path) => path.parentPath.isExpressionStatement();
 
 const isMemberExpressionCallee = ({parentPath}) => {
     if (!parentPath.isCallExpression())
@@ -31,16 +30,16 @@ const isMemberExpressionCallee = ({parentPath}) => {
     return likeChain(callee);
 };
 
-module.exports.ObjectExpression = (path, {print, maybe, indent, write}, semantics) => {
+module.exports.ObjectExpression = maybeParens((path, {print, maybe, indent, write}, semantics) => {
     const {trailingComma} = semantics;
     indent.inc();
     
     const properties = path.get('properties');
     const {length} = properties;
-    const parens = isParens(path);
     const manyLines = !isOneLine(path);
     
-    maybe.print(parens, '(');
+    maybe.print(path.isRecordExpression(), '#');
+    
     print('{');
     parseComments(path, {write}, semantics);
     maybe.print.newline(manyLines);
@@ -82,10 +81,9 @@ module.exports.ObjectExpression = (path, {print, maybe, indent, write}, semantic
     indent.dec();
     maybe.indent(manyLines);
     print('}');
-    maybe.print(parens, ')');
     
     maybe.indent.dec(isMemberExpressionCallee(path));
-};
+});
 
 const hasNextLeadingComment = (path) => {
     const next = path.getNextSibling();
@@ -134,10 +132,3 @@ function isOneLine(path) {
     
     return !isValue(path);
 }
-
-function isParens(path) {
-    if (isBodyOfArrow(path))
-        return true;
-    
-    return isParentExpression(path);
-}

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

@@ -2,8 +2,4 @@
 
 const {ObjectExpression} = require('./object-expression');
 
-module.exports.RecordExpression = (path, operations, semantics) => {
-    const {write} = operations;
-    write('#');
-    ObjectExpression(path, operations, semantics);
-};
+module.exports.RecordExpression = ObjectExpression;

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

@@ -15,13 +15,14 @@ const {
 } = require('../../is');
 
 const {checkMaxPropertiesInOneLine} = require('./max-properties-in-one-line');
+const {maybeTypeAnnotation} = require('../../literals/maybe-type-annotation');
 
 const isTwoLevelsDeep = ({parentPath}) => parentPath.parentPath.parentPath.isObjectProperty();
 
 const isOneParentProperty = ({parentPath}) => parentPath.parentPath.node.properties?.length === 1;
 
 module.exports.ObjectPattern = {
-    print(path, {indent, print, maybe}, semantics) {
+    print: maybeTypeAnnotation((path, {indent, print, maybe}, semantics) => {
         const {maxPropertiesInOneLine} = semantics;
         
         indent.inc();
@@ -89,14 +90,7 @@ module.exports.ObjectPattern = {
         indent.dec();
         maybe.indent(is);
         print('}');
-        
-        const {typeAnnotation} = path.node;
-        
-        if (typeAnnotation) {
-            print(': ');
-            print('__typeAnnotation');
-        }
-    },
+    }),
     afterIf(path) {
         if (!path.parentPath.isObjectProperty())
             return false;

package/lib/tokenize/expressions/rest-element.js

@@ -1,16 +1,8 @@
 'use strict';
 
-const {exists} = require('../is');
+const {maybeTypeAnnotation} = require('../literals/maybe-type-annotation');
 
-module.exports.RestElement = (path, {print, traverse}) => {
-    const typeAnnotation = path.get('typeAnnotation');
-    
+module.exports.RestElement = maybeTypeAnnotation((path, {print}) => {
     print('...');
     print('__argument');
-    
-    if (exists(typeAnnotation)) {
-        print(':');
-        print.space();
-        traverse(typeAnnotation);
-    }
-};
+});

package/lib/tokenize/literals/identifier.js

@@ -2,8 +2,9 @@
 
 const {maybeDecorators} = require('../maybe-get');
 const {maybeParens} = require('../expressions/function/parens');
+const {maybeTypeAnnotation} = require('./maybe-type-annotation');
 
-module.exports.Identifier = maybeParens((path, printer) => {
+module.exports.Identifier = maybeParens(maybeTypeAnnotation((path, printer) => {
     const {
         write,
         maybe,
@@ -14,8 +15,6 @@ module.exports.Identifier = maybeParens((path, printer) => {
     const {node} = path;
     const {name, optional} = node;
     
-    const typeAnnotation = path.get('typeAnnotation');
-    
     for (const decorator of maybeDecorators(path)) {
         traverse(decorator);
         print(' ');
@@ -23,5 +22,4 @@ module.exports.Identifier = maybeParens((path, printer) => {
     
     write(name);
     maybe.write(optional, '?');
-    traverse(typeAnnotation);
-});
+}));

package/lib/tokenize/literals/maybe-type-annotation.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports.maybeTypeAnnotation = (visit) => (path, printer, semantics) => {
+    const {typeAnnotation} = path.node;
+    const {print} = printer;
+    
+    visit(path, printer, semantics);
+    
+    if (typeAnnotation) {
+        print(':');
+        print.space();
+        print('__typeAnnotation');
+    }
+};

package/lib/tokenize/typescript/index.js

@@ -177,11 +177,6 @@ module.exports = {
         print('__parameter');
     },
     TSTypeAnnotation(path, {print}) {
-        if (path.parentPath.isIdentifier()) {
-            print(':');
-            print.space();
-        }
-        
         print('__typeAnnotation');
     },
     TSConstructSignatureDeclaration,

package/lib/tokenize/typescript/ts-property-signature.js

@@ -1,17 +1,10 @@
 'use strict';
 
-const {exists} = require('../is');
+const {maybeTypeAnnotation} = require('../literals/maybe-type-annotation');
 
-module.exports.TSPropertySignature = (path, {print, maybe, traverse}) => {
+module.exports.TSPropertySignature = maybeTypeAnnotation((path, {print, maybe}) => {
     const {optional} = path.node;
-    const typeAnnotation = path.get('typeAnnotation');
     
     print('__key');
     maybe.print(optional, '?');
-    
-    if (exists(typeAnnotation)) {
-        print(':');
-        print.space();
-        traverse(typeAnnotation);
-    }
-};
+});

package/package.json

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