@bian-womp/spark-graph 0.3.54 → 0.3.56

package/lib/cjs/index.cjs

@@ -1546,6 +1546,40 @@ class LevelLogger {
     error(message, context, overrideLevel) {
         this.log("error", message, context, overrideLevel);
     }
+    /**
+     * Tries to parse a string as JSON and format it nicely if it's fully JSON
+     */
+    parseJsonStringIfFull(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 {
+                const parsed = JSON.parse(trimmed);
+                return JSON.stringify(parsed, null, 2);
+            }
+            catch {
+                // If parsing fails, return original string
+                return str;
+            }
+        }
+        return str;
+    }
+    /**
+     * Parses JSON strings in context values if they are fully JSON
+     */
+    parseJsonStringsInContext(context) {
+        const parsed = {};
+        for (const [key, value] of Object.entries(context)) {
+            if (typeof value === "string") {
+                parsed[key] = this.parseJsonStringIfFull(value);
+            }
+            else {
+                parsed[key] = value;
+            }
+        }
+        return parsed;
+    }
     /**
      * Core logging method that respects the log level and applies prefix
      */
@@ -1559,12 +1593,31 @@ class LevelLogger {
         const effectiveValue = LevelLogger.levelValues[effectiveLevel] ?? 1;
         // Only log if the requested level is >= effective level
         if (requestedValue >= effectiveValue) {
-            const { formatJson, ...rest } = context ?? {};
-            const contextStr = rest && Object.keys(rest).length > 0
-                ? `${formatJson ? "\n" : " "}${Object.entries(rest)
-                    .map(([k, v]) => formatJson
-                    ? `${k}=${stringifySceneAndOps(v)}`
-                    : `${k}=${JSON.stringify(v)}`)
+            const { logFormat = "plain", ...rest } = context ?? {};
+            const formatJson = logFormat === "json" || logFormat === "json-deep";
+            const parseJsonString = logFormat === "json-deep";
+            // Parse JSON strings in context values if requested
+            let processedContext = rest;
+            if (parseJsonString && rest && Object.keys(rest).length > 0) {
+                processedContext = this.parseJsonStringsInContext(rest);
+            }
+            const contextStr = processedContext && Object.keys(processedContext).length > 0
+                ? `${formatJson ? "\n" : " "}${Object.entries(processedContext)
+                    .map(([k, v]) => {
+                    // 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
+                    if (parseJsonString &&
+                        typeof v === "string" &&
+                        v.trim().match(/^[{\[]/) &&
+                        v.includes("\n")) {
+                        return `${k}=${v}`;
+                    }
+                    if (formatJson) {
+                        return `${k}=${stringifySceneAndOps(v)}`;
+                    }
+                    return `${k}=${JSON.stringify(v)}`;
+                })
                     .join(formatJson ? "\n" : " ")}`
                 : "";
             const prefixedMessage = this.prefix
@@ -3751,11 +3804,11 @@ class GraphRuntime {
         if (!node)
             return undefined;
         return {
-            inputs: { ...node.inputs },
-            outputs: { ...node.outputs },
+            inputs: node.inputs,
+            outputs: node.outputs,
             state: node.state,
             params: node.params,
-            stats: { ...node.stats },
+            stats: node.stats,
         };
     }
     getEnvironment() {