@putout/printer 18.2.6 → 18.2.8

package/ChangeLog

@@ -1,3 +1,15 @@
+2026.03.08, v18.2.8
+
+feature:
+- 39d5af8 @putout/printer: ArrayExpression: isNeedIndent
+
+2026.03.08, v18.2.7
+
+feature:
+- c873574 @putout/printer: isIncreaseIndent: move out: newlinew -> indent
+- d3672b6 @putout/printer: ArrayExpression: newline: isIncreaseIndent
+- 642c80f @putout/printer: ArrayExpression: indent: isArrayIndented: type-check
+
 2026.03.08, v18.2.6
 
 feature:

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

@@ -12,15 +12,14 @@ import {
     callWithPrev,
 } from '#is';
 import {
-    isIncreaseIndent,
     isCurrentNewLine,
     isMultiLine,
 } from './newline.js';
+import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
     isArrayInsideArray,
-    isArrayIndented,
+    isNeedIndent,
 } from './indent.js';
-import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
     beforeIf,
     isInsideOneElementArray,
@@ -89,13 +88,12 @@ export const ArrayExpression = {
         } = semantics;
         
         const elements = path.get('elements');
-        const shouldIncreaseIndent = !isIncreaseIndent(path);
         
         print('[');
         
-        const indented = isArrayIndented(path);
+        const needIndent = isNeedIndent(path);
         
-        maybe.indent.inc(indented && shouldIncreaseIndent);
+        maybe.indent.inc(needIndent);
         
         const needsNewline = isMultiLine(path, {
             maxElementsInOneLine,
@@ -132,7 +130,7 @@ export const ArrayExpression = {
             }
         }
         
-        maybe.indent.dec(indented && shouldIncreaseIndent);
+        maybe.indent.dec(needIndent);
         
         const parentElements = path.parentPath.get('elements');
         

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

@@ -1,14 +1,46 @@
 import {types} from '@putout/babel';
-import {isIndented, isInsideArray} from '#is';
+import {isInsideArray, isInsideCall} from '#is';
+import {createTypeChecker} from '#type-checker';
+
+const isTwoLongStrings = (path) => {
+    const [a, b] = path.node.elements;
+    const LONG_STRING = 20;
+    
+    if (!isStringLiteral(a) || !isStringLiteral(b))
+        return false;
+    
+    return a.value.length > LONG_STRING;
+};
 
 const {
     isStringLiteral,
     isArrayExpression,
     isObjectExpression,
     isTemplateLiteral,
+    isBooleanLiteral,
 } = types;
 
-const isObjectAfterString = ([first, second]) => {
+const isInsideCallLoop = createTypeChecker([
+    ['-: -> !', isInsideCall],
+    ['+: parentPath.parentPath -> ForOfStatement'],
+]);
+
+const isStringAndObject = (path) => {
+    const {elements} = path.node;
+    const first = elements.at(0);
+    const last = elements.at(-1);
+    
+    return isStringLiteral(first) && isObjectExpression(last);
+};
+
+const isBooleanAndObject = (path) => {
+    const [a, b] = path.node.elements;
+    return isBooleanLiteral(a) && isObjectExpression(b);
+};
+
+const isObjectAfterString = (path) => {
+    const [first, second] = path.node.elements;
+    
     if (!first || !second)
         return false;
     
@@ -21,19 +53,26 @@ const isObjectAfterString = ([first, second]) => {
     return isTemplateLiteral(first);
 };
 
-export const isArrayIndented = (path) => {
-    const elements = path.get('elements');
-    
-    if (isArrayInsideArray(path))
-        return false;
-    
-    const [first] = elements;
-    
-    if (isObjectAfterString(elements))
-        return false;
-    
-    return !isTwoLongStrings(elements) || !isInsideArray(path) && isIndented(first);
-};
+export const isIncreaseIndent = createTypeChecker([
+    ['-: node.elements.length -> !', Boolean],
+    ['+', isBooleanAndObject],
+    ['-', isInsideCallLoop],
+    ['+: node.elements.0 -> ObjectExpression'],
+    ['-: node.elements.1 -> SpreadElement'],
+    ['+', isStringAndObject],
+]);
+
+export const isIndentElement = createTypeChecker([
+    ['-', isArrayInsideArray],
+    ['-', isObjectAfterString],
+    ['+: -> !', isTwoLongStrings],
+    ['+: -> !', isInsideArray],
+]);
+
+export const isNeedIndent = createTypeChecker([
+    ['-: -> !', isIndentElement],
+    ['+: -> !', isIncreaseIndent],
+]);
 
 export function isArrayInsideArray(path) {
     if (!path.isArrayExpression() || !path.parentPath.isArrayExpression())
@@ -50,12 +89,3 @@ export function isArrayInsideArray(path) {
     
     return length <= 3 && length !== 1;
 }
-
-const isTwoLongStrings = ([a, b]) => {
-    const LONG_STRING = 20;
-    
-    if (!isStringLiteral(a) || !isStringLiteral(b))
-        return false;
-    
-    return a.node.value.length > LONG_STRING;
-};

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

@@ -12,6 +12,7 @@ import {
     isInsideCall,
     isInsideArray,
 } from '#is';
+import {isIncreaseIndent} from './indent.js';
 
 const isParentProperty = (path) => path.find(isObjectProperty);
 
@@ -111,8 +112,6 @@ const isBooleanAndSimple = (path) => {
     return isBooleanLiteral(a) && isSimple(b);
 };
 
-const isBooleanAndObject = ([a, b]) => isBooleanLiteral(a) && isObjectExpression(b);
-
 const isNullAndSimple = (path) => {
     const {elements} = path.node;
     const [a, b] = elements;
@@ -306,39 +305,6 @@ function isNumbers(elements) {
     return false;
 }
 
-export function isIncreaseIndent(path) {
-    const elements = path.get('elements');
-    
-    if (!elements.length)
-        return false;
-    
-    if (isBooleanAndObject(elements))
-        return true;
-    
-    if (isInsideCallLoop(path))
-        return false;
-    
-    if (elements[0].isObjectExpression())
-        return true;
-    
-    if (isSpreadElement(elements[1]))
-        return false;
-    
-    return isStringAndObject(elements);
-}
-
-const isInsideCallLoop = createTypeChecker([
-    ['-: -> !', isInsideCall],
-    ['+: parentPath.parentPath -> ForOfStatement'],
-]);
-
-const isStringAndObject = (elements) => {
-    const first = elements.at(0);
-    const last = elements.at(-1);
-    
-    return isStringLiteral(first) && isObjectExpression(last);
-};
-
 export const isCurrentNewLine = createTypeChecker([
     '+: -> SpreadElement',
     '+: -> !ObjectExpression',

package/lib/tokenize/is.js

@@ -72,15 +72,6 @@ export const isPrevBody = (path) => path
 
 export const isParentLast = (path) => isLast(path.parentPath);
 
-export const isIndented = (path = {}) => {
-    const {parentPath, node} = path;
-    
-    if (!parentPath.node.loc)
-        return true;
-    
-    return node.loc?.start.column !== parentPath.node.loc.start.column;
-};
-
 export function isCoupleLines(path) {
     const start = path.node?.loc?.start?.line;
     const end = path.node?.loc?.end?.line;

package/package.json

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