@bian-womp/spark-graph 0.3.55 → 0.3.57

package/lib/cjs/index.cjs

@@ -1546,6 +1546,70 @@ 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;
+    }
+    /**
+     * 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 = {};
+        for (const [key, value] of Object.entries(context)) {
+            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;
+            }
+        }
+        return parsed;
+    }
     /**
      * Core logging method that respects the log level and applies prefix
      */
@@ -1559,12 +1623,73 @@ 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;
+            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
+                ? `${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
+                    // Wrap it with json`...` to distinguish it as formatted JSON
+                    if (parseJsonString &&
+                        typeof v === "string" &&
+                        v.trim().match(/^[{\[]/) &&
+                        v.includes("\n")) {
+                        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)}`;
+                    }
+                    return `${k}=${JSON.stringify(v)}`;
+                })
                     .join(formatJson ? "\n" : " ")}`
                 : "";
             const prefixedMessage = this.prefix