@putout/bundle 3.19.0 → 3.19.1

package/bundle/putout.js

@@ -9437,7 +9437,7 @@ __export(lib_exports, {
         return tsUndefinedKeyword;
     },
     TSUnionType: function() {
-        return tsUnionType;
+        return tsUnionType$1;
     },
     TSUnknownKeyword: function() {
         return tsUnknownKeyword;
@@ -11171,7 +11171,7 @@ __export(lib_exports, {
         return isJSX;
     },
     isJSXAttribute: function() {
-        return isJSXAttribute$2;
+        return isJSXAttribute$3;
     },
     isJSXClosingElement: function() {
         return isJSXClosingElement;
@@ -11192,7 +11192,7 @@ __export(lib_exports, {
         return isJSXFragment;
     },
     isJSXIdentifier: function() {
-        return isJSXIdentifier$1;
+        return isJSXIdentifier$3;
     },
     isJSXMemberExpression: function() {
         return isJSXMemberExpression;
@@ -12233,7 +12233,7 @@ __export(lib_exports, {
         return tsUndefinedKeyword;
     },
     tsUnionType: function() {
-        return tsUnionType;
+        return tsUnionType$1;
     },
     tsUnknownKeyword: function() {
         return tsUnknownKeyword;
@@ -14418,7 +14418,7 @@ function isOptionalIndexedAccessType(node, opts) {
     if (node.type !== "OptionalIndexedAccessType") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isJSXAttribute$2(node, opts) {
+function isJSXAttribute$3(node, opts) {
     if (!node) return false;
     if (node.type !== "JSXAttribute") return false;
     return opts == null || shallowEqual(node, opts);
@@ -14448,7 +14448,7 @@ function isJSXSpreadChild(node, opts) {
     if (node.type !== "JSXSpreadChild") return false;
     return opts == null || shallowEqual(node, opts);
 }
-function isJSXIdentifier$1(node, opts) {
+function isJSXIdentifier$3(node, opts) {
     if (!node) return false;
     if (node.type !== "JSXIdentifier") return false;
     return opts == null || shallowEqual(node, opts);
@@ -23458,7 +23458,7 @@ function tsNamedTupleMember$1(label, elementType) {
     validate$4(defs.optional, node, "optional", optional);
     return node;
 }
-function tsUnionType(types2) {
+function tsUnionType$1(types2) {
     var node = {
         type: "TSUnionType",
         types: types2
@@ -25026,7 +25026,7 @@ function createTSUnionType(typeAnnotations) {
     if (flattened.length === 1) {
         return flattened[0];
     } else {
-        return tsUnionType(flattened);
+        return tsUnionType$1(flattened);
     }
 }
 function buildUndefinedNode() {
@@ -49874,7 +49874,7 @@ function TSNamedTupleMember$1(node) {
     this.space();
     this.print(node.elementType);
 }
-function TSUnionType(node) {
+function TSUnionType$2(node) {
     tsPrintUnionOrIntersectionType(this, node, "|");
 }
 function TSIntersectionType$1(node) {
@@ -50460,7 +50460,7 @@ var generatorFunctions = /* @__PURE__ */ Object.freeze({
     TSTypeQuery: TSTypeQuery,
     TSTypeReference: TSTypeReference$1,
     TSUndefinedKeyword: TSUndefinedKeyword,
-    TSUnionType: TSUnionType,
+    TSUnionType: TSUnionType$2,
     TSUnknownKeyword: TSUnknownKeyword,
     TSVoidKeyword: TSVoidKeyword,
     TaggedTemplateExpression: TaggedTemplateExpression$1,
@@ -80040,7 +80040,7 @@ function isParens$5(path) {
 
 var objectProperty = {};
 
-var concatanate$1 = {};
+var concatenate$1 = {};
 
 const {
     isStringLiteral: isStringLiteral$7,
@@ -80055,7 +80055,7 @@ const isStringLike = (a) => {
     return isTemplateLiteral$3(a);
 };
 
-concatanate$1.isConcatenation = (path) => {
+concatenate$1.isConcatenation = (path) => {
     const {parentPath} = path;
     const {operator} = path.node;
     
@@ -80077,7 +80077,7 @@ concatanate$1.isConcatenation = (path) => {
     return isBinaryExpression(left) && isStringLike(right);
 };
 
-concatanate$1.concatanate = (path, {print, indent}) => {
+concatenate$1.concatenate = (path, {print, indent}) => {
     if (!path.parentPath.isBinaryExpression()) {
         indent.inc();
         print.breakline();
@@ -80093,7 +80093,7 @@ concatanate$1.concatanate = (path, {print, indent}) => {
         indent.dec();
 };
 
-const {isConcatenation: isConcatenation$2} = concatanate$1;
+const {isConcatenation: isConcatenation$2} = concatenate$1;
 const {isOneLine} = objectExpression;
 const {printKey: printKey$4} = printKey$7;
 
@@ -80643,7 +80643,8 @@ const {
     isClassMethod,
     isTemplateLiteral: isTemplateLiteral$2,
     isJSXText: isJSXText$3,
-    isJSXAttribute: isJSXAttribute$1,
+    isJSXAttribute: isJSXAttribute$2,
+    isJSXIdentifier: isJSXIdentifier$2,
     isTSTypeReference: isTSTypeReference$2,
     isTSTypeParameter,
 } = types$q;
@@ -80656,6 +80657,9 @@ function extract$5(node) {
     if (isIdentifier$7(node))
         return node.name;
     
+    if (isJSXIdentifier$2(node))
+        return node.name;
+    
     if (isRegExpLiteral$1(node))
         return node.pattern;
     
@@ -80677,7 +80681,7 @@ function extract$5(node) {
     if (isJSXText$3(node))
         return node.value;
     
-    if (isJSXAttribute$1(node))
+    if (isJSXAttribute$2(node))
         return node.name.name;
     
     if (isClassMethod(node))
@@ -80697,6 +80701,7 @@ function extract$5(node) {
         'RegExpLiteral',
         'ArrayExpression',
         'MemberExpression',
+        'JSXIdentifier',
         'JSXAttribute',
         'JSXText',
         'TSTypeParameter',
@@ -82149,9 +82154,9 @@ maybeSpace$1.maybeSpace = (path, {print}) => {
 };
 
 const {
-    concatanate,
+    concatenate,
     isConcatenation: isConcatenation$1,
-} = concatanate$1;
+} = concatenate$1;
 
 const {maybeSpace} = maybeSpace$1;
 const {isParens: isParens$2} = parens;
@@ -82186,7 +82191,7 @@ const BinaryExpression$1 = {
         }
         
         if (isConcatenation$1(path))
-            return concatanate(path, {
+            return concatenate(path, {
                 print,
                 indent,
                 maybe,
@@ -82660,7 +82665,7 @@ const {hasPrevNewline: hasPrevNewline$2} = mark;
 const {isExportDeclaration: isExportDeclaration$3} = bundle.types;
 const {maybeSpaceAfterKeyword: maybeSpaceAfterKeyword$2} = maybeSpaceAfterKeyword$3;
 
-const {isConcatenation} = concatanate$1;
+const {isConcatenation} = concatenate$1;
 const {parseLeadingComments: parseLeadingComments$2} = comment;
 const {maybeDeclare: maybeDeclare$4} = maybeDeclare$6;
 
@@ -84947,6 +84952,53 @@ tsMethodSignature.TSMethodSignature = (path, printer, semantics) => {
     write.newline();
 };
 
+var tsUnionType = {};
+
+const {
+    maybeParenOpen,
+    maybeParenClose,
+} = parens;
+
+tsUnionType.TSUnionType = (path, printer, semantics) => {
+    const types = path.get('types');
+    
+    maybeParenOpen(path, printer);
+    
+    if (types.length <= semantics.maxTypesInOneLine)
+        printInOneLine(types, printer);
+    else
+        printInCoupleLines(types, printer);
+    
+    maybeParenClose(path, printer);
+};
+
+function printInOneLine(types, {traverse, write}) {
+    const n = types.length - 1;
+    
+    for (const [i, type] of types.entries()) {
+        traverse(type);
+        
+        if (i < n) {
+            write.space();
+            write('|');
+            write.space();
+        }
+    }
+}
+
+function printInCoupleLines(types, {traverse, write, indent}) {
+    indent.inc();
+    
+    for (const type of types) {
+        write.breakline();
+        write('|');
+        write.space();
+        traverse(type);
+    }
+    
+    indent.dec();
+}
+
 var tsImportType = {};
 
 const {createImportExpression} = importExpression;
@@ -85055,11 +85107,7 @@ const {TSConstructorType} = tsConstructorType;
 const {TSCallSignatureDeclaration} = tsCallSignatureDeclaration;
 const {TSConstructSignatureDeclaration} = tsConstructSignatureDeclaration;
 const {TSMethodSignature} = tsMethodSignature;
-
-const {
-    maybeParenOpen,
-    maybeParenClose,
-} = parens;
+const {TSUnionType} = tsUnionType;
 
 const {maybePrintTypeAnnotation} = maybeTypeAnnotation$4;
 const {TSImportType} = tsImportType;
@@ -85081,6 +85129,7 @@ var typescript$1 = {
     TSModuleBlock,
     TSIntersectionType,
     TSImportType,
+    TSUnionType,
     TSBigIntKeyword(path, {write}) {
         write('bigint');
     },
@@ -85153,26 +85202,6 @@ var typescript$1 = {
         print(' satisfies ');
         print('__typeAnnotation');
     },
-    TSUnionType(path, printer) {
-        const {traverse, write} = printer;
-        
-        const types = path.get('types');
-        const n = types.length - 1;
-        
-        maybeParenOpen(path, printer);
-        
-        for (const [i, type] of types.entries()) {
-            traverse(type);
-            
-            if (i < n) {
-                write.space();
-                write('|');
-                write.space();
-            }
-        }
-        
-        maybeParenClose(path, printer);
-    },
     TSNumberKeyword(path, {write}) {
         write('number');
     },
@@ -85722,6 +85751,7 @@ function initSemantics(semantics = {}) {
         maxSpecifiersInOneLine: 2,
         maxElementsInOneLine: 5,
         maxVariablesInOneLine: 4,
+        maxTypesInOneLine: 3,
         trailingComma: true,
         encodeSingleQuote: true,
         encodeDoubleQuote: false,
@@ -114820,8 +114850,8 @@ const {
     isExportSpecifier,
     isRegExpLiteral,
     isJSXText: isJSXText$2,
-    isJSXIdentifier,
-    isJSXAttribute,
+    isJSXIdentifier: isJSXIdentifier$1,
+    isJSXAttribute: isJSXAttribute$1,
     isTSTypeReference: isTSTypeReference$1,
     isTSTypeParameterDeclaration,
 } = types$f;
@@ -115002,10 +115032,10 @@ is$2.isJSXChildren = (a) => {
 is$2.isJSXAttributes = (a) => {
     const b = !isArray$6(a) ? a : a[0];
     
-    if (!isJSXAttribute(b))
+    if (!isJSXAttribute$1(b))
         return false;
     
-    return isJSXIdentifier(b.name, {
+    return isJSXIdentifier$1(b.name, {
         name: JSX_ATTRIBUTES,
     });
 };
@@ -115139,7 +115169,7 @@ is$2.isLinkedNode = (a) => {
     if (isJSXText$2(a) && LINKED_NODE.test(a.value))
         return true;
     
-    if (isJSXIdentifier(a) && LINKED_NODE.test(a.name))
+    if (isJSXIdentifier$1(a) && LINKED_NODE.test(a.name))
         return true;
     
     if (isTemplateElement$2(a) && LINKED_NODE.test(a.value.raw))
@@ -115188,6 +115218,7 @@ const {
     isIdentifier: isIdentifier$3,
     isStatement: isStatement$1,
     isJSXElement,
+    isJSXAttribute,
     isStringLiteral: isStringLiteral$3,
     isTemplateLiteral: isTemplateLiteral$1,
     TemplateElement,
@@ -115231,12 +115262,15 @@ function findVarsWays$2(node) {
     
     traverse$7(node, {
         noScope: true,
-        'Identifier|BooleanLiteral|StringLiteral|TemplateElement|RegExpLiteral|JSXText|JSXAttribute|TSTypeReference|TSTypeParameter'(path) {
+        'Identifier|JSXIdentifier|BooleanLiteral|StringLiteral|TemplateElement|RegExpLiteral|JSXText|JSXAttribute|TSTypeReference|TSTypeParameter'(path) {
             if (isInsideTypeReference(path))
                 return;
             
             const {node} = path;
             
+            if (isJSXAttribute(path.parentPath) && path.parentPath.node.name === node)
+                return;
+            
             const way = [];
             const name = extract(node);
             
@@ -115394,13 +115428,14 @@ const {
     isTemplateElement: isTemplateElement$1,
     isTSTypeReference,
     isJSXText: isJSXText$1,
+    isJSXIdentifier,
 } = types$d;
 
 const parseName = (node) => {
     node = node[0] || node;
     const {name, value} = node;
     
-    if (isIdentifier$2(node))
+    if (isIdentifier$2(node) || isJSXIdentifier(node))
         return name;
     
     if (isLiteral(node))
@@ -115414,6 +115449,8 @@ const parseName = (node) => {
     
     if (isJSXText$1(node))
         return node.value;
+    
+    throw Error(`☝️ Looks like type of node '${node.type}' not supported by 'compare -> link -> parseName()'`);
 };
 
 link$1.exports = ({add, value, nodeValue, templateStore}) => {
@@ -115603,7 +115640,9 @@ function compareTemplateElements(node, template) {
 }
 
 function linkNodes(node, template, {add, templateStore}) {
-    if (node && isLinkedNode$1(template) || isLinkedArgs(template) || isLinkedId$1(node, template) || isLinkedBool(node, template))
+    const is = node && (isLinkedNode$1(template) || isLinkedArgs(template) || isLinkedId$1(node, template) || isLinkedBool(node, template));
+    
+    if (is)
         return link({
             add,
             value: template,