@putout/printer 18.2.9 → 18.2.11

package/ChangeLog

@@ -1,3 +1,16 @@
+2026.03.08, v18.2.11
+
+feature:
+- b16bb59 @putout/printer: ArrayExpression: newline: isNewlineAfterComma
+- 5f0e329 @putout/printer: @putout/plugin-minify v12.0.0
+
+2026.03.08, v18.2.10
+
+feature:
+- 7a73310 @putout/printer: ArrayExpresison: maybeSecondIndent
+- cfcf1ce @putout/printer: ArrayExpression: isSecondIndent
+- 0acb26a @putout/printer: ArrayExpression: isSecondIndent
+
 2026.03.08, v18.2.9
 
 feature:

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

@@ -4,22 +4,19 @@ import {
     isCoupleLines,
     isStringAndIdentifier,
     isIdentifierAndIdentifier,
-    isStringAndArray,
     isSimpleAndNotEmptyObject,
-    isNextObject,
     callWithNext,
-    isInsideArray,
     callWithPrev,
 } from '#is';
 import {
     isCurrentNewLine,
     isMultiLine,
+    isNewlineAfterComma,
 } from './newline.js';
 import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
-    isArrayInsideArray,
-    isHideIndent,
     isNeedIndent,
+    maybeSecondIndent,
 } from './indent.js';
 import {
     beforeIf,
@@ -30,35 +27,9 @@ const {
     isObjectExpression,
     isSpreadElement,
     isIdentifier,
-    isFunction,
     isCallExpression,
-    isObjectProperty,
 } = types;
 
-const isSpreadBeforeObject = (a) => {
-    if (!a.isObjectExpression())
-        return false;
-    
-    const prev = a.getPrevSibling();
-    
-    if (!prev.isSpreadElement())
-        return false;
-    
-    const argCall = prev.get('argument');
-    
-    if (argCall.isCallExpression()) {
-        const [first] = argCall.get('arguments');
-        
-        if (isFunction(first))
-            return false;
-    }
-    
-    if (prev.getPrevSibling().isObjectExpression())
-        return false;
-    
-    return prev.get('argument').isCallExpression();
-};
-
 const isSimpleBetweenObjects = createTypeChecker([
     ['+', callWithNext(isObjectExpression)],
     ['-', isSpreadElement],
@@ -76,7 +47,9 @@ export const ArrayExpression = {
     before(path, {print}) {
         print.breakline();
     },
-    print(path, {print, maybe}, semantics) {
+    print(path, printer, semantics) {
+        const {print, maybe} = printer;
+        
         const {
             maxElementsInOneLine,
             trailingComma,
@@ -113,30 +86,21 @@ export const ArrayExpression = {
             if (index < n || trailingComma)
                 maybe.print(is, ',');
             
-            if (!(isObjectExpression(element) && isObjectProperty(path.parentPath)))
-                maybe.print.newline((is || isSpreadBeforeObject(element)) && !isNextObject(element) && !isObjectExpression(element));
+            if (is && isNewlineAfterComma(element))
+                print.newline();
             
             maybe.print.space(is && isObjectAfterSimple(element));
             
             if (!is && index < n) {
                 print(',');
-                
-                if (isSpaceAfterComa(element))
-                    print.space();
+                maybe.print.space(isSpaceAfterComa(element));
             }
         }
         
         maybe.indent.dec(needIndent);
-        
-        if (isInsideArray(path) && isStringAndArray(path.parentPath)) {
-            const needsToHideIndent = isHideIndent(path);
-            
-            maybe.indent.dec(needsToHideIndent);
-            maybe.indent(needsNewline);
-            maybe.indent.inc(needsToHideIndent);
-        } else if (!isArrayInsideArray(path) && !isObjectExpression(elements.at(-1))) {
-            maybe.indent(needsNewline);
-        }
+        maybeSecondIndent(path, printer, semantics, {
+            needsNewline,
+        });
         
         if (isSimpleAndNotEmptyObject(path) && !isSpreadElement(elements.at(-1)) && !isCallExpression(elements.at(-1))) {
             print(',');

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

@@ -1,6 +1,10 @@
 import {types} from '@putout/babel';
-import {isInsideArray, isInsideCall} from '#is';
 import {createTypeChecker} from '#type-checker';
+import {
+    isInsideArray,
+    isInsideCall,
+    isStringAndArray,
+} from '#is';
 
 const isTwoLongStrings = (path) => {
     const [a, b] = path.node.elements;
@@ -93,5 +97,36 @@ export function isArrayInsideArray(path) {
 const isTwo = (a) => a === 2;
 
 export const isHideIndent = createTypeChecker([
+    ['-: -> !', isInsideArray],
+    ['-: parentPath -> !', isStringAndArray],
     ['+: parentPath.node.elements.length', isTwo],
 ]);
+
+const isLastElementObjectExpression = ({node}) => isObjectExpression(node.elements.at(-1));
+
+const isNeedsNewlineOption = (a, {needsNewline}) => needsNewline;
+const isNeedsToHideIndentOption = (a, {needsToHideIndent}) => needsToHideIndent;
+
+export const isSecondIndent = createTypeChecker([
+    ['-: -> !', isNeedsNewlineOption],
+    ['+', isNeedsToHideIndentOption],
+    ['-: ->', isArrayInsideArray],
+    ['+: -> !', isLastElementObjectExpression],
+]);
+
+export function maybeSecondIndent(path, printer, semantics, options) {
+    const {maybe, indent} = printer;
+    const {needsNewline} = options;
+    const needsToHideIndent = isHideIndent(path);
+    
+    const needsToMakeSecondIndent = isSecondIndent(path, {
+        needsNewline,
+        needsToHideIndent,
+    });
+    
+    if (needsToMakeSecondIndent) {
+        maybe.indent.dec(needsToHideIndent);
+        indent();
+        maybe.indent.inc(needsToHideIndent);
+    }
+}

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

@@ -11,6 +11,7 @@ import {
     isSimpleAndNotEmptyObject,
     isInsideCall,
     isInsideArray,
+    isNextObject,
 } from '#is';
 import {isIncreaseIndent} from './indent.js';
 
@@ -309,3 +310,8 @@ export const isCurrentNewLine = createTypeChecker([
     '+: -> SpreadElement',
     '+: -> !ObjectExpression',
 ]);
+
+export const isNewlineAfterComma = createTypeChecker([
+    ['-', isNextObject],
+    ['+: -> !', isObjectExpression],
+]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.2.9",
+  "version": "18.2.11",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -74,7 +74,6 @@
     "@babel/parser": "^7.28.5",
     "@putout/eslint": "^6.0.0",
     "@putout/eslint-flat": "^4.0.0",
-    "@putout/plugin-minify": "^11.2.1",
     "@putout/plugin-printer": "^8.0.0",
     "@putout/plugin-promises": "^19.0.0",
     "@putout/plugin-react-hook-form": "^6.0.0",