@openrewrite/rewrite 8.68.0-20251202-082117 → 8.68.0-20251202-154952

package/src/javascript/templating/engine.ts

@@ -136,7 +136,7 @@ class TemplateCache {
         // the same dependencies will automatically share the same workspace
         let workspaceDir: string | undefined;
         if (dependencies && Object.keys(dependencies).length > 0) {
-            workspaceDir = await DependencyWorkspace.getOrCreateWorkspace(dependencies);
+            workspaceDir = await DependencyWorkspace.getOrCreateWorkspace({dependencies});
         }
 
         // Prepend context statements for type attribution context

package/src/json/parser.ts

@@ -119,8 +119,25 @@ class ParseJsonReader extends ParserSourceReader {
                 source: parsed.toString(),
                 value: parsed,
             } satisfies Json.Literal as Json.Literal;
+        } else if (typeof parsed === "boolean") {
+            const source = parsed ? "true" : "false";
+            this.cursor += source.length;
+            return {
+                kind: Json.Kind.Literal,
+                ...base,
+                source,
+                value: parsed,
+            } satisfies Json.Literal as Json.Literal;
+        } else if (parsed === null) {
+            this.cursor += 4; // "null".length
+            return {
+                kind: Json.Kind.Literal,
+                ...base,
+                source: "null",
+                value: null,
+            } satisfies Json.Literal as Json.Literal;
         } else {
-            throw new Error(`Unsupported JSON type: ${parsed}`);
+            throw new Error(`Unsupported JSON type: ${typeof parsed}`);
         }
     }
 

package/src/json/tree.ts

@@ -32,7 +32,7 @@ export namespace Json {
         Object: "org.openrewrite.json.tree.Json$JsonObject",
         Space: "org.openrewrite.json.tree.Space",
         Comment: "org.openrewrite.json.tree.Comment",
-        RightPadded: "org.openrewrite.json.tree.RightPadded"
+        RightPadded: "org.openrewrite.json.tree.JsonRightPadded"
     } as const
 
     export type Key = Identifier | Literal

package/src/parser.ts

@@ -131,7 +131,7 @@ export function readSourceSync(sourcePath: ParserInput) {
 
 type ParserConstructor<T extends Parser> = new (options?: ParserOptions) => T;
 
-export type ParserType = "javascript";
+export type ParserType = "javascript" | "packageJson";
 
 export class Parsers {
     private static registry = new Map<ParserType, ParserConstructor<Parser>>();

package/src/rpc/request/parse.ts

@@ -15,17 +15,30 @@
  */
 import * as rpc from "vscode-jsonrpc/node";
 import {ExecutionContext} from "../../execution";
-import {ParserInput, Parsers} from "../../parser";
+import {ParserInput, parserInputFile, Parsers, ParserType} from "../../parser";
 import {randomId, UUID} from "../../uuid";
 import {produce} from "immer";
 import {SourceFile} from "../../tree";
 import {withMetrics} from "./metrics";
+import * as path from "path";
 
 export class Parse {
     constructor(private readonly inputs: ParserInput[],
                 private readonly relativeTo?: string) {
     }
 
+    /**
+     * Determines the parser type based on the file path.
+     */
+    private static getParserType(input: ParserInput): ParserType {
+        const filePath = parserInputFile(input);
+        const fileName = path.basename(filePath);
+        if (fileName === 'package.json') {
+            return "packageJson";
+        }
+        return "javascript";
+    }
+
     static handle(connection: rpc.MessageConnection,
                   localObjects: Map<string, ((input: string) => any) | any>,
                   metricsCsv?: string): void {
@@ -40,7 +53,12 @@ export class Parse {
                         typeof input === 'string' ? input : input.sourcePath
                     ).join(',');
 
-                    const parser = Parsers.createParser("javascript", {
+                    // Derive parser type from the first input's file path
+                    const parserType = request.inputs.length > 0
+                        ? Parse.getParserType(request.inputs[0])
+                        : "javascript";
+
+                    const parser = Parsers.createParser(parserType, {
                         ctx: new ExecutionContext(),
                         relativeTo: request.relativeTo
                     })!;