@putout/printer 17.0.8 → 17.2.0

package/ChangeLog

@@ -1,3 +1,15 @@
+2026.02.11, v17.2.0
+
+feature:
+- 7cb116c @putout/printer: ArrayExpression: ObjectExpression, after StringLiteral/TemplateLiteral: indent
+- 7a5f660 @putout/printer: eslint v10.0.0
+
+2026.02.01, v17.1.0
+
+feature:
+- df72e84 @putout/printer: ObjectPattern: split to couple files
+- 3dba268 @putout/printer: ObjectPattern: couple assigns
+
 2026.01.28, v17.0.8
 
 feature:

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

@@ -4,10 +4,25 @@ import {isIndented} from '#is';
 const {
     isStringLiteral,
     isArrayExpression,
+    isObjectExpression,
+    isTemplateLiteral,
 } = types;
 
 export const isInsideArray = (path) => path.parentPath.isArrayExpression();
 
+const isObjectAfterString = ([first, second]) => {
+    if (!first || !second)
+        return false;
+    
+    if (!isObjectExpression(second))
+        return false;
+    
+    if (isStringLiteral(first))
+        return true;
+    
+    return isTemplateLiteral(first);
+};
+
 export const isArrayIndented = (path) => {
     const elements = path.get('elements');
     
@@ -16,6 +31,9 @@ export const isArrayIndented = (path) => {
     
     const [first] = elements;
     
+    if (isObjectAfterString(elements))
+        return false;
+    
     return !isTwoLongStrings(elements) || !isInsideArray(path) && isIndented(first);
 };
 

package/lib/tokenize/expressions/object-pattern/has.js

@@ -0,0 +1,51 @@
+import {types} from '@putout/babel';
+
+const {
+    isAssignmentPattern,
+    isObjectPattern,
+    isVariableDeclaration,
+    isObjectExpression,
+} = types;
+
+export function hasObjectPattern(properties) {
+    for (const property of properties) {
+        if (isObjectPattern(property.node.value))
+            return true;
+    }
+    
+    return false;
+}
+
+export function hasAssign(properties) {
+    for (const prop of properties) {
+        const {value} = prop.node;
+        
+        if (isAssignmentPattern(value))
+            return true;
+    }
+    
+    return false;
+}
+
+export function hasAssignObject(path, maxPropertiesLengthInOneLine) {
+    const {parentPath} = path;
+    
+    if (isVariableDeclaration(parentPath.parentPath)) {
+        const {declarations} = parentPath.parentPath.node;
+        
+        if (declarations.length > 1)
+            return false;
+    }
+    
+    const properties = path.get('properties');
+    const n = properties.length;
+    
+    for (const prop of properties) {
+        const {value} = prop.node;
+        
+        if (isAssignmentPattern(value) && isObjectExpression(value.right))
+            return n > 1 || maxPropertiesLengthInOneLine <= value.left;
+    }
+    
+    return false;
+}

package/lib/tokenize/expressions/object-pattern/is.js

@@ -0,0 +1,74 @@
+import {types} from '@putout/babel';
+import {isCoupleLines, exists} from '#is';
+import {hasAssign} from './has.js';
+
+const {
+    isObjectExpression,
+    isAssignmentPattern,
+    isForOfStatement,
+    isFunction,
+    isVariableDeclarator,
+    isObjectProperty,
+} = types;
+
+export const isInsideFn = (path) => {
+    if (isFunction(path.parentPath))
+        return true;
+    
+    return isFunction(path.parentPath.parentPath);
+};
+
+export function isIndent(path) {
+    return !path.parentPath.isArrayPattern();
+}
+
+export const isCoupleProperties = ({path, valuePath, property}) => {
+    if (!isCoupleLines(valuePath))
+        return false;
+    
+    if (exists(property.getPrevSibling()))
+        return false;
+    
+    const properties = path.get('properties');
+    const {parentPath} = path;
+    
+    if (isVariableDeclarator(parentPath) && !hasAssign(properties))
+        return false;
+    
+    return !isObjectProperty(parentPath);
+};
+
+export function isInsideForOf({parentPath}) {
+    return isForOfStatement(parentPath.parentPath.parentPath);
+}
+
+export function isPrevAssign(path) {
+    const prev = path.getPrevSibling();
+    
+    return isAssignmentPattern(prev.node.value);
+}
+
+export function isPrevAssignObject(path) {
+    const prev = path.getPrevSibling();
+    
+    if (!isAssignmentPattern(prev.node.value))
+        return false;
+    
+    const {right} = prev.node.value;
+    
+    return isObjectExpression(right);
+}
+
+export function isNextAssignObject(path) {
+    const next = path.getNextSibling();
+    
+    if (!next.node)
+        return false;
+    
+    if (!isAssignmentPattern(next.node.value))
+        return false;
+    
+    const {right} = next.node.value;
+    
+    return isObjectExpression(right);
+}

package/lib/tokenize/expressions/object-pattern/object-pattern.js

@@ -1,91 +1,28 @@
 import {types} from '@putout/babel';
-import {
-    isForOf,
-    isCoupleLines,
-    exists,
-} from '#is';
 import {wrongShorthand} from './wrong-shorthand.js';
-import {moreThenMaxPropertiesInOneLine} from './more-then-max-properties-in-one-line.js';
 import {maybeTypeAnnotation} from '../../maybe/maybe-type-annotation.js';
-import {moreThenMaxPropertiesLengthInOneLine} from './more-then-max-properties-length-in-one-line.js';
 import {printKey} from '../object-expression/print-key.js';
 import {
     calculateAssigns,
     isLongAssignPattern,
 } from './calculate-long-assign-pattern.js';
 import {printLeadingComments} from './comments.js';
+import {shouldAddNewline} from './should-add-new-line.js';
+import {
+    hasAssignObject,
+    hasObjectPattern,
+} from './has.js';
+import {
+    isCoupleProperties,
+    isIndent,
+    isInsideFn,
+    isInsideForOf,
+    isNextAssignObject,
+    isPrevAssign,
+    isPrevAssignObject,
+} from './is.js';
 
-const {
-    isObjectExpression,
-    isIdentifier,
-    isAssignmentPattern,
-    isVariableDeclarator,
-    isFunction,
-    isObjectPattern,
-    isForOfStatement,
-    isVariableDeclaration,
-} = types;
-
-const isInsideFn = (path) => {
-    if (isFunction(path.parentPath))
-        return true;
-    
-    return isFunction(path.parentPath.parentPath);
-};
-
-function isIndent(path) {
-    return !path.parentPath.isArrayPattern();
-}
-
-const isCoupleProperties = ({path, valuePath, property}) => {
-    if (!isCoupleLines(valuePath))
-        return false;
-    
-    if (exists(property.getPrevSibling()))
-        return false;
-    
-    const properties = path.get('properties');
-    
-    if (path.parentPath.isVariableDeclarator() && !hasAssign(properties))
-        return false;
-    
-    return !path.parentPath.isObjectProperty();
-};
-
-function isInsideForOf({parentPath}) {
-    return isForOfStatement(parentPath.parentPath.parentPath);
-}
-
-function isPrevAssign(path) {
-    const prev = path.getPrevSibling();
-    
-    return isAssignmentPattern(prev.node.value);
-}
-
-function isPrevAssignObject(path) {
-    const prev = path.getPrevSibling();
-    
-    if (!isAssignmentPattern(prev.node.value))
-        return false;
-    
-    const {right} = prev.node.value;
-    
-    return isObjectExpression(right);
-}
-
-function isNextAssignObject(path) {
-    const next = path.getNextSibling();
-    
-    if (!next.node)
-        return false;
-    
-    if (!isAssignmentPattern(next.node.value))
-        return false;
-    
-    const {right} = next.node.value;
-    
-    return isObjectExpression(right);
-}
+const {isObjectExpression} = types;
 
 export const ObjectPattern = {
     print: maybeTypeAnnotation((path, printer, semantics) => {
@@ -142,6 +79,7 @@ export const ObjectPattern = {
             });
             
             maybe.indent((prevAssignObject || is) && notInsideFn);
+            
             maybe.print.breakline(couple && !isLongAssignPattern(property, semantics));
             
             if (!isAssign && nextAssignObject)
@@ -199,134 +137,3 @@ export const ObjectPattern = {
         print('}');
     }),
 };
-
-function checkLength(properties) {
-    for (const prop of properties) {
-        const {value} = prop.node;
-        
-        if (!isIdentifier(value))
-            continue;
-        
-        if (value.name.length > 4)
-            return true;
-    }
-    
-    return false;
-}
-
-function hasAssign(properties) {
-    for (const prop of properties) {
-        const {value} = prop.node;
-        
-        if (isAssignmentPattern(value))
-            return true;
-    }
-    
-    return false;
-}
-
-function hasComputed(properties) {
-    for (const prop of properties) {
-        const {computed} = prop.node;
-        
-        if (computed)
-            return true;
-    }
-    
-    return false;
-}
-
-function hasAssignObject(path, maxPropertiesLengthInOneLine) {
-    const {parentPath} = path;
-    
-    if (isVariableDeclaration(parentPath.parentPath)) {
-        const {declarations} = parentPath.parentPath.node;
-        
-        if (declarations.length > 1)
-            return false;
-    }
-    
-    const properties = path.get('properties');
-    const n = properties.length;
-    
-    for (const prop of properties) {
-        const {value} = prop.node;
-        
-        if (isAssignmentPattern(value) && isObjectExpression(value.right))
-            return n > 1 || maxPropertiesLengthInOneLine <= value.left;
-    }
-    
-    return false;
-}
-
-function hasObjectPattern(properties) {
-    for (const property of properties) {
-        if (isObjectPattern(property.node.value))
-            return true;
-    }
-    
-    return false;
-}
-
-const ONE_LINE = false;
-const COUPLE_LINES = true;
-
-function hasPropertyLeadingComment(properties) {
-    for (const property of properties) {
-        if (property.node.leadingComments)
-            return true;
-    }
-    
-    return false;
-}
-
-function shouldAddNewline(path, semantics) {
-    const {parentPath} = path;
-    const properties = path.get('properties');
-    const n = properties.length - 1;
-    
-    if (hasPropertyLeadingComment(properties))
-        return true;
-    
-    const {
-        maxPropertiesInOneLine,
-        maxPropertiesLengthInOneLine,
-    } = semantics;
-    
-    const moreLength = moreThenMaxPropertiesLengthInOneLine(path, {
-        maxPropertiesLengthInOneLine,
-    });
-    
-    const moreCount = moreThenMaxPropertiesInOneLine(path, {
-        maxPropertiesInOneLine,
-    });
-    
-    if (hasComputed(properties))
-        return COUPLE_LINES;
-    
-    const fnParam = isFunctionParam(path);
-    
-    if (hasObjectPattern(properties))
-        return COUPLE_LINES;
-    
-    if (moreCount && !moreLength && isVariableDeclarator(path.parentPath))
-        return ONE_LINE;
-    
-    if (!fnParam && n && !isForOf(path) && checkLength(properties))
-        return COUPLE_LINES;
-    
-    if (!fnParam && hasAssign(properties))
-        return COUPLE_LINES;
-    
-    return parentPath.isObjectProperty();
-}
-
-function isFunctionParam({parentPath}) {
-    if (parentPath.isFunction())
-        return true;
-    
-    if (!parentPath.isAssignmentPattern())
-        return false;
-    
-    return parentPath.parentPath.isFunction();
-}

package/lib/tokenize/expressions/object-pattern/should-add-new-line.js

@@ -0,0 +1,123 @@
+import {types} from '@putout/babel';
+import {isForOf} from '#is';
+import {moreThenMaxPropertiesInOneLine} from './more-then-max-properties-in-one-line.js';
+import {moreThenMaxPropertiesLengthInOneLine} from './more-then-max-properties-length-in-one-line.js';
+import {
+    hasAssign,
+    hasObjectPattern,
+} from './has.js';
+
+const {
+    isIdentifier,
+    isAssignmentPattern,
+    isVariableDeclarator,
+    isObjectProperty,
+} = types;
+
+const ONE_LINE = false;
+const COUPLE_LINES = true;
+
+function hasPropertyLeadingComment(properties) {
+    for (const property of properties) {
+        if (property.node.leadingComments)
+            return true;
+    }
+    
+    return false;
+}
+
+function isFunctionParam({parentPath}) {
+    if (parentPath.isFunction())
+        return true;
+    
+    if (!parentPath.isAssignmentPattern())
+        return false;
+    
+    return parentPath.parentPath.isFunction();
+}
+
+export function shouldAddNewline(path, semantics) {
+    const {parentPath} = path;
+    const properties = path.get('properties');
+    const n = properties.length - 1;
+    
+    if (isCoupleAssigns(path))
+        return COUPLE_LINES;
+    
+    if (hasPropertyLeadingComment(properties))
+        return COUPLE_LINES;
+    
+    const {
+        maxPropertiesInOneLine,
+        maxPropertiesLengthInOneLine,
+    } = semantics;
+    
+    const moreLength = moreThenMaxPropertiesLengthInOneLine(path, {
+        maxPropertiesLengthInOneLine,
+    });
+    
+    const moreCount = moreThenMaxPropertiesInOneLine(path, {
+        maxPropertiesInOneLine,
+    });
+    
+    if (hasComputed(properties))
+        return COUPLE_LINES;
+    
+    const fnParam = isFunctionParam(path);
+    
+    if (hasObjectPattern(properties))
+        return COUPLE_LINES;
+    
+    if (moreCount && !moreLength && isVariableDeclarator(path.parentPath))
+        return ONE_LINE;
+    
+    if (!fnParam && n && !isForOf(path) && checkLength(properties))
+        return COUPLE_LINES;
+    
+    if (!fnParam && hasAssign(properties))
+        return COUPLE_LINES;
+    
+    return parentPath.isObjectProperty();
+}
+
+function isCoupleAssigns(path) {
+    if (isFunctionParam(path))
+        return false;
+    
+    let assignsCount = 0;
+    
+    for (const property of path.node.properties) {
+        if (!isObjectProperty(property))
+            continue;
+        
+        if (isAssignmentPattern(property.value))
+            ++assignsCount;
+    }
+    
+    return assignsCount > 1;
+}
+
+function checkLength(properties) {
+    for (const prop of properties) {
+        const {value} = prop.node;
+        
+        if (!isIdentifier(value))
+            continue;
+        
+        if (value.name.length > 4)
+            return true;
+    }
+    
+    return false;
+}
+
+function hasComputed(properties) {
+    for (const prop of properties) {
+        const {computed} = prop.node;
+        
+        if (computed)
+            return true;
+    }
+    
+    return false;
+}

package/lib/tokenize/literals/string-literal.js

@@ -32,18 +32,18 @@ const maybeEscape = (value, {escapeDoubleQuote, escapeSingleQuote}) => {
 };
 
 const escape = (list, {slash, quote}) => {
-    const res = [];
+    const result = [];
     
     for (const [index, char] of list.entries()) {
         const prev = list[index - 1];
         
         if (char === quote && prev !== slash) {
-            res.push(`${slash}${char}`);
+            result.push(`${slash}${char}`);
             continue;
         }
         
-        res.push(char);
+        result.push(char);
     }
     
-    return res.join('');
+    return result.join('');
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "17.0.8",
+  "version": "17.2.0",
   "type": "module",
   "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
   "description": "Simplest possible opinionated Babel AST printer for 🐊Putout",
@@ -72,7 +72,7 @@
     "c8": "^10.1.2",
     "check-dts": "^0.9.0",
     "escover": "^5.0.0",
-    "eslint": "^9.0.0",
+    "eslint": "^10.0.0",
     "eslint-plugin-putout": "^30.0.0",
     "estree-to-babel": "^12.0.0",
     "goldstein": "^7.0.0",