@openrewrite/rewrite 8.92.16 → 8.92.17

package/src/javascript/format/tabs-and-indents-visitor.ts

@@ -179,15 +179,42 @@ export class TabsAndIndentsVisitor<P> extends JavaScriptVisitor<P> {
         // 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
         if (tree.kind === JS.Kind.TemplateExpressionSpan) {
-            // Extract base indent from the expression's prefix whitespace (after the last newline)
+            // Whitespace after ${ belongs to the span, not its child expression.
             const span = tree as JS.TemplateExpression.Span;
-            const prefix = span.expression?.prefix?.whitespace ?? "";
+            const prefix = lastWhitespace(span.prefix);
             const lastNewline = prefix.lastIndexOf("\n");
             if (lastNewline >= 0) {
-                return prefix.length - lastNewline - 1;
+                return this.indentWidth(prefix.substring(lastNewline + 1));
+            }
+            const template = this.cursor.parentTree()?.value as JS.TemplateExpression | undefined;
+            if (template?.kind === JS.Kind.TemplateExpression) {
+                const index = template.spans.findIndex(s => s.element.id === span.id);
+                const preceding = index > 0 ? template.spans[index - 1].element.tail : template.head;
+                const text = preceding.valueSource ?? "";
+                const newline = text.lastIndexOf("\n");
+                if (newline >= 0) {
+                    // A span on a literal's own line is anchored to that line's indentation.
+                    const indent = text.substring(newline + 1).match(/^[ \t]*/)?.[0] ?? "";
+                    return this.indentWidth(indent);
+                }
+            }
+            // An inline interpolation continues the surrounding code line, not column zero.
+            for (let c = this.cursor.parent; c; c = c.parent) {
+                const parent = c.value as J;
+                if (parent?.prefix && spaceContainsNewline(parent.prefix)) {
+                    return (c.messages.get("indentContext") as IndentContext | undefined)?.[0] ?? parentMyIndent;
+                }
             }
             return 0;
         }
+        // The tail prefix is the whitespace before }, not another continuation of the expression.
+        const parentTree = this.cursor.parentTree()?.value;
+        if (parentTree?.kind === JS.Kind.TemplateExpressionSpan &&
+            (parentTree as JS.TemplateExpression.Span).tail === tree) {
+            const prefix = lastWhitespace(tree.prefix);
+            const newline = prefix.lastIndexOf("\n");
+            return newline < 0 ? parentMyIndent : this.indentWidth(prefix.substring(newline + 1));
+        }
         if (tree.kind === J.Kind.IfElse || parentIndentKind === 'align') {
             return parentMyIndent;
         }

package/src/javascript/markers.ts

@@ -24,9 +24,10 @@ import {
     StyleKind,
     TabsAndIndentsStyle,
     WrappingAndBracesStyle,
-    WrappingAndBracesStyleDetailKind
+    WrappingAndBracesStyleDetailKind,
+    prettierStyle
 } from "./style";
-import {Autodetect} from "./autodetect";
+import {Autodetect, autodetect} from "./autodetect";
 import {updateIfChanged} from "../util";
 
 declare module "./tree" {
@@ -37,6 +38,7 @@ declare module "./tree" {
             readonly NonNullAssertion: "org.openrewrite.javascript.marker.NonNullAssertion";
             readonly DelegatedYield: "org.openrewrite.javascript.marker.DelegatedYield";
             readonly FunctionDeclaration: "org.openrewrite.javascript.marker.FunctionDeclaration";
+            readonly Computed: "org.openrewrite.javascript.marker.Computed";
         };
     }
 }
@@ -48,6 +50,7 @@ declare module "./tree" {
     Optional: "org.openrewrite.javascript.marker.Optional",
     NonNullAssertion: "org.openrewrite.javascript.marker.NonNullAssertion",
     FunctionDeclaration: "org.openrewrite.javascript.marker.FunctionDeclaration",
+    Computed: "org.openrewrite.javascript.marker.Computed",
 } as const;
 
 /**
@@ -80,6 +83,18 @@ export interface FunctionDeclaration extends Marker {
     readonly prefix: J.Space;
 }
 
+/**
+ * A name written in brackets where the model has room for an identifier only, as the
+ * member of `enum A { ['b'] }` is. The identifier holds the bracketed literal.
+ */
+export interface Computed extends Marker {
+    readonly kind: typeof JS.Markers.Computed;
+    /**
+     * The space before the closing bracket.
+     */
+    readonly suffix: J.Space;
+}
+
 /**
  * Registers an RPC codec for any marker that has a `prefix: J.Space` field.
  */
@@ -107,11 +122,26 @@ registerPrefixedMarkerCodec<Generator>(JS.Markers.Generator);
 registerPrefixedMarkerCodec<NonNullAssertion>(JS.Markers.NonNullAssertion);
 registerPrefixedMarkerCodec<FunctionDeclaration>(JS.Markers.FunctionDeclaration);
 
+RpcCodecs.registerCodec(JS.Markers.Computed, {
+    async rpcReceive(before: Computed, q: RpcReceiveQueue): Promise<Computed> {
+        return updateIfChanged(before, {
+            id: await q.receive(before.id),
+            suffix: await q.receive(before.suffix),
+        });
+    },
+
+    async rpcSend(after: Computed, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.suffix);
+    }
+});
+
 // Register codec for PrettierStyle (a NamedStyles that contains Prettier configuration)
 // Only serialize the variable fields; constant fields are defined in the interface
 RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
     async rpcReceive(before: PrettierStyle, q: RpcReceiveQueue): Promise<PrettierStyle> {
-        return updateIfChanged(before, {
+        // the fields that never vary are not sent, so a marker first met here does not have them yet
+        return updateIfChanged(before.name ? before : {...prettierStyle(before.id, {}), ...before}, {
             id: await q.receive(before.id),
             config: await q.receive(before.config),
             prettierVersion: await q.receive(before.prettierVersion),
@@ -131,7 +161,7 @@ RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
 // Only serialize the variable fields (id, styles); constant fields are defined in the interface
 RpcCodecs.registerCodec(StyleKind.Autodetect, {
     async rpcReceive(before: Autodetect, q: RpcReceiveQueue): Promise<Autodetect> {
-        return updateIfChanged(before, {
+        return updateIfChanged(before.name ? before : {...autodetect(before.id, []), ...before}, {
             id: await q.receive(before.id),
             styles: (await q.receiveList(before.styles))!,
         });

package/src/javascript/node-resolution-result.ts

@@ -659,7 +659,7 @@ export function createNodeResolutionResultMarker(
         resolvedDependencies,
         packageManager,
         engines: normalizeEngines(packageJsonContent.engines),
-        npmrcConfigs,
+        npmrcConfigs: npmrcConfigs?.length ? npmrcConfigs : undefined,
     } as NodeResolutionResult;
 }
 
@@ -1022,7 +1022,8 @@ RpcCodecs.registerCodec(NodeResolutionResultKind, {
             resolvedDependencies: (await q.receiveList(before.resolvedDependencies)) || [],
             packageManager: await q.receive(before.packageManager),
             engines: await q.receive(before.engines),
-            npmrcConfigs: (await q.receiveList(before.npmrcConfigs)) || undefined,
+            // an empty list is how having none is sent
+            npmrcConfigs: await q.receiveList(before.npmrcConfigs).then(configs => configs?.length ? configs : undefined),
         });
     },