@putout/printer 18.2.11 → 18.3.0

package/ChangeLog

@@ -1,3 +1,19 @@
+2026.03.08, v18.3.0
+
+feature:
+- 31aa6f8 @putout/printer: ArrayExpression: isIndentBeforeElement
+- e21a6cd @putout/printer: ArrayExpression: simplify
+- 00b646d @putout/printer: ArrayExpression: maybePrintSpace
+- 56e83f6 @putout/printer: ArrayExpression: maybePrintCommaWithSpace
+- 9be2086 @putout/printer: ArrayExpression: afterIf: simplify
+- 2ccc185 @putout/printer: ArrayExpression: isCommaBeforeClosingSquareBrace
+- 35e1a1a @putout/printer: ArrayExpression: neesComma
+
+2026.03.08, v18.2.12
+
+feature:
+- 284d9a7 @putout/printer: ArrayExpression: isNewlineAfterComma: simplify
+
 2026.03.08, v18.2.11
 
 feature:
@@ -7,7 +23,7 @@ feature:
 2026.03.08, v18.2.10
 
 feature:
-- 7a73310 @putout/printer: ArrayExpresison: maybeSecondIndent
+- 7a73310 @putout/printer: ArrayExpresison: maybeAdditionalIndent
 - cfcf1ce @putout/printer: ArrayExpression: isSecondIndent
 - 0acb26a @putout/printer: ArrayExpression: isSecondIndent
 

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

@@ -0,0 +1,16 @@
+import {
+    isCoupleLines,
+    isIdentifierAndIdentifier,
+    isStringAndIdentifier,
+} from '#is';
+import {createTypeChecker} from '#type-checker';
+import {isInsideOneElementArray} from './before-if.js';
+
+export const afterIf = createTypeChecker([
+    ['-: parentPath -> !ArrayExpression'],
+    ['-: parentPath ->', isCoupleLines],
+    ['+', isIdentifierAndIdentifier],
+    ['-: -> !', isStringAndIdentifier],
+    ['+', isInsideOneElementArray],
+]);
+

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

@@ -1,46 +1,23 @@
 import {types} from '@putout/babel';
 import {createTypeChecker} from '#type-checker';
+import {callWithNext, callWithPrev} from '#is';
 import {
-    isCoupleLines,
-    isStringAndIdentifier,
-    isIdentifierAndIdentifier,
-    isSimpleAndNotEmptyObject,
-    callWithNext,
-    callWithPrev,
-} from '#is';
-import {
-    isCurrentNewLine,
+    isIndentBeforeElement,
     isMultiLine,
-    isNewlineAfterComma,
 } from './newline.js';
-import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
     isNeedIndent,
-    maybeSecondIndent,
+    maybeAdditionalIndent,
 } from './indent.js';
+import {beforeIf} from './before-if.js';
+import {afterIf} from './after-if.js';
 import {
-    beforeIf,
-    isInsideOneElementArray,
-} from './before-if.js';
-
-const {
-    isObjectExpression,
-    isSpreadElement,
-    isIdentifier,
-    isCallExpression,
-} = types;
-
-const isSimpleBetweenObjects = createTypeChecker([
-    ['+', callWithNext(isObjectExpression)],
-    ['-', isSpreadElement],
-    ['-', isIdentifier],
-    ['+: -> !', isCallExpression],
-]);
+    isCommaBeforeClosingSquareBrace,
+    isNewlineAfterComma,
+    isSpaceAfterComa,
+} from './comma.js';
 
-const isSpaceAfterComa = createTypeChecker([
-    ['+', callWithNext(isSimpleBetweenObjects)],
-    ['+: -> !ObjectExpression'],
-]);
+const {isObjectExpression} = types;
 
 export const ArrayExpression = {
     beforeIf,
@@ -48,7 +25,11 @@ export const ArrayExpression = {
         print.breakline();
     },
     print(path, printer, semantics) {
-        const {print, maybe} = printer;
+        const {
+            print,
+            maybe,
+            indent,
+        } = printer;
         
         const {
             maxElementsInOneLine,
@@ -56,73 +37,58 @@ export const ArrayExpression = {
             maxElementLengthInOneLine,
         } = semantics;
         
-        const elements = path.get('elements');
-        
-        print('[');
-        
         const needIndent = isNeedIndent(path);
-        
-        maybe.indent.inc(needIndent);
-        
-        const needsNewline = isMultiLine(path, {
+        const multiline = isMultiLine(path, {
             maxElementsInOneLine,
             maxElementLengthInOneLine,
         });
         
-        const n = elements.length - 1;
+        const elements = path.get('elements');
         
-        if (needsNewline)
-            print.newline();
+        print('[');
+        maybe.indent.inc(needIndent);
+        maybe.print.newline(multiline);
+        
+        const n = elements.length - 1;
         
         for (const [index, element] of elements.entries()) {
-            const is = needsNewline && isCurrentNewLine(element);
+            const isLast = index === n;
+            const needsIndentBeforeElement = isIndentBeforeElement(element, {multiline});
+            const needsComma = needsIndentBeforeElement && trailingComma || !isLast;
             
-            if (isSimpleAfterObject(element))
+            if (isNewlineBeforeElement(element))
                 print.newline();
             
-            maybe.indent(is);
+            if (needsIndentBeforeElement)
+                indent();
+            
             print(element);
             
-            if (index < n || trailingComma)
-                maybe.print(is, ',');
+            if (needsComma)
+                print(',');
             
-            if (is && isNewlineAfterComma(element))
+            if (isNewlineAfterComma(element, {multiline})) {
                 print.newline();
-            
-            maybe.print.space(is && isObjectAfterSimple(element));
-            
-            if (!is && index < n) {
-                print(',');
-                maybe.print.space(isSpaceAfterComa(element));
+                continue;
             }
+            
+            if (isSpaceAfterComa(element, {isLast}))
+                print.space();
         }
         
         maybe.indent.dec(needIndent);
-        maybeSecondIndent(path, printer, semantics, {
-            needsNewline,
+        maybeAdditionalIndent(path, printer, semantics, {
+            multiline,
         });
         
-        if (isSimpleAndNotEmptyObject(path) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
+        if (isCommaBeforeClosingSquareBrace(path)) {
             print(',');
             print.breakline();
         }
         
         print(']');
     },
-    afterIf(path) {
-        const {parentPath} = path;
-        
-        if (!parentPath.isArrayExpression())
-            return false;
-        
-        if (isCoupleLines(parentPath))
-            return false;
-        
-        if (isStringAndIdentifier(path) && isInsideOneElementArray(path))
-            return true;
-        
-        return isIdentifierAndIdentifier(path);
-    },
+    afterIf,
     after(path, {print, indent}) {
         indent.dec();
         print.breakline();
@@ -136,8 +102,9 @@ const isSimple = createTypeChecker([
     '+: -> !CallExpression',
 ]);
 
-const isSimpleAfterObject = createTypeChecker([
+const isNewlineBeforeElement = createTypeChecker([
     ['-', isSimple],
     ['-', callWithNext(isObjectExpression)],
     ['+', callWithPrev(isObjectExpression)],
 ]);
+

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

@@ -0,0 +1,44 @@
+import {types} from '@putout/babel';
+import {createTypeChecker} from '#type-checker';
+import {
+    callWithNext,
+    isSimpleAndNotEmptyObject,
+} from '#is';
+import {
+    isLastOption,
+    isMultilineOption,
+} from './is.js';
+
+const {
+    isSpreadElement,
+    isCallExpression,
+    isObjectExpression,
+    isIdentifier,
+} = types;
+
+const callWithLastElement = (fn) => (a) => fn(a.at(-1));
+
+export const isCommaBeforeClosingSquareBrace = createTypeChecker([
+    ['-: -> !', isSimpleAndNotEmptyObject],
+    ['-: node.elements', callWithLastElement(isSpreadElement)],
+    ['+: node.elements -> !', callWithLastElement(isCallExpression)],
+]);
+
+export const isNewlineAfterComma = createTypeChecker([
+    ['-: -> !', isMultilineOption],
+    ['-', callWithNext(isObjectExpression)],
+    ['+: -> !ObjectExpression'],
+]);
+
+const isSimpleBetweenObjects = createTypeChecker([
+    ['+', callWithNext(isObjectExpression)],
+    ['-', isSpreadElement],
+    ['-', isIdentifier],
+    ['+: -> !', isCallExpression],
+]);
+
+export const isSpaceAfterComa = createTypeChecker([
+    ['-', isLastOption],
+    ['+', callWithNext(isSimpleBetweenObjects)],
+    ['+: -> !ObjectExpression'],
+]);

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

@@ -5,6 +5,10 @@ import {
     isInsideCall,
     isStringAndArray,
 } from '#is';
+import {
+    isMultilineOption,
+    isNeedsToHideIndentOption,
+} from './is.js';
 
 const isTwoLongStrings = (path) => {
     const [a, b] = path.node.elements;
@@ -104,23 +108,20 @@ export const isHideIndent = createTypeChecker([
 
 const isLastElementObjectExpression = ({node}) => isObjectExpression(node.elements.at(-1));
 
-const isNeedsNewlineOption = (a, {needsNewline}) => needsNewline;
-const isNeedsToHideIndentOption = (a, {needsToHideIndent}) => needsToHideIndent;
-
 export const isSecondIndent = createTypeChecker([
-    ['-: -> !', isNeedsNewlineOption],
+    ['-: -> !', isMultilineOption],
     ['+', isNeedsToHideIndentOption],
     ['-: ->', isArrayInsideArray],
     ['+: -> !', isLastElementObjectExpression],
 ]);
 
-export function maybeSecondIndent(path, printer, semantics, options) {
+export function maybeAdditionalIndent(path, printer, semantics, options) {
     const {maybe, indent} = printer;
-    const {needsNewline} = options;
+    const {multiline} = options;
     const needsToHideIndent = isHideIndent(path);
     
     const needsToMakeSecondIndent = isSecondIndent(path, {
-        needsNewline,
+        multiline,
         needsToHideIndent,
     });
     

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

@@ -0,0 +1,4 @@
+export const isMultilineOption = (a, {multiline}) => multiline;
+export const isNeedsToHideIndentOption = (a, {needsToHideIndent}) => needsToHideIndent;
+export const isLastOption = (a, {isLast}) => isLast;
+

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

@@ -11,9 +11,9 @@ import {
     isSimpleAndNotEmptyObject,
     isInsideCall,
     isInsideArray,
-    isNextObject,
 } from '#is';
 import {isIncreaseIndent} from './indent.js';
+import {isMultilineOption} from './is.js';
 
 const isParentProperty = (path) => path.find(isObjectProperty);
 
@@ -306,12 +306,9 @@ function isNumbers(elements) {
     return false;
 }
 
-export const isCurrentNewLine = createTypeChecker([
-    '+: -> SpreadElement',
-    '+: -> !ObjectExpression',
+export const isIndentBeforeElement = createTypeChecker([
+    ['-: -> !', isMultilineOption],
+    ['+: -> SpreadElement'],
+    ['+: -> !ObjectExpression'],
 ]);
 
-export const isNewlineAfterComma = createTypeChecker([
-    ['-', isNextObject],
-    ['+: -> !', isObjectExpression],
-]);

package/lib/tokenize/is.js

@@ -61,10 +61,6 @@ export const isPrev = (path) => {
 export const isNextParent = (path) => isNext(path.parentPath);
 export const isLast = (path) => isInsideProgram(path) && !isNext(path);
 
-export const isNextObject = (a) => a
-    .getNextSibling()
-    .isObjectExpression();
-
 export const isFirst = (path) => path.node === path.parentPath.node.body?.[0];
 export const isPrevBody = (path) => path
     .getPrevSibling()

package/package.json

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

package/lib/tokenize/expressions/array-expression/is-object-after-simple.js

@@ -1,18 +0,0 @@
-import {isNextObject} from '#is';
-import {createTypeChecker} from '#type-checker';
-
-const SIMPLE_TYPES = [
-    'ArrayExpression',
-    'ObjectExpression',
-    'SpreadElement',
-    'CallExpression',
-    'Identifier',
-    'NewExpression',
-];
-
-const isSimpleType = ({type}) => SIMPLE_TYPES.includes(type);
-
-export const isObjectAfterSimple = createTypeChecker([
-    ['-: -> !', isNextObject],
-    ['+', isSimpleType],
-]);