@putout/printer 18.8.2 → 18.8.3

package/ChangeLog

@@ -1,3 +1,11 @@
+2026.03.20, v18.8.3
+
+feature:
+- 527b8425 @putout/printer: ObjectPattern: shouldAddNewline: simplify
+- 0332d176 @putout/printer: ObjectPattern: isFunctionParam
+- 3eadc072 @putout/printer: ObjectPattern: isLessThenMaxPropertiesInOneLine
+- 63c73f94 @putout/printer: ObjectPattern: hasAssignObject: simplify
+
 2026.03.19, v18.8.2
 
 feature:

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

@@ -3,23 +3,20 @@ 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))
+export function hasObjectPattern(path) {
+    for (const {value} of path.node.properties) {
+        if (isObjectPattern(value))
             return true;
     }
     
     return false;
 }
 
-export function hasAssign(properties) {
-    for (const prop of properties) {
-        const {value} = prop.node;
-        
+export function hasAssign(path) {
+    for (const {value} of path.node.properties) {
         if (isAssignmentPattern(value))
             return true;
     }
@@ -28,15 +25,6 @@ export function hasAssign(properties) {
 }
 
 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;
     

package/lib/tokenize/expressions/object-pattern/is-less-then-max-properties-in-one-line.js

@@ -0,0 +1,7 @@
+import {createTypeChecker} from '#type-checker';
+
+const getMaxPropertiesInOneLine = (a, {maxPropertiesInOneLine}) => maxPropertiesInOneLine;
+
+export const isLessThenMaxPropertiesInOneLine = createTypeChecker([
+    ['+: node.properties.length', '<=', getMaxPropertiesInOneLine],
+]);

package/lib/tokenize/expressions/object-pattern/{more-then-max-properties-length-in-one-line.js → is-more-then-max-properties-length-in-one-line.js}

@@ -9,13 +9,10 @@ function getLength(left, right) {
     if (isIdentifier(left) && isIdentifier(right))
         return left.name.length + right.name.length;
     
-    if (isIdentifier(left))
-        return left.name.length;
-    
-    return 0;
+    return left.name.length;
 }
 
-export const moreThenMaxPropertiesLengthInOneLine = (path, {maxPropertiesLengthInOneLine}) => {
+export const isMoreThenMaxPropertiesLengthInOneLine = (path, {maxPropertiesLengthInOneLine}) => {
     const {properties} = path.node;
     
     for (const {key, value} of properties) {

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

@@ -34,10 +34,9 @@ export const isCoupleProperties = ({path, valuePath, property}) => {
     if (exists(property.getPrevSibling()))
         return false;
     
-    const properties = path.get('properties');
     const {parentPath} = path;
     
-    if (isVariableDeclarator(parentPath) && !hasAssign(properties))
+    if (isVariableDeclarator(parentPath) && !hasAssign(path))
         return false;
     
     return !isObjectProperty(parentPath);

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

@@ -47,7 +47,7 @@ export const ObjectPattern = {
             maxPropertiesLengthInOneLine,
         });
         
-        const hasObject = n && hasObjectPattern(properties);
+        const hasObject = n && hasObjectPattern(path);
         const notInsideFn = !isInsideFn(path);
         
         maybe.print.newline(is && notInsideFn);

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

@@ -1,84 +1,66 @@
 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 {callWithParent, isForOf} from '#is';
+import {createTypeChecker} from '#type-checker';
+import {isLessThenMaxPropertiesInOneLine} from './is-less-then-max-properties-in-one-line.js';
+import {isMoreThenMaxPropertiesLengthInOneLine} from './is-more-then-max-properties-length-in-one-line.js';
 import {
     hasAssign,
     hasObjectPattern,
 } from './has.js';
 
+const isMoreCountLessLength = createTypeChecker([
+    ['-: -> !', isLessThenMaxPropertiesInOneLine],
+    ['-', isMoreThenMaxPropertiesLengthInOneLine],
+    ['+: parentPath -> VariableDeclarator'],
+]);
+
 const {
     isIdentifier,
     isAssignmentPattern,
-    isVariableDeclarator,
     isObjectProperty,
+    isFunction,
 } = types;
 
-const ONE_LINE = false;
-const COUPLE_LINES = true;
-
-function hasPropertyLeadingComment(properties) {
-    for (const property of properties) {
-        if (property.node.leadingComments)
+function hasPropertyLeadingComment(path) {
+    for (const property of path.node.properties) {
+        if (property.leadingComments)
             return true;
     }
     
     return false;
 }
 
-function isFunctionParam({parentPath}) {
-    if (parentPath.isFunction())
-        return true;
-    
-    if (!parentPath.isAssignmentPattern())
-        return false;
-    
-    return parentPath.parentPath.isFunction();
-}
+const cutOptions = (fn) => (a) => fn(a);
+const isFunctionLike = cutOptions(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();
-}
+const isFunctionParam = callWithParent(createTypeChecker([
+    ['+', isFunctionLike],
+    ['-: -> !AssignmentPattern'],
+    ['+: parentPath', isFunctionLike],
+]));
+
+const isOneOfIdentifiersHasMoreLength = createTypeChecker([
+    ['-', isFunctionParam],
+    ['-', isForOf],
+    ['-: node.properties.length', '=', 1],
+    ['+', checkLength],
+]);
+
+const hasAssignNotFunctionParam = createTypeChecker([
+    ['-', isFunctionParam],
+    ['+', hasAssign],
+]);
+
+export const shouldAddNewline = createTypeChecker([
+    ['+', isCoupleAssigns],
+    ['+', hasPropertyLeadingComment],
+    ['+', hasComputed],
+    ['+', hasObjectPattern],
+    ['-', isMoreCountLessLength],
+    ['+', hasAssignNotFunctionParam],
+    ['+', isOneOfIdentifiersHasMoreLength],
+    ['+: parentPath -> ObjectProperty'],
+]);
 
 function isCoupleAssigns(path) {
     if (isFunctionParam(path))
@@ -97,13 +79,16 @@ function isCoupleAssigns(path) {
     return assignsCount > 1;
 }
 
-function checkLength(properties) {
-    for (const prop of properties) {
-        const {value} = prop.node;
-        
-        if (!isIdentifier(value))
-            continue;
-        
+const getValue = (a) => a.value;
+
+function checkLength(path) {
+    const identifiers = path
+        .node
+        .properties
+        .map(getValue)
+        .filter(isIdentifier);
+    
+    for (const value of identifiers) {
         if (value.name.length > 4)
             return true;
     }
@@ -111,10 +96,8 @@ function checkLength(properties) {
     return false;
 }
 
-function hasComputed(properties) {
-    for (const prop of properties) {
-        const {computed} = prop.node;
-        
+function hasComputed(path) {
+    for (const {computed} of path.node.properties) {
         if (computed)
             return true;
     }

package/lib/tokenize/type-checker/parsers.js

@@ -1,5 +1,6 @@
 import {createTuple} from './create-tuple.js';
 
+const isFn = (a) => typeof a === 'function';
 const isString = (a) => typeof a === 'string';
 const {isArray} = Array;
 
@@ -46,11 +47,18 @@ export function parseTypeNames(typeNames) {
     return tuples;
 }
 
-const equal = (a) => (b) => b === a;
-const more = (a) => (b) => b > a;
-const less = (a) => (b) => b < a;
-const moreOrEqual = (a) => (b) => b >= a;
-const lessOrEqual = (a) => (b) => b <= a;
+const createValueParser = (fn) => (a) => (b, ...c) => {
+    if (isFn(a))
+        return fn(a(b, ...c), b);
+    
+    return fn(a, b);
+};
+
+const equal = createValueParser((a, b) => b === a);
+const more = createValueParser((a, b) => b > a);
+const less = createValueParser((a, b) => b < a);
+const moreOrEqual = createValueParser((a, b) => b >= a);
+const lessOrEqual = createValueParser((a, b) => b <= a);
 
 const CMP = {
     '=': equal,
@@ -63,7 +71,6 @@ const CMP = {
 function parseComparison(typeName) {
     if (typeName.length === 3) {
         const [result, comparison, value] = typeName;
-        
         return [result, CMP[comparison](value)];
     }
     

package/lib/tokenize/type-checker/report.js

@@ -48,6 +48,7 @@ const setLine = (name, index) => {
         line,
         column,
     ] = name.split(':');
+    
     const newLine = Number(line) + index + 1;
     
     return [
@@ -76,12 +77,15 @@ function createRawCode(currentType) {
     if (isFn(currentType))
         return currentType.name;
     
-    const [operator, fn] = currentType;
+    const [operator, fn, value] = currentType;
     
-    if (fn) {
+    if (isFn(fn)) {
         const name = fn.name || fn;
         return `['${operator}', ${name}]`;
     }
     
+    if (isString(fn))
+        return `['${operator}', '${fn}', ${value}]`;
+    
     return operator;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@putout/printer",
-  "version": "18.8.2",
+  "version": "18.8.3",
   "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/object-pattern/more-then-max-properties-in-one-line.js

@@ -1,10 +0,0 @@
-export const moreThenMaxPropertiesInOneLine = (path, {maxPropertiesInOneLine}) => {
-    const {parentPath} = path;
-    
-    if (parentPath.isObjectProperty())
-        return false;
-    
-    const n = path.node.properties.length;
-    
-    return maxPropertiesInOneLine >= n;
-};