@putout/printer 18.2.5 → 18.2.7

package/ChangeLog

@@ -1,3 +1,16 @@
+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:
+- 9363494 @putout/printer: ArrayExpression: isObjectAfterSimple: type-check
+- 463944a @putout/printer: ArrayExpression: isZero -> !Boolean
+
 2026.03.07, v18.2.5
 
 fix:

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

@@ -12,13 +12,13 @@ import {
     callWithPrev,
 } from '#is';
 import {
-    isIncreaseIndent,
     isCurrentNewLine,
     isMultiLine,
 } from './newline.js';
 import {
     isArrayInsideArray,
-    isArrayIndented,
+    isIncreaseIndent,
+    isIndentElement,
 } from './indent.js';
 import {isObjectAfterSimple} from './is-object-after-simple.js';
 import {
@@ -93,7 +93,7 @@ export const ArrayExpression = {
         
         print('[');
         
-        const indented = isArrayIndented(path);
+        const indented = isIndentElement(path);
         
         maybe.indent.inc(indented && shouldIncreaseIndent);
         

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,21 @@ 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 isIndentElement = createTypeChecker([
+    ['-', isArrayInsideArray],
+    ['-', isObjectAfterString],
+    ['+: -> !', isTwoLongStrings],
+    ['+: -> !', isInsideArray],
+]);
+
+export const isIncreaseIndent = createTypeChecker([
+    ['-: node.elements.length -> !', Boolean],
+    ['+', isBooleanAndObject],
+    ['-', isInsideCallLoop],
+    ['+: node.elements.0 -> ObjectExpression'],
+    ['-: node.elements.1 -> SpreadElement'],
+    ['+', isStringAndObject],
+]);
 
 export function isArrayInsideArray(path) {
     if (!path.isArrayExpression() || !path.parentPath.isArrayExpression())
@@ -51,11 +85,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/is-object-after-simple.js

@@ -1,4 +1,5 @@
-import {isNextObject, isPrevObject} from '#is';
+import {isNextObject} from '#is';
+import {createTypeChecker} from '#type-checker';
 
 const SIMPLE_TYPES = [
     'ArrayExpression',
@@ -9,11 +10,9 @@ const SIMPLE_TYPES = [
     'NewExpression',
 ];
 
-export const isObjectAfterSimple = (a) => {
-    const {type} = a;
-    
-    if (!isNextObject(a) || isPrevObject(a))
-        return false;
-    
-    return SIMPLE_TYPES.includes(type);
-};
+const isSimpleType = ({type}) => SIMPLE_TYPES.includes(type);
+
+export const isObjectAfterSimple = createTypeChecker([
+    ['-: -> !', isNextObject],
+    ['+', isSimpleType],
+]);

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

@@ -12,8 +12,7 @@ import {
     isInsideCall,
     isInsideArray,
 } from '#is';
-
-const isZero = (length) => !length;
+import {isIncreaseIndent} from './indent.js';
 
 const isParentProperty = (path) => path.find(isObjectProperty);
 
@@ -113,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;
@@ -203,7 +200,7 @@ const isBodyWithOneElement = createTypeChecker([
 ]);
 
 export const isMultiLine = createTypeChecker([
-    ['-: node.elements.length', isZero],
+    ['-: node.elements.length -> !', Boolean],
     ['+', isBodyWithOneElement],
     ['+', isMoreThenMaxElementLengthInOneLine],
     ['+', isElementsMoreThenMaxWithFirstString],
@@ -308,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

@@ -65,10 +65,6 @@ export const isNextObject = (a) => a
     .getNextSibling()
     .isObjectExpression();
 
-export const isPrevObject = (a) => a
-    .getPrevSibling()
-    .isObjectExpression();
-
 export const isFirst = (path) => path.node === path.parentPath.node.body?.[0];
 export const isPrevBody = (path) => path
     .getPrevSibling()
@@ -76,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.5",
+  "version": "18.2.7",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",