@openrewrite/rewrite 8.69.0-20251209-122812 → 8.69.0-20251209-133839

package/dist/javascript/tabs-and-indents-visitor.d.ts

@@ -5,14 +5,16 @@ import { TabsAndIndentsStyle } from "./style";
 export declare class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     private readonly tabsAndIndentsStyle;
     private stopAfter?;
-    private readonly singleIndent;
+    private readonly indentSize;
+    private readonly useTabCharacter;
     constructor(tabsAndIndentsStyle: TabsAndIndentsStyle, stopAfter?: Tree | undefined);
+    private indentString;
     protected preVisit(tree: J, _p: P): Promise<J | undefined>;
     private setupCursorMessagesForTree;
     private getParentIndentContext;
     private computeMyIndent;
     private prefixContainsNewline;
-    private isNestedJsxTag;
+    private isJsxChildElement;
     private computeIndentKind;
     postVisit(tree: J, _p: P): Promise<J | undefined>;
     private isInsideJsxTag;
@@ -27,7 +29,6 @@ export declare class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
     private postVisitLeftPadded;
     visitRightPadded<T extends J | boolean>(right: J.RightPadded<T>, p: P): Promise<J.RightPadded<T> | undefined>;
     private preVisitRightPadded;
-    private elementPrefixContainsNewline;
     /**
      * Check if an element is a spread - either directly marked with Spread marker,
      * or a PropertyAssignment whose name has a Spread marker (for object spreads).

package/dist/javascript/tabs-and-indents-visitor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tabs-and-indents-visitor.d.ts","sourceRoot":"","sources":["../../src/javascript/tabs-and-indents-visitor.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,iBAAiB,EAAC,MAAM,WAAW,CAAC;AAC5C,OAAO,EAGH,CAAC,EAOJ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAC,MAAM,EAAmB,IAAI,EAAC,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAC,mBAAmB,EAAC,MAAM,SAAS,CAAC;AAI5C,qBAAa,qBAAqB,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAGlD,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAAuB,OAAO,CAAC,SAAS,CAAC;IAFzF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;gBAET,mBAAmB,EAAE,mBAAmB,EAAU,SAAS,CAAC,EAAE,IAAI,YAAA;cAU/E,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAKhE,OAAO,CAAC,0BAA0B;IAiBlC,OAAO,CAAC,sBAAsB;IA8B9B,OAAO,CAAC,eAAe;IAmCvB,OAAO,CAAC,qBAAqB;IAc7B,OAAO,CAAC,cAAc;IAStB,OAAO,CAAC,iBAAiB;IAaV,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IA2ChE,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,uBAAuB;IAwD/B,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,iBAAiB;IAUZ,cAAc,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAuBlG,OAAO,CAAC,iBAAiB;IA8BzB,OAAO,CAAC,kBAAkB;IAsCb,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAC1E,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EACrB,CAAC,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IA2BvC,OAAO,CAAC,kBAAkB;IAsB1B,OAAO,CAAC,mBAAmB;IAmBd,gBAAgB,CAAC,CAAC,SAAS,CAAC,GAAG,OAAO,EAC/C,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EACvB,CAAC,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAyBxC,OAAO,CAAC,mBAAmB;IA0D3B,OAAO,CAAC,4BAA4B;IAapC;;;OAGG;IACH,OAAO,CAAC,eAAe;IAgBjB,KAAK,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAanF,OAAO,CAAC,oBAAoB;IA8C5B,OAAO,CAAC,aAAa;CAMxB"}
+{"version":3,"file":"tabs-and-indents-visitor.d.ts","sourceRoot":"","sources":["../../src/javascript/tabs-and-indents-visitor.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAC,iBAAiB,EAAC,MAAM,WAAW,CAAC;AAC5C,OAAO,EAGH,CAAC,EAOJ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAC,MAAM,EAAmB,IAAI,EAAC,MAAM,SAAS,CAAC;AAGtD,OAAO,EAAC,mBAAmB,EAAC,MAAM,SAAS,CAAC;AAK5C,qBAAa,qBAAqB,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAIlD,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAAuB,OAAO,CAAC,SAAS,CAAC;IAHzF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAU;gBAEb,mBAAmB,EAAE,mBAAmB,EAAU,SAAS,CAAC,EAAE,IAAI,YAAA;IAM/F,OAAO,CAAC,YAAY;cAOJ,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAKhE,OAAO,CAAC,0BAA0B;IA8DlC,OAAO,CAAC,sBAAsB;IAmB9B,OAAO,CAAC,eAAe;IA0CvB,OAAO,CAAC,qBAAqB;IAa7B,OAAO,CAAC,iBAAiB;IAWzB,OAAO,CAAC,iBAAiB;IAeV,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAkEhE,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,uBAAuB;IAyD/B,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,iBAAiB;IAUZ,cAAc,CAAC,CAAC,SAAS,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAuBlG,OAAO,CAAC,iBAAiB;IAMzB,OAAO,CAAC,kBAAkB;IAmBb,eAAe,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,EAC1E,IAAI,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,EACrB,CAAC,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IA2BvC,OAAO,CAAC,kBAAkB;IAmB1B,OAAO,CAAC,mBAAmB;IAoBd,gBAAgB,CAAC,CAAC,SAAS,CAAC,GAAG,OAAO,EAC/C,KAAK,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,EACvB,CAAC,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IAyBxC,OAAO,CAAC,mBAAmB;IAyC3B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAgBjB,KAAK,CAAC,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAanF,OAAO,CAAC,oBAAoB;IA6C5B,OAAO,CAAC,aAAa;CAMxB"}

package/dist/javascript/tabs-and-indents-visitor.js

@@ -38,12 +38,14 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         super();
         this.tabsAndIndentsStyle = tabsAndIndentsStyle;
         this.stopAfter = stopAfter;
-        if (this.tabsAndIndentsStyle.useTabCharacter) {
-            this.singleIndent = "\t";
-        }
-        else {
-            this.singleIndent = " ".repeat(this.tabsAndIndentsStyle.indentSize);
+        this.indentSize = this.tabsAndIndentsStyle.indentSize;
+        this.useTabCharacter = this.tabsAndIndentsStyle.useTabCharacter;
+    }
+    indentString(indent) {
+        if (this.useTabCharacter) {
+            return "\t".repeat(Math.floor(indent / this.indentSize));
         }
+        return " ".repeat(indent);
     }
     preVisit(tree, _p) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -52,52 +54,85 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         });
     }
     setupCursorMessagesForTree(cursor, tree) {
-        var _a, _b, _c, _d;
+        var _a, _b, _c;
+        // Check if this MethodInvocation starts a method chain (select.after has newline)
+        if (tree.kind === java_1.J.Kind.MethodInvocation) {
+            const mi = tree;
+            if (mi.select && mi.select.after.whitespace.includes("\n")) {
+                // This MethodInvocation has a chained method call after it
+                // Store the ORIGINAL parent indent context in "chainedIndentContext"
+                // This will be propagated down and used when we reach the chain's innermost element
+                const parentContext = this.getParentIndentContext(cursor);
+                cursor.messages.set("chainedIndentContext", parentContext);
+                // For children (arguments), use continuation indent
+                // But the prefix will be normalized in postVisit using chainedIndentContext
+                const [parentIndent, parentIndentKind] = parentContext;
+                cursor.messages.set("indentContext", [parentIndent + this.indentSize, parentIndentKind]);
+                return;
+            }
+            // Check if we're at the base of a chain (no select) and parent has chainedIndentContext
+            if (!mi.select) {
+                const chainedContext = (_a = cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("chainedIndentContext");
+                if (chainedContext !== undefined) {
+                    // Consume the chainedIndentContext - this is the base of the chain
+                    // The base element gets the original indent (no extra continuation)
+                    // Propagate chainedIndentContext so the `name` child knows not to add indent
+                    cursor.messages.set("indentContext", chainedContext);
+                    cursor.messages.set("chainedIndentContext", chainedContext);
+                    return;
+                }
+            }
+        }
+        // Check if we're the `name` of a MethodInvocation at the base of a chain
+        if (tree.kind === java_1.J.Kind.Identifier) {
+            const parentValue = (_b = cursor.parent) === null || _b === void 0 ? void 0 : _b.value;
+            if ((parentValue === null || parentValue === void 0 ? void 0 : parentValue.kind) === java_1.J.Kind.MethodInvocation) {
+                const parentMi = parentValue;
+                // Check if parent has chainedIndentContext (meaning it's at the base of a chain)
+                // and we are the `name` (not an argument or something else)
+                const parentChainedContext = (_c = cursor.parent) === null || _c === void 0 ? void 0 : _c.messages.get("chainedIndentContext");
+                if (parentChainedContext !== undefined && !parentMi.select) {
+                    // We're the name of a chain-base MethodInvocation - use the chained indent directly
+                    cursor.messages.set("indentContext", parentChainedContext);
+                    return;
+                }
+            }
+        }
         const [parentMyIndent, parentIndentKind] = this.getParentIndentContext(cursor);
         const myIndent = this.computeMyIndent(tree, parentMyIndent, parentIndentKind);
-        cursor.messages.set("myIndent", myIndent);
         // For Binary, behavior depends on whether it's already on a continuation line
+        let indentKind;
         if (tree.kind === java_1.J.Kind.Binary) {
-            const hasNewline = ((_b = (_a = tree.prefix) === null || _a === void 0 ? void 0 : _a.whitespace) === null || _b === void 0 ? void 0 : _b.includes("\n")) ||
-                ((_d = (_c = tree.prefix) === null || _c === void 0 ? void 0 : _c.comments) === null || _d === void 0 ? void 0 : _d.some(c => c.suffix.includes("\n")));
             // If Binary has newline OR parent is in align mode, children align
-            const shouldAlign = hasNewline || parentIndentKind === 'align';
-            cursor.messages.set("indentKind", shouldAlign ? 'align' : 'continuation');
+            const hasNewline = this.prefixContainsNewline(tree);
+            indentKind = (hasNewline || parentIndentKind === 'align') ? 'align' : 'continuation';
         }
         else {
-            cursor.messages.set("indentKind", this.computeIndentKind(tree));
+            indentKind = this.computeIndentKind(tree);
         }
+        cursor.messages.set("indentContext", [myIndent, indentKind]);
     }
     getParentIndentContext(cursor) {
-        // Find the nearest myIndent and the nearest indentKind separately
-        // Container/RightPadded/LeftPadded inherit myIndent but don't have indentKind
-        let parentIndent;
-        let parentKind;
+        // Walk up the cursor chain to find the nearest indent context
+        // We need to walk because intermediate nodes like RightPadded may not have context set
         for (let c = cursor.parent; c != null; c = c.parent) {
-            if (parentIndent === undefined) {
-                const indent = c.messages.get("myIndent");
-                if (indent !== undefined) {
-                    parentIndent = indent;
-                }
-            }
-            if (parentKind === undefined) {
-                const kind = c.messages.get("indentKind");
-                if (kind !== undefined) {
-                    parentKind = kind;
-                }
+            // chainedIndentContext stores the original context - prefer it
+            const chainedContext = c.messages.get("chainedIndentContext");
+            if (chainedContext !== undefined) {
+                return chainedContext;
             }
-            // Found both, we can stop
-            if (parentIndent !== undefined && parentKind !== undefined) {
-                break;
+            const context = c.messages.get("indentContext");
+            if (context !== undefined) {
+                return context;
             }
         }
-        return [parentIndent !== null && parentIndent !== void 0 ? parentIndent : "", parentKind !== null && parentKind !== void 0 ? parentKind : 'continuation'];
+        return [0, 'continuation'];
     }
     computeMyIndent(tree, parentMyIndent, parentIndentKind) {
         var _a, _b, _c;
-        // CompilationUnit is the root - it always has myIndent="" regardless of prefix content
+        // CompilationUnit is the root - it always has myIndent=0 regardless of prefix content
         if (tree.kind === tree_1.JS.Kind.CompilationUnit) {
-            return "";
+            return 0;
         }
         // TemplateExpressionSpan: reset indent context - template literal content determines its own indentation
         // The expression inside ${...} should be indented based on where it appears in the template, not outer code
@@ -107,44 +142,52 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             const prefix = (_c = (_b = (_a = span.expression) === null || _a === void 0 ? void 0 : _a.prefix) === null || _b === void 0 ? void 0 : _b.whitespace) !== null && _c !== void 0 ? _c : "";
             const lastNewline = prefix.lastIndexOf("\n");
             if (lastNewline >= 0) {
-                return prefix.slice(lastNewline + 1);
+                return prefix.length - lastNewline - 1;
             }
-            return "";
+            return 0;
         }
         if (tree.kind === java_1.J.Kind.IfElse || parentIndentKind === 'align') {
             return parentMyIndent;
         }
+        // Certain structures don't add indent for themselves - they stay at parent level
+        // - TryCatch: catch clause is part of try statement
+        // - TypeLiteral: { members } in type definitions
+        // - EnumValueSet: enum members get same indent as the set itself
+        if (tree.kind === java_1.J.Kind.TryCatch || tree.kind === tree_1.JS.Kind.TypeLiteral || tree.kind === java_1.J.Kind.EnumValueSet) {
+            return parentMyIndent;
+        }
         // Only add indent if this element starts on a new line
         // Check both the element's prefix and any Spread marker's prefix
         const hasNewline = this.prefixContainsNewline(tree);
         if (!hasNewline) {
             // Special case for JSX: children of JsxTag don't have newlines in their prefix
-            // (newlines are in text Literal nodes), but nested tags should still get block indent
-            if (this.isNestedJsxTag(tree)) {
-                return parentMyIndent + this.singleIndent;
+            // (newlines are in text Literal nodes), but JSX children should still get block indent
+            if (this.isJsxChildElement(tree)) {
+                return parentMyIndent + this.indentSize;
             }
             return parentMyIndent;
         }
         // Add indent for block children or continuation
-        return parentMyIndent + this.singleIndent;
+        return parentMyIndent + this.indentSize;
     }
     prefixContainsNewline(tree) {
-        var _a, _b, _c, _d, _e, _f;
-        // Check the element's own prefix
-        if (((_b = (_a = tree.prefix) === null || _a === void 0 ? void 0 : _a.whitespace) === null || _b === void 0 ? void 0 : _b.includes("\n")) ||
-            ((_d = (_c = tree.prefix) === null || _c === void 0 ? void 0 : _c.comments) === null || _d === void 0 ? void 0 : _d.some(c => c.suffix.includes("\n")))) {
+        var _a, _b;
+        // Check if the element starts on a new line (only the last whitespace matters)
+        if (tree.prefix && (0, java_1.lastWhitespace)(tree.prefix).includes("\n")) {
             return true;
         }
         // For elements with Spread marker, check the Spread marker's prefix
-        const spreadMarker = (_f = (_e = tree.markers) === null || _e === void 0 ? void 0 : _e.markers) === null || _f === void 0 ? void 0 : _f.find(m => m.kind === tree_1.JS.Markers.Spread);
+        const spreadMarker = (_b = (_a = tree.markers) === null || _a === void 0 ? void 0 : _a.markers) === null || _b === void 0 ? void 0 : _b.find(m => m.kind === tree_1.JS.Markers.Spread);
         if (spreadMarker && (0, java_1.spaceContainsNewline)(spreadMarker.prefix)) {
             return true;
         }
         return false;
     }
-    isNestedJsxTag(tree) {
-        // Check if this is a JsxTag whose parent is also a JsxTag
-        if (tree.kind !== tree_1.JS.Kind.JsxTag) {
+    isJsxChildElement(tree) {
+        // Check if this is a JSX child element whose parent is a JsxTag
+        // JSX children (JsxTag, JsxEmbeddedExpression) don't have newlines in their own prefix
+        // (newlines are in text Literal nodes), but they should still get block indent
+        if (tree.kind !== tree_1.JS.Kind.JsxTag && tree.kind !== tree_1.JS.Kind.JsxEmbeddedExpression) {
             return false;
         }
         const parentTree = this.cursor.parentTree();
@@ -155,6 +198,8 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             case java_1.J.Kind.Block:
             case java_1.J.Kind.Case:
             case tree_1.JS.Kind.JsxTag:
+            case tree_1.JS.Kind.TypeLiteral:
+            case java_1.J.Kind.EnumValueSet:
                 return 'block';
             case tree_1.JS.Kind.CompilationUnit:
                 return 'align';
@@ -164,19 +209,40 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
     }
     postVisit(tree, _p) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c;
+            var _a, _b, _c, _d, _e;
             if (this.stopAfter != null && (0, tree_2.isScope)(this.stopAfter, tree)) {
                 (_a = this.cursor) === null || _a === void 0 ? void 0 : _a.root.messages.set("stop", true);
             }
-            const myIndent = this.cursor.messages.get("myIndent");
-            if (myIndent === undefined) {
+            // If parent has chainedIndentContext but no indentContext yet, we're exiting a chain element
+            // Set indentContext on parent = [chainedIndent + indentSize, chainedIndentKind]
+            // This only happens once at the innermost element; subsequent parents will already have indentContext
+            const parentChainedContext = (_b = this.cursor.parent) === null || _b === void 0 ? void 0 : _b.messages.get("chainedIndentContext");
+            const parentHasIndentContext = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.messages.has("indentContext");
+            if (parentChainedContext !== undefined && !parentHasIndentContext) {
+                const [chainedIndent, chainedIndentKind] = parentChainedContext;
+                this.cursor.parent.messages.set("indentContext", [chainedIndent + this.indentSize, chainedIndentKind]);
+            }
+            const indentContext = this.cursor.messages.get("indentContext");
+            if (indentContext === undefined) {
                 return tree;
             }
+            let [myIndent] = indentContext;
+            // For chain-start MethodInvocations, the prefix contains whitespace before the chain BASE
+            // Use chainedIndentContext (the original indent) for the prefix, not the continuation indent
+            const chainedContext = this.cursor.messages.get("chainedIndentContext");
+            if (chainedContext !== undefined && tree.kind === java_1.J.Kind.MethodInvocation) {
+                const mi = tree;
+                if (mi.select && mi.select.after.whitespace.includes("\n")) {
+                    // This is a chain-start - use original indent for prefix normalization
+                    myIndent = chainedContext[0];
+                }
+            }
             let result = tree;
+            const indentStr = this.indentString(myIndent);
             // Check if the element has a Spread marker - if so, normalize its prefix instead
-            const spreadMarker = (_c = (_b = result.markers) === null || _b === void 0 ? void 0 : _b.markers) === null || _c === void 0 ? void 0 : _c.find(m => m.kind === tree_1.JS.Markers.Spread);
+            const spreadMarker = (_e = (_d = result.markers) === null || _d === void 0 ? void 0 : _d.markers) === null || _e === void 0 ? void 0 : _e.find(m => m.kind === tree_1.JS.Markers.Spread);
             if (spreadMarker && (0, java_1.spaceContainsNewline)(spreadMarker.prefix)) {
-                const normalizedPrefix = (0, java_1.normalizeSpaceIndent)(spreadMarker.prefix, myIndent);
+                const normalizedPrefix = (0, java_1.normalizeSpaceIndent)(spreadMarker.prefix, indentStr);
                 if (normalizedPrefix !== spreadMarker.prefix) {
                     result = (0, immer_1.produce)(result, draft => {
                         const spreadIdx = draft.markers.markers.findIndex(m => m.kind === tree_1.JS.Markers.Spread);
@@ -188,7 +254,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             }
             else if (result.prefix && (0, java_1.spaceContainsNewline)(result.prefix)) {
                 // Normalize the entire prefix space including comment suffixes
-                const normalizedPrefix = (0, java_1.normalizeSpaceIndent)(result.prefix, myIndent);
+                const normalizedPrefix = (0, java_1.normalizeSpaceIndent)(result.prefix, indentStr);
                 if (normalizedPrefix !== result.prefix) {
                     result = (0, immer_1.produce)(result, draft => {
                         draft.prefix = normalizedPrefix;
@@ -214,13 +280,14 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         }
         // Check if this literal is the last child of a JsxTag - if so, its trailing whitespace
         // should use the parent tag's indent, not the content indent
-        const parentIndent = this.cursor.parentTree().messages.get("myIndent");
+        const parentContext = this.cursor.parentTree().messages.get("indentContext");
+        const parentIndent = parentContext === null || parentContext === void 0 ? void 0 : parentContext[0];
         const isLastChild = parentIndent !== undefined && this.isLastChildOfJsxTag(literal);
         // For JSX text content, the newline is in the value, not the prefix.
         // Since the content IS effectively on a new line, it should get block child indent.
         // myIndent is the parent's indent (because Literal prefix has no newline),
-        // so we need to add singleIndent for content lines.
-        const contentIndent = myIndent + this.singleIndent;
+        // so we need to add indentSize for content lines.
+        const contentIndent = myIndent + this.indentSize;
         // Split by newlines and normalize each line's indentation
         const lines = literal.valueSource.split('\n');
         const result = [];
@@ -235,7 +302,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
                 // Line has only whitespace (or is empty)
                 if (isLastChild && i === lines.length - 1) {
                     // Trailing whitespace of last child - use parent indent for closing tag alignment
-                    result.push(parentIndent);
+                    result.push(this.indentString(parentIndent));
                 }
                 else if (i < lines.length - 1) {
                     // Empty line in the middle (followed by more lines) - keep empty
@@ -243,12 +310,12 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
                 }
                 else {
                     // Trailing whitespace of non-last-child - add content indent
-                    result.push(contentIndent);
+                    result.push(this.indentString(contentIndent));
                 }
             }
             else {
                 // Line has content - add proper indent
-                result.push(contentIndent + content);
+                result.push(this.indentString(contentIndent) + content);
             }
         }
         const normalizedValueSource = result.join('\n');
@@ -277,7 +344,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             return block;
         }
         return (0, immer_1.produce)(block, draft => {
-            draft.end = (0, java_1.replaceLastWhitespace)(draft.end, ws => (0, java_1.replaceIndentAfterLastNewline)(ws, myIndent));
+            draft.end = (0, java_1.replaceLastWhitespace)(draft.end, ws => (0, java_1.replaceIndentAfterLastNewline)(ws, this.indentString(myIndent)));
         });
     }
     visitContainer(container, p) {
@@ -285,7 +352,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             // Create cursor for this container
             this.cursor = new tree_2.Cursor(container, this.cursor);
             // Pre-visit hook: set up cursor messages
-            this.preVisitContainer(container);
+            this.preVisitContainer();
             // Visit children (similar to base visitor but without cursor management)
             let ret = (yield (0, visitor_2.produceAsync)(container, (draft) => __awaiter(this, void 0, void 0, function* () {
                 draft.before = yield this.visitSpace(container.before, p);
@@ -299,56 +366,16 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             return ret;
         });
     }
-    preVisitContainer(container) {
-        var _a, _b, _c, _d;
-        let myIndent = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("myIndent")) !== null && _b !== void 0 ? _b : "";
-        // Check if we're in a method chain - use chainedIndent if available
-        // This ensures arguments inside method chains like `.select(arg)` inherit the chain's indent level
-        // BUT stop at scope boundaries:
-        // 1. Blocks - nested code inside callbacks should NOT use outer chainedIndent
-        // 2. Other Containers - nested function call arguments should NOT use outer chainedIndent
-        for (let c = this.cursor.parent; c; c = c.parent) {
-            // Stop searching if we hit a Block (function body, arrow function body, etc.)
-            // This prevents chainedIndent from leaking into nested scopes
-            if (((_c = c.value) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Block) {
-                break;
-            }
-            // Stop searching if we hit another Container (arguments of another function call)
-            // This prevents chainedIndent from leaking into nested function calls
-            if (((_d = c.value) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Container) {
-                break;
-            }
-            const chainedIndent = c.messages.get("chainedIndent");
-            if (chainedIndent !== undefined) {
-                myIndent = chainedIndent;
-                break;
-            }
-        }
-        this.cursor.messages.set("myIndent", myIndent);
-        this.cursor.messages.set("indentKind", 'continuation');
+    preVisitContainer() {
+        var _a;
+        const parentContext = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("indentContext");
+        const [myIndent] = parentContext !== null && parentContext !== void 0 ? parentContext : [0, 'continuation'];
+        this.cursor.messages.set("indentContext", [myIndent, 'continuation']);
     }
     postVisitContainer(container) {
-        var _a, _b, _c, _d;
-        let parentIndent = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("myIndent")) !== null && _b !== void 0 ? _b : "";
-        // Check for chainedIndent for closing delimiter alignment in method chains
-        // BUT stop at scope boundaries:
-        // 1. Blocks - nested code inside callbacks should NOT use outer chainedIndent
-        // 2. Other Containers - nested function call arguments should NOT use outer chainedIndent
-        for (let c = this.cursor.parent; c; c = c.parent) {
-            // Stop searching if we hit a Block (function body, arrow function body, etc.)
-            if (((_c = c.value) === null || _c === void 0 ? void 0 : _c.kind) === java_1.J.Kind.Block) {
-                break;
-            }
-            // Stop searching if we hit another Container (arguments of another function call)
-            if (((_d = c.value) === null || _d === void 0 ? void 0 : _d.kind) === java_1.J.Kind.Container) {
-                break;
-            }
-            const chainedIndent = c.messages.get("chainedIndent");
-            if (chainedIndent !== undefined) {
-                parentIndent = chainedIndent;
-                break;
-            }
-        }
+        var _a;
+        const parentContext = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("indentContext");
+        const [parentIndent] = parentContext !== null && parentContext !== void 0 ? parentContext : [0, 'continuation'];
         // Normalize the last element's after whitespace (closing delimiter like `)`)
         // The closing delimiter should align with the parent's indent level
         if (container.elements.length > 0) {
@@ -356,7 +383,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             if (effectiveLastWs.includes("\n")) {
                 return (0, immer_1.produce)(container, draft => {
                     const lastDraft = draft.elements[draft.elements.length - 1];
-                    lastDraft.after = (0, java_1.replaceLastWhitespace)(lastDraft.after, ws => (0, java_1.replaceIndentAfterLastNewline)(ws, parentIndent));
+                    lastDraft.after = (0, java_1.replaceLastWhitespace)(lastDraft.after, ws => (0, java_1.replaceIndentAfterLastNewline)(ws, this.indentString(parentIndent)));
                 });
             }
         }
@@ -387,26 +414,23 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         });
     }
     preVisitLeftPadded(left) {
-        var _a, _b, _c, _d;
-        // Get parent indent from parent cursor
-        const parentIndent = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("myIndent")) !== null && _b !== void 0 ? _b : "";
+        var _a, _b;
+        const parentContext = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("indentContext");
+        const [parentIndent, parentIndentKind] = parentContext !== null && parentContext !== void 0 ? parentContext : [0, 'continuation'];
         const hasNewline = left.before.whitespace.includes("\n");
         // Check if parent is a Binary in align mode - if so, don't add continuation indent
-        // (Binary sets indentKind='align' when it's already on a continuation line)
-        const parentValue = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.value;
-        const parentIndentKind = (_d = this.cursor.parent) === null || _d === void 0 ? void 0 : _d.messages.get("indentKind");
+        const parentValue = (_b = this.cursor.parent) === null || _b === void 0 ? void 0 : _b.value;
         const shouldAlign = (parentValue === null || parentValue === void 0 ? void 0 : parentValue.kind) === java_1.J.Kind.Binary && parentIndentKind === 'align';
         // Compute myIndent INCLUDING continuation if applicable
-        // This ensures child elements see the correct parent indent
         let myIndent = parentIndent;
         if (hasNewline && !shouldAlign) {
-            myIndent = parentIndent + this.singleIndent;
+            myIndent = parentIndent + this.indentSize;
         }
-        this.cursor.messages.set("myIndent", myIndent);
+        this.cursor.messages.set("indentContext", [myIndent, 'continuation']);
         this.cursor.messages.set("hasNewline", hasNewline);
     }
     postVisitLeftPadded(left) {
-        var _a, _b;
+        var _a;
         if (left === undefined) {
             return undefined;
         }
@@ -414,10 +438,11 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         if (!hasNewline) {
             return left;
         }
-        // Use the myIndent we computed in preVisitLeftPadded (which includes continuation if applicable)
-        const targetIndent = (_b = this.cursor.messages.get("myIndent")) !== null && _b !== void 0 ? _b : "";
+        // Use the indent we computed in preVisitLeftPadded (which includes continuation if applicable)
+        const context = this.cursor.messages.get("indentContext");
+        const [targetIndent] = context !== null && context !== void 0 ? context : [0, 'continuation'];
         return (0, immer_1.produce)(left, draft => {
-            draft.before.whitespace = (0, java_1.replaceIndentAfterLastNewline)(draft.before.whitespace, targetIndent);
+            draft.before.whitespace = (0, java_1.replaceIndentAfterLastNewline)(draft.before.whitespace, this.indentString(targetIndent));
         });
     }
     visitRightPadded(right, p) {
@@ -443,74 +468,42 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
         });
     }
     preVisitRightPadded(right) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        // Get parent indent from parent cursor
-        const parentIndent = (_b = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("myIndent")) !== null && _b !== void 0 ? _b : "";
-        const parentIndentKind = (_d = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.messages.get("indentKind")) !== null && _d !== void 0 ? _d : "";
-        // Check if the `after` has a newline (e.g., in method chains like `db\n    .from()`)
-        const hasNewline = right.after.whitespace.includes("\n");
-        // Only apply chainedIndent logic for method chains (when parent is a MethodInvocation)
-        const parentKind = (_f = (_e = this.cursor.parent) === null || _e === void 0 ? void 0 : _e.value) === null || _f === void 0 ? void 0 : _f.kind;
-        const isMethodChain = parentKind === java_1.J.Kind.MethodInvocation;
-        let myIndent = parentIndent;
-        if (hasNewline && isMethodChain) {
-            // Search up the cursor hierarchy for an existing chainedIndent (to avoid stacking in method chains)
-            let existingChainedIndent;
-            for (let c = this.cursor.parent; c; c = c.parent) {
-                existingChainedIndent = c.messages.get("chainedIndent");
-                if (existingChainedIndent !== undefined) {
-                    break;
-                }
-            }
-            if (existingChainedIndent === undefined) {
-                myIndent = parentIndent + this.singleIndent;
-                // Set chainedIndent on parent so further chain elements don't stack
-                (_g = this.cursor.parent) === null || _g === void 0 ? void 0 : _g.messages.set("chainedIndent", myIndent);
-            }
-            else {
-                myIndent = existingChainedIndent;
-            }
+        var _a, _b, _c, _d, _e, _f, _g;
+        const parentContext = (_a = this.cursor.parent) === null || _a === void 0 ? void 0 : _a.messages.get("indentContext");
+        const [parentIndent, parentIndentKind] = parentContext !== null && parentContext !== void 0 ? parentContext : [0, 'continuation'];
+        // Check if parent has chainedIndentContext - if so, this is the select of a method chain
+        // Propagate chainedIndentContext but do NOT set indentContext
+        const parentChainedContext = (_b = this.cursor.parent) === null || _b === void 0 ? void 0 : _b.messages.get("chainedIndentContext");
+        if (parentChainedContext !== undefined) {
+            this.cursor.messages.set("chainedIndentContext", parentChainedContext);
+            // Do NOT set indentContext - child elements will use chainedIndentContext
+            return;
         }
-        else if (parentIndentKind !== 'align' && (0, java_1.isJava)(right.element) && this.elementPrefixContainsNewline(right.element)) {
-            myIndent = parentIndent + this.singleIndent;
+        // Check if Parentheses wraps a Binary expression - if so, let Binary handle its own indent
+        const rightPaddedParentKind = (_d = (_c = this.cursor.parent) === null || _c === void 0 ? void 0 : _c.value) === null || _d === void 0 ? void 0 : _d.kind;
+        const elementKind = (_e = right.element) === null || _e === void 0 ? void 0 : _e.kind;
+        const isParenthesesWrappingBinary = rightPaddedParentKind === java_1.J.Kind.Parentheses &&
+            elementKind === java_1.J.Kind.Binary;
+        let myIndent = parentIndent;
+        if (!isParenthesesWrappingBinary && parentIndentKind !== 'align' && (0, java_1.isJava)(right.element) && this.prefixContainsNewline(right.element)) {
+            myIndent = parentIndent + this.indentSize;
             // For spread elements with newlines, mark continuation as established
-            // This allows subsequent elements on the SAME line to inherit the continuation level
             const element = right.element;
             if (this.isSpreadElement(element)) {
-                (_h = this.cursor.parent) === null || _h === void 0 ? void 0 : _h.messages.set("continuationIndent", myIndent);
+                (_f = this.cursor.parent) === null || _f === void 0 ? void 0 : _f.messages.set("continuationIndent", myIndent);
             }
         }
-        else if ((0, java_1.isJava)(right.element) && !this.elementPrefixContainsNewline(right.element)) {
+        else if ((0, java_1.isJava)(right.element) && !this.prefixContainsNewline(right.element)) {
             // Element has no newline - check if a previous sibling established continuation
-            const continuationIndent = (_j = this.cursor.parent) === null || _j === void 0 ? void 0 : _j.messages.get("continuationIndent");
+            const continuationIndent = (_g = this.cursor.parent) === null || _g === void 0 ? void 0 : _g.messages.get("continuationIndent");
             if (continuationIndent !== undefined) {
                 myIndent = continuationIndent;
             }
         }
-        this.cursor.messages.set("myIndent", myIndent);
         // Set 'align' for most RightPadded elements to prevent double-continuation
-        // EXCEPT when Parentheses wraps a Binary expression - in that case, the Binary's
-        // children need continuation mode to get proper indentation for multi-line operands
-        const rightPaddedParentKind = (_l = (_k = this.cursor.parent) === null || _k === void 0 ? void 0 : _k.value) === null || _l === void 0 ? void 0 : _l.kind;
-        const elementKind = (_m = right.element) === null || _m === void 0 ? void 0 : _m.kind;
-        const isParenthesesWrappingBinary = rightPaddedParentKind === java_1.J.Kind.Parentheses &&
-            elementKind === java_1.J.Kind.Binary;
-        if (!isParenthesesWrappingBinary) {
-            this.cursor.messages.set("indentKind", "align");
-        }
-    }
-    elementPrefixContainsNewline(element) {
-        var _a, _b;
-        // Check the element's own prefix
-        if ((0, java_1.lastWhitespace)(element.prefix).includes("\n")) {
-            return true;
-        }
-        // Also check for Spread marker's prefix
-        const spreadMarker = (_b = (_a = element.markers) === null || _a === void 0 ? void 0 : _a.markers) === null || _b === void 0 ? void 0 : _b.find(m => m.kind === tree_1.JS.Markers.Spread);
-        if (spreadMarker && (0, java_1.spaceContainsNewline)(spreadMarker.prefix)) {
-            return true;
-        }
-        return false;
+        // EXCEPT when Parentheses wraps a Binary expression - use continuation so Binary children align
+        const indentKind = isParenthesesWrappingBinary ? 'continuation' : 'align';
+        this.cursor.messages.set("indentContext", [myIndent, indentKind]);
     }
     /**
      * Check if an element is a spread - either directly marked with Spread marker,
@@ -551,7 +544,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
     setupAncestorIndents() {
         const path = [];
         let anchorCursor;
-        let anchorIndent = "";
+        let anchorIndent = 0;
         for (let c = this.cursor.parent; c; c = c.parent) {
             path.push(c);
             const v = c.value;
@@ -560,13 +553,13 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
                 const idx = ws.lastIndexOf('\n');
                 if (idx !== -1) {
                     anchorCursor = c;
-                    anchorIndent = ws.substring(idx + 1);
+                    anchorIndent = ws.length - idx - 1;
                 }
             }
             if (v.kind === tree_1.JS.Kind.CompilationUnit) {
                 if (!anchorCursor) {
                     anchorCursor = c;
-                    anchorIndent = "";
+                    anchorIndent = 0;
                 }
                 break;
             }
@@ -581,8 +574,7 @@ class TabsAndIndentsVisitor extends visitor_1.JavaScriptVisitor {
             const savedCursor = this.cursor;
             this.cursor = c;
             if (c === anchorCursor) {
-                c.messages.set("myIndent", anchorIndent);
-                c.messages.set("indentKind", this.computeIndentKind(v));
+                c.messages.set("indentContext", [anchorIndent, this.computeIndentKind(v)]);
             }
             else {
                 this.setupCursorMessagesForTree(c, v);