@openrewrite/rewrite 8.69.0-20251210-214835 → 8.69.0-20251211-110844

package/src/javascript/search/find-dependency.ts

@@ -5,7 +5,7 @@
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * <p>
- * https://docs.moderne.io/licensing/moderate-source-available-license
+ * https://docs.moderne.io/licensing/moderne-source-available-license
  * <p>
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
@@ -17,10 +17,12 @@
 import {Option, Recipe} from "../../recipe";
 import {ExecutionContext} from "../../execution";
 import {TreeVisitor} from "../../visitor";
-import {Json, JsonVisitor} from "../../json";
+import {getMemberKeyName, isMember, Json, JsonVisitor} from "../../json";
 import {foundSearchResult} from "../../markers";
 import {
+    allDependencyScopes,
     Dependency,
+    DependencyScope,
     findNodeResolutionResult,
     NodeResolutionResult,
     ResolvedDependency
@@ -29,12 +31,7 @@ import * as semver from "semver";
 import * as picomatch from "picomatch";
 
 /** Dependency section names in package.json */
-const DEPENDENCY_SECTIONS = new Set([
-    'dependencies',
-    'devDependencies',
-    'peerDependencies',
-    'optionalDependencies'
-]);
+const DEPENDENCY_SECTIONS = new Set<DependencyScope>(allDependencyScopes);
 
 /**
  * Finds npm/Node.js dependencies declared in package.json.
@@ -134,7 +131,7 @@ export class FindDependency extends Recipe {
                 }
 
                 // Get the package name from the member key
-                const depName = this.getMemberKeyName(member);
+                const depName = getMemberKeyName(member);
                 if (!depName) {
                     return super.visitMember(member, ctx);
                 }
@@ -179,18 +176,16 @@ export class FindDependency extends Recipe {
              * Checks if the current member's parent is a dependency section object.
              * Returns the section name if so, undefined otherwise.
              */
-            private getParentDependencySection(): string | undefined {
+            private getParentDependencySection(): DependencyScope | undefined {
                 // Walk up the cursor to find the parent member that contains this dependency
                 // Structure: Document > Object > Member("dependencies") > Object > Member("lodash")
                 let cursor = this.cursor.parent;
                 while (cursor) {
                     const tree = cursor.value;
-                    if (tree && typeof tree === 'object' && 'kind' in tree) {
-                        if (tree.kind === Json.Kind.Member) {
-                            const memberKey = this.getMemberKeyName(tree as Json.Member);
-                            if (memberKey && DEPENDENCY_SECTIONS.has(memberKey)) {
-                                return memberKey;
-                            }
+                    if (tree && typeof tree === 'object' && 'kind' in tree && isMember(tree as Json)) {
+                        const memberKey = getMemberKeyName(tree as Json.Member);
+                        if (memberKey && DEPENDENCY_SECTIONS.has(memberKey as DependencyScope)) {
+                            return memberKey as DependencyScope;
                         }
                     }
                     cursor = cursor.parent;
@@ -198,46 +193,12 @@ export class FindDependency extends Recipe {
                 return undefined;
             }
 
-            /**
-             * Extracts the key name from a Json.Member
-             */
-            private getMemberKeyName(member: Json.Member): string | undefined {
-                const key = member.key.element;
-                if (key.kind === Json.Kind.Literal) {
-                    // Remove quotes from string literal
-                    const source = (key as Json.Literal).source;
-                    if (source.startsWith('"') && source.endsWith('"')) {
-                        return source.slice(1, -1);
-                    }
-                    return source;
-                } else if (key.kind === Json.Kind.Identifier) {
-                    return (key as Json.Identifier).name;
-                }
-                return undefined;
-            }
-
             /**
              * Finds a dependency by name in the appropriate section of the resolution result.
              */
-            private findDependencyByName(name: string, section: string): Dependency | undefined {
+            private findDependencyByName(name: string, section: DependencyScope): Dependency | undefined {
                 if (!this.resolution) return undefined;
-
-                let deps: Dependency[] | undefined;
-                switch (section) {
-                    case 'dependencies':
-                        deps = this.resolution.dependencies;
-                        break;
-                    case 'devDependencies':
-                        deps = this.resolution.devDependencies;
-                        break;
-                    case 'peerDependencies':
-                        deps = this.resolution.peerDependencies;
-                        break;
-                    case 'optionalDependencies':
-                        deps = this.resolution.optionalDependencies;
-                        break;
-                }
-
+                const deps = this.resolution[section];
                 return deps?.find(d => d.name === name);
             }
         };

package/src/json/tree.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Markers} from "../markers";
+import {emptyMarkers, Markers} from "../markers";
 import {SourceFile, Tree} from "../tree";
 
 
@@ -117,3 +117,100 @@ const jsonKindValues = new Set(Object.values(Json.Kind));
 export function isJson(tree: any): tree is Json {
     return jsonKindValues.has(tree["kind"]);
 }
+
+export function isLiteral(json: Json): json is Json.Literal {
+    return json.kind === Json.Kind.Literal;
+}
+
+export function isObject(json: Json): json is Json.Object {
+    return json.kind === Json.Kind.Object;
+}
+
+export function isArray(json: Json): json is Json.Array {
+    return json.kind === Json.Kind.Array;
+}
+
+export function isIdentifier(json: Json): json is Json.Identifier {
+    return json.kind === Json.Kind.Identifier;
+}
+
+export function isMember(json: Json): json is Json.Member {
+    return json.kind === Json.Kind.Member;
+}
+
+/**
+ * Gets the key name from a Json.Member.
+ * Handles both string literals (quoted keys) and identifiers (unquoted keys).
+ *
+ * @param member The JSON member to extract the key name from
+ * @returns The key name as a string, or undefined if extraction fails
+ */
+export function getMemberKeyName(member: Json.Member): string | undefined {
+    const key = member.key.element;
+    if (isLiteral(key)) {
+        const source = key.source;
+        // Remove quotes from string literal
+        if (source.startsWith('"') && source.endsWith('"')) {
+            return source.slice(1, -1);
+        }
+        return source;
+    } else if (isIdentifier(key)) {
+        return key.name;
+    }
+    return undefined;
+}
+
+/**
+ * Detects the indentation used in a JSON document by examining existing members or array elements.
+ * Returns the base indent string (e.g., "  " for 2 spaces, "    " for 4 spaces).
+ *
+ * @param doc The JSON document to analyze
+ * @returns The detected indent string, or "    " (4 spaces) as default
+ */
+export function detectIndent(doc: Json.Document): string {
+    const defaultIndent = '    '; // Default to 4 spaces
+
+    if (isObject(doc.value)) {
+        if (doc.value.members && doc.value.members.length > 0) {
+            // Look at the prefix of the first member's key to detect indentation
+            const firstMemberRightPadded = doc.value.members[0];
+            const firstMember = firstMemberRightPadded.element as Json.Member;
+            const prefix = firstMember.key.element.prefix.whitespace;
+            // Extract just the spaces/tabs after the newline
+            const match = prefix.match(/\n([ \t]+)/);
+            if (match) {
+                return match[1];
+            }
+        }
+    } else if (isArray(doc.value)) {
+        if (doc.value.values && doc.value.values.length > 0) {
+            // Look at the prefix of the first array element to detect indentation
+            const firstElement = doc.value.values[0].element;
+            const prefix = firstElement.prefix.whitespace;
+            // Extract just the spaces/tabs after the newline
+            const match = prefix.match(/\n([ \t]+)/);
+            if (match) {
+                return match[1];
+            }
+        }
+    }
+
+    return defaultIndent;
+}
+
+/**
+ * Creates a RightPadded wrapper for a JSON element.
+ *
+ * @param element The JSON element to wrap
+ * @param after The trailing space after the element
+ * @param markers Optional markers to attach
+ * @returns A RightPadded wrapper containing the element
+ */
+export function rightPadded<T extends Json>(element: T, after: Json.Space, markers?: Markers): Json.RightPadded<T> {
+    return {
+        kind: Json.Kind.RightPadded,
+        element,
+        after,
+        markers: markers ?? emptyMarkers
+    };
+}

package/src/parser.ts

@@ -57,6 +57,23 @@ export abstract class Parser {
 
     abstract parse(...sourcePaths: ParserInput[]): AsyncGenerator<SourceFile>
 
+    /**
+     * Parses a single input and returns the first source file.
+     * This is a convenience method for when you know you're parsing exactly one input.
+     *
+     * @param input The input to parse
+     * @returns The parsed source file
+     * @throws Error if the parser produces no results
+     */
+    async parseOne(input: ParserInput): Promise<SourceFile> {
+        const result = await this.parse(input).next();
+        if (result.done) {
+            const sourcePath = typeof input === 'string' ? input : input.sourcePath;
+            throw new Error(`Parser produced no results for: ${sourcePath}`);
+        }
+        return result.value;
+    }
+
     protected relativePath(sourcePath: ParserInput): string {
         const path = typeof sourcePath === "string" ? sourcePath : sourcePath.sourcePath;
         return isAbsolute(path) && this.relativeTo ? relative(this.relativeTo, path) : path;

package/src/reference.ts

@@ -18,7 +18,7 @@ import {setAutoFreeze} from "immer";
 // this is required because otherwise `asRef()` won't work for objects created using immer
 setAutoFreeze(false);
 
-const REFERENCE_KEY = Symbol("org.openrewrite.rpc.Reference");
+const REFERENCE_KEY = Symbol.for("org.openrewrite.rpc.Reference");
 
 export interface Reference {
     [REFERENCE_KEY]: true;

package/src/visitor.ts

@@ -43,7 +43,7 @@ export async function produceAsync<Base extends Objectish>(
     return finishDraft(draft) as Base;
 }
 
-const stopAfterPreVisit = Symbol("STOP_AFTER_PRE_VISIT")
+const stopAfterPreVisit = Symbol.for("STOP_AFTER_PRE_VISIT")
 
 export abstract class TreeVisitor<T extends Tree, P> {
     protected cursor: Cursor = rootCursor();