@bian-womp/spark-graph 0.3.56 → 0.3.58

package/lib/cjs/index.cjs

@@ -1565,8 +1565,28 @@ class LevelLogger {
         }
         return str;
     }
+    /**
+     * Tries to parse a string as JSON and return the parsed object/array if it's fully JSON
+     * Used for parsing JSON strings inside arrays so they can be formatted by stringifySceneAndOps
+     */
+    parseJsonStringToObject(str) {
+        const trimmed = str.trim();
+        // Check if the string starts with { or [ and ends with } or ]
+        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+            try {
+                return JSON.parse(trimmed);
+            }
+            catch {
+                // If parsing fails, return original string
+                return str;
+            }
+        }
+        return str;
+    }
     /**
      * Parses JSON strings in context values if they are fully JSON
+     * Also handles arrays containing JSON strings
      */
     parseJsonStringsInContext(context) {
         const parsed = {};
@@ -1574,6 +1594,16 @@ class LevelLogger {
             if (typeof value === "string") {
                 parsed[key] = this.parseJsonStringIfFull(value);
             }
+            else if (Array.isArray(value)) {
+                // Process arrays: parse JSON strings within the array to objects/arrays
+                // so they can be formatted correctly by stringifySceneAndOps
+                parsed[key] = value.map((item) => {
+                    if (typeof item === "string") {
+                        return this.parseJsonStringToObject(item);
+                    }
+                    return item;
+                });
+            }
             else {
                 parsed[key] = value;
             }
@@ -1598,7 +1628,43 @@ class LevelLogger {
             const parseJsonString = logFormat === "json-deep";
             // Parse JSON strings in context values if requested
             let processedContext = rest;
+            const parsedKeys = new Set(); // Track keys that had JSON strings parsed
             if (parseJsonString && rest && Object.keys(rest).length > 0) {
+                // Check which keys had JSON strings before parsing
+                for (const [key, value] of Object.entries(rest)) {
+                    if (typeof value === "string") {
+                        const trimmed = value.trim();
+                        if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+                            (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+                            try {
+                                JSON.parse(trimmed);
+                                parsedKeys.add(key);
+                            }
+                            catch {
+                                // Not valid JSON, skip
+                            }
+                        }
+                    }
+                    else if (Array.isArray(value)) {
+                        // Check if array contains JSON strings
+                        for (const item of value) {
+                            if (typeof item === "string") {
+                                const trimmed = item.trim();
+                                if ((trimmed.startsWith("{") && trimmed.endsWith("}")) ||
+                                    (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+                                    try {
+                                        JSON.parse(trimmed);
+                                        parsedKeys.add(key);
+                                        break; // Found at least one JSON string in array
+                                    }
+                                    catch {
+                                        // Not valid JSON, continue
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
                 processedContext = this.parseJsonStringsInContext(rest);
             }
             const contextStr = processedContext && Object.keys(processedContext).length > 0
@@ -1607,11 +1673,17 @@ class LevelLogger {
                     // If parseJsonString is enabled and value is a formatted JSON string
                     // (starts with { or [ and contains newlines indicating it was formatted),
                     // output it directly without stringifySceneAndOps to preserve formatting
+                    // Wrap it with json`...` to distinguish it as formatted JSON
                     if (parseJsonString &&
                         typeof v === "string" &&
                         v.trim().match(/^[{\[]/) &&
                         v.includes("\n")) {
-                        return `${k}=${v}`;
+                        return `${k}=json\`${v}\``;
+                    }
+                    // If this key had a JSON string parsed and we're formatting JSON,
+                    // wrap the formatted output with json`...`
+                    if (formatJson && parseJsonString && parsedKeys.has(k)) {
+                        return `${k}=json\`${stringifySceneAndOps(v)}\``;
                     }
                     if (formatJson) {
                         return `${k}=${stringifySceneAndOps(v)}`;