@putout/printer 9.7.0 → 9.8.0

package/ChangeLog

@@ -1,3 +1,9 @@
+2024.07.14, v9.8.0
+
+feature:
+- 8fc9139 @putout/printer: maybe-print-computed: add
+- 8800d25 @putout/printer: printKey: add
+
 2024.07.13, v9.7.0
 
 feature:

package/lib/tokenize/expressions/class/class-property.js

@@ -3,6 +3,8 @@
 const {exists} = require('../../is');
 const {maybePrintTypeAnnotation} = require('../../maybe/maybe-type-annotation');
 const {maybeDecorators} = require('../../maybe/maybe-decorators');
+const {printKey} = require('../object-expression/print-key');
+const {printKind} = require('../function/kind');
 
 const processClassProperty = maybeDecorators((path, printer, semantics, {accessor} = {}) => {
     const {node} = path;
@@ -23,7 +25,9 @@ const processClassProperty = maybeDecorators((path, printer, semantics, {accesso
     maybe.print(node.readonly, 'readonly ');
     maybe.print(declare, 'declare ');
     
-    print('__key');
+    printKind(path, printer);
+    printKey(path, printer);
+    
     maybe.print(optional, '?');
     
     maybePrintTypeAnnotation(path, printer);

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

@@ -3,7 +3,8 @@
 const {isNext} = require('../../is');
 const {printParams} = require('./params');
 const {maybeDecorators} = require('../../maybe/maybe-decorators');
-const {printKey} = require('./kind');
+const {printKey} = require('../object-expression/print-key');
+const {printKind} = require('./kind');
 
 const ClassMethod = {
     print: maybeDecorators((path, printer, semantics) => {
@@ -26,6 +27,7 @@ const ClassMethod = {
             print(' ');
         }
         
+        printKind(path, printer);
         printKey(path, printer);
         printParams(path, printer, semantics);
         

package/lib/tokenize/expressions/function/kind.js

@@ -1,12 +1,7 @@
 'use strict';
 
-module.exports.printKey = (path, {write, traverse, maybe}) => {
-    const key = path.get('key');
-    const {
-        kind,
-        computed,
-        generator,
-    } = path.node;
+module.exports.printKind = (path, {write}) => {
+    const {kind, generator} = path.node;
     
     const isGetter = kind === 'get' || kind === 'set';
     
@@ -14,8 +9,4 @@ module.exports.printKey = (path, {write, traverse, maybe}) => {
         write(`${kind} `);
     else if (generator)
         write('*');
-    
-    maybe.write(computed, '[');
-    traverse(key);
-    maybe.write(computed, ']');
 };

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

@@ -2,7 +2,8 @@
 
 const {isNewlineBetweenSiblings} = require('../../is');
 const {printParams} = require('./params');
-const {printKey} = require('./kind');
+const {printKey} = require('../object-expression/print-key');
+const {printKind} = require('./kind');
 
 module.exports.ObjectMethod = {
     beforeIf(path) {
@@ -14,6 +15,7 @@ module.exports.ObjectMethod = {
     print(path, printer, semantics) {
         const {print} = printer;
         
+        printKind(path, printer);
         printKey(path, printer);
         printParams(path, printer, semantics);
         

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

@@ -9,10 +9,19 @@ const {
 const {chain} = require('./chain');
 const {satisfy} = require('../../is');
 
+const {maybePrintComputed} = require('../object-expression/maybe-print-computed');
+
 const isArgOfCall = (path) => path.parentPath.isCallExpression() && path.parentPath.get('arguments.0') === path;
 
-module.exports.MemberExpression = (path, {print, maybe, traverse}) => {
+module.exports.MemberExpression = (path, printer) => {
+    const {
+        print,
+        maybe,
+        traverse,
+    } = printer;
+    
     const object = path.get('object');
+    const property = path.get('property');
     const isParens = object.isAwaitExpression() || object.isAssignmentExpression();
     const {computed} = path.node;
     
@@ -20,13 +29,8 @@ module.exports.MemberExpression = (path, {print, maybe, traverse}) => {
     traverse(object);
     maybe.print(isParens, ')');
     
-    if (computed) {
-        print('[');
-        print('__property');
-        print(']');
-        
-        return;
-    }
+    if (computed)
+        return maybePrintComputed(path, property, printer);
     
     const isChain = likeChain(path);
     

package/lib/tokenize/expressions/object-expression/maybe-print-computed.js

@@ -0,0 +1,9 @@
+'use strict';
+
+module.exports.maybePrintComputed = (path, key, {maybe, traverse}) => {
+    const {computed} = path.node;
+    
+    maybe.write(computed, '[');
+    traverse(key);
+    maybe.write(computed, ']');
+};

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

@@ -2,21 +2,24 @@
 
 const {isConcatenation} = require('../binary-expression/concatanate');
 const {isOneLine} = require('./object-expression');
+const {printKey} = require('./print-key');
 
-module.exports.ObjectProperty = (path, {maybe, traverse, write}, semantics) => {
+module.exports.ObjectProperty = (path, printer, semantics) => {
     const {trailingComma} = semantics;
-    const {shorthand, computed} = path.node;
+    const {shorthand} = path.node;
+    const {
+        maybe,
+        traverse,
+        write,
+    } = printer;
     
-    const key = path.get('key');
     const value = path.get('value');
     
     const properties = path.parentPath.get('properties');
     const isLast = path === properties.at(-1);
     const manyLines = !isOneLine(path.parentPath);
     
-    maybe.write(computed, '[');
-    traverse(key);
-    maybe.write(computed, ']');
+    printKey(path, printer);
     
     if (!shorthand) {
         write(':');

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const {maybePrintComputed} = require('./maybe-print-computed');
+
+module.exports.printKey = (path, printer) => {
+    const key = path.get('key');
+    
+    maybePrintComputed(path, key, printer);
+};

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

@@ -18,6 +18,7 @@ const {moreThenMaxPropertiesInOneLine} = require('./more-then-max-properties-in-
 
 const {maybeTypeAnnotation} = require('../../maybe/maybe-type-annotation');
 const {moreThenMaxPropertiesLengthInOneLine} = require('./more-then-max-properties-length-in-one-line');
+const {printKey} = require('../object-expression/print-key');
 
 const isTwoLevelsDeep = ({parentPath}) => parentPath.parentPath.parentPath.isObjectProperty();
 const isOneParentProperty = ({parentPath}) => parentPath.parentPath.node.properties?.length === 1;
@@ -37,13 +38,19 @@ const isCoupleProperties = ({path, valuePath, property}) => {
 };
 
 module.exports.ObjectPattern = {
-    print: maybeTypeAnnotation((path, {print, maybe, indent}, semantics) => {
+    print: maybeTypeAnnotation((path, printer, semantics) => {
         const shouldIndent = isIndent(path);
         const {
             maxPropertiesInOneLine,
             maxPropertiesLengthInOneLine,
         } = semantics;
         
+        const {
+            print,
+            maybe,
+            indent,
+        } = printer;
+        
         maybe.indent.inc(shouldIndent);
         print('{');
         
@@ -83,9 +90,7 @@ module.exports.ObjectPattern = {
             maybe.indent(is);
             maybe.print.breakline(couple);
             
-            maybe.print(computed, '[');
-            print(keyPath);
-            maybe.print(computed, ']');
+            printKey(property, printer);
             
             if (!shorthand || wrongShorthand({computed, isAssign, keyPath, valuePath})) {
                 print(':');

package/lib/tokenize/typescript/function/ts-method-signature.js

@@ -1,15 +1,18 @@
 'use strict';
 
 const {printParams} = require('../../expressions/function/params');
-const {printKey} = require('../../expressions/function/kind');
+const {printKind} = require('../../expressions/function/kind');
 const {
     hasReturnType,
     printReturnType,
 } = require('./print-return-type');
 
+const {printKey} = require('../../expressions/object-expression/print-key');
+
 module.exports.TSMethodSignature = (path, printer, semantics) => {
     const {write} = printer;
     
+    printKind(path, printer);
     printKey(path, printer);
     printParams(path, printer, semantics);
     

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

@@ -7,23 +7,15 @@ const {
     isNext,
 } = require('../../is');
 
+const {printKey} = require('../../expressions/object-expression/print-key');
+
 module.exports.TSPropertySignature = (path, printer) => {
-    const {
-        print,
-        maybe,
-        write,
-    } = printer;
+    const {maybe, write} = printer;
     
-    const {
-        computed,
-        optional,
-        readonly,
-    } = path.node;
+    const {optional, readonly} = path.node;
     
     maybe.print(readonly, 'readonly ');
-    maybe.print(computed, '[');
-    print('__key');
-    maybe.print(computed, ']');
+    printKey(path, printer);
     maybe.print(optional, '?');
     
     maybePrintTypeAnnotation(path, printer);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "9.7.0",
+  "version": "9.8.0",
   "type": "commonjs",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -45,6 +45,7 @@
     "generate"
   ],
   "devDependencies": {
+    "@putout/eslint": "^3.5.0",
     "@putout/plugin-minify": "^8.0.0",
     "@putout/plugin-printer": "^3.0.0",
     "@putout/plugin-promises": "^15.0.0",