@putout/printer 18.2.0 → 18.2.2

package/ChangeLog

@@ -1,3 +1,14 @@
+2026.03.07, v18.2.2
+
+feature:
+- 7633d10 @putout/printer: ArrayExpression: isSimpleAfterObject
+- c57048d @putout/printer: ArrayExpression: isCurrentNewLine: simplify
+
+2026.03.07, v18.2.1
+
+fix:
+- b4e4b01 @putout/printer: ExpressionStatement
+
 2026.03.07, v18.2.0
 
 feature:

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

@@ -9,6 +9,7 @@ import {
     isNextObject,
     callWithNext,
     isInsideArray,
+    callWithPrev,
 } from '#is';
 import {
     isIncreaseIndent,
@@ -96,17 +97,18 @@ export const ArrayExpression = {
         
         maybe.indent.inc(indented && shouldIncreaseIndent);
         
-        const isNewLine = isMultiLine(path, {
+        const needsNewline = isMultiLine(path, {
             maxElementsInOneLine,
             maxElementLengthInOneLine,
         });
         
         const n = elements.length - 1;
         
-        maybe.print.newline(isNewLine && elements.length);
+        if (needsNewline)
+            print.newline();
         
         for (const [index, element] of elements.entries()) {
-            const is = isNewLine && isCurrentNewLine(element);
+            const is = needsNewline && isCurrentNewLine(element);
             
             if (isSimpleAfterObject(element))
                 print.newline();
@@ -139,10 +141,10 @@ export const ArrayExpression = {
             const isHideIdent = !isAroundStrings(path) || parentCountTwo;
             
             maybe.indent.dec(isHideIdent);
-            maybe.indent(elements.length && isNewLine);
+            maybe.indent(elements.length && needsNewline);
             maybe.indent.inc(isHideIdent);
         } else if (!isArrayInsideArray(path) && !isObjectExpression(elements.at(-1))) {
-            maybe.indent(elements.length && isNewLine);
+            maybe.indent(elements.length && needsNewline);
         }
         
         if (isSimpleAndNotEmptyObject(path) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
@@ -173,15 +175,15 @@ export const ArrayExpression = {
     },
 };
 
-function isSimpleAfterObject(path) {
-    if (!isSpreadElement(path) && !isIdentifier(path) && !isCallExpression(path))
-        return;
-    
-    const prev = path.getPrevSibling();
-    const next = path.getNextSibling();
-    
-    if (next.isObjectExpression())
-        return false;
-    
-    return prev.isObjectExpression();
-}
+const isSimple = createTypeChecker([
+    '-: -> SpreadElement',
+    '-: -> Identifier',
+    '+: -> !CallExpression',
+]);
+
+const isSimpleAfterObject = createTypeChecker([
+    ['-', isSimple],
+    ['-', callWithNext(isObjectExpression)],
+    ['+', callWithPrev(isObjectExpression)],
+]);
+

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

@@ -338,9 +338,8 @@ const isStringAndObject = (elements) => {
     return isStringLiteral(first) && isObjectExpression(last);
 };
 
-export const isCurrentNewLine = (path) => {
-    if (path.isSpreadElement())
-        return true;
-    
-    return !path.isObjectExpression();
-};
+export const isCurrentNewLine = createTypeChecker([
+    '+: -> SpreadElement',
+    '+: -> !ObjectExpression',
+]);
+

package/lib/tokenize/is.js

@@ -31,6 +31,7 @@ export const isInsideTSModuleBlock = ({parentPath}) => isTSModuleBlock(parentPat
 export const isInsideCall = ({parentPath}) => parentPath.isCallExpression();
 export const isInsideReturn = ({parentPath}) => parentPath.isReturnStatement();
 export const callWithNext = (fn) => (path) => fn(path.getNextSibling());
+export const callWithPrev = (fn) => (path) => fn(path.getPrevSibling());
 export const callWithParent = (fn) => (path) => fn(path.parentPath);
 
 export const isNext = (path) => {

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

@@ -39,7 +39,7 @@ const isBreaklineAfter = createTypeChecker([
 const isNextStatementWithBlockComment = createTypeChecker([
     '-: node.expression -> !CallExpression',
     '-: node.expression.arguments.0 -> !CallExpression',
-    '+: node.trailingComments.0 -> 🧨 CommentBlock',
+    '+: node.trailingComments.0 -> CommentBlock',
 ]);
 
 const isBreakline = createTypeChecker([

package/lib/tokenize/type-checker/instrument.js

@@ -37,4 +37,3 @@ export const instrument = (typeNames, fn, overrides = {}) => {
 };
 
 export const getCoverage = () => Coverage;
-

package/lib/tokenize/type-checker/type-checker.js

@@ -12,6 +12,7 @@ export const createTypeChecker = (typeNames, overrides = {}) => {
     const {
         instrumentCoverage = _instrument,
     } = overrides;
+    
     const tuples = parseTypeNames(typeNames);
     const typeChecker = (path, options) => {
         for (const [index, [operation, typeName]] of tuples.entries()) {

package/package.json

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