@bian-womp/spark-graph 0.3.82 → 0.3.83

package/lib/cjs/index.cjs

@@ -1438,9 +1438,52 @@ function stringifySceneAndOps(obj) {
 /**
  * A reusable logger class that supports configurable log levels and prefixes.
  * Can be instantiated with a default log level and optionally override per call.
+ *
+ * Dynamic log-level rules:
+ * - Rules are configured once via `LevelLogger.setDynamicLevelRules(raw)`.
+ * - Rules can also be configured per logger instance via `setInstanceDynamicLevelRules(raw)`.
+ * - Rules are compiled into a static runtime-friendly structure for fast matching.
+ * - On every log call, logger resolves dynamic level by rule match:
+ *   `overrideLevel` > instance rule > global rule > logger default.
+ *
+ * Rule format (raw):
+ * [
+ *   {
+ *     "name": "optional label",
+ *     "enabled": true,
+ *     "setLevel": "debug",
+ *     "when": {
+ *       "prefix": { "startsWith": ["[node:scene.importAsset"] },
+ *       "message": { "startsWith": ["computeAssetSyncStatus"] }
+ *     }
+ *   }
+ * ]
+ *
+ * Matching semantics:
+ * - Rules are evaluated in order; first match wins.
+ * - `prefix` and `message` conditions are AND-ed when both exist.
+ * - Within each operator list (`startsWith`, `contains`, etc.), values are OR-ed.
+ * - If multiple operators are defined in one block, all operators must pass.
+ * - `not` negates an additional matcher block.
+ * - String matching is case-insensitive; regex is used as provided.
+ *
+ * Priority strategy (fixed):
+ * - `overrideLevel` > first matching instance rule > first matching global rule > logger default.
  */
 class LevelLogger {
+    /**
+     * Updates static dynamic level rules from raw settings input.
+     * Accepts either:
+     * - a JSON string containing an array of rules
+     * - an in-memory array of rules
+     *
+     * Invalid rules are ignored; parse errors clear rules and warn.
+     */
+    static setDynamicLevelRules(raw) {
+        LevelLogger.compiledDynamicLevelRules = LevelLogger.compileDynamicLevelRulesFromRaw(raw);
+    }
     constructor(defaultLevel = "info", prefix = "") {
+        this.compiledInstanceDynamicLevelRules = [];
         this.defaultLevel = defaultLevel;
         this.prefix = prefix;
     }
@@ -1471,29 +1514,179 @@ class LevelLogger {
     getLevelValue() {
         return LevelLogger.levelValues[this.defaultLevel];
     }
+    /**
+     * Sets per-instance dynamic rules. These are evaluated along with global rules
+     * using the active priority preset.
+     */
+    setInstanceDynamicLevelRules(raw) {
+        this.compiledInstanceDynamicLevelRules = LevelLogger.compileDynamicLevelRulesFromRaw(raw);
+    }
+    static isRecord(value) {
+        return value !== null && typeof value === "object";
+    }
+    static isLogLevel(value) {
+        return typeof value === "string" && value in LevelLogger.levelValues;
+    }
+    static normalizeStringArray(input) {
+        if (typeof input === "string")
+            return [input];
+        if (!Array.isArray(input))
+            return [];
+        return input.filter((v) => typeof v === "string");
+    }
+    static compileRegexArray(input) {
+        const patterns = LevelLogger.normalizeStringArray(input);
+        const compiled = [];
+        for (const pattern of patterns) {
+            try {
+                compiled.push(new RegExp(pattern));
+            }
+            catch (err) {
+                console.warn(`[LevelLogger] Invalid regex in dynamic level rule: ${pattern}`, err);
+            }
+        }
+        return compiled;
+    }
+    static compileMatchRule(input) {
+        if (!LevelLogger.isRecord(input))
+            return undefined;
+        const equals = LevelLogger.normalizeStringArray(input.equals).map((v) => v.toLowerCase());
+        const startsWith = LevelLogger.normalizeStringArray(input.startsWith).map((v) => v.toLowerCase());
+        const contains = LevelLogger.normalizeStringArray(input.contains).map((v) => v.toLowerCase());
+        const regex = LevelLogger.compileRegexArray(input.regex);
+        let not;
+        if (LevelLogger.isRecord(input.not)) {
+            not = {
+                equals: LevelLogger.normalizeStringArray(input.not.equals).map((v) => v.toLowerCase()),
+                startsWith: LevelLogger.normalizeStringArray(input.not.startsWith).map((v) => v.toLowerCase()),
+                contains: LevelLogger.normalizeStringArray(input.not.contains).map((v) => v.toLowerCase()),
+                regex: LevelLogger.compileRegexArray(input.not.regex),
+            };
+        }
+        if (!equals.length && !startsWith.length && !contains.length && !regex.length && !not)
+            return undefined;
+        return { equals, startsWith, contains, regex, not };
+    }
+    static compileDynamicLevelRules(raw) {
+        if (!Array.isArray(raw)) {
+            console.warn("[LevelLogger] Dynamic level rules must be an array. Ignoring value.");
+            return [];
+        }
+        const compiled = [];
+        for (const item of raw) {
+            if (!LevelLogger.isRecord(item))
+                continue;
+            if (item.enabled === false)
+                continue;
+            if (!LevelLogger.isLogLevel(item.setLevel))
+                continue;
+            let when;
+            if (LevelLogger.isRecord(item.when)) {
+                const prefix = LevelLogger.compileMatchRule(item.when.prefix);
+                const message = LevelLogger.compileMatchRule(item.when.message);
+                if (prefix || message)
+                    when = { prefix, message };
+            }
+            compiled.push({
+                name: typeof item.name === "string" ? item.name : undefined,
+                setLevel: item.setLevel,
+                when,
+            });
+        }
+        return compiled;
+    }
+    static compileDynamicLevelRulesFromRaw(raw) {
+        if (raw === undefined || raw === null || raw === "")
+            return [];
+        let parsed = raw;
+        if (typeof raw === "string") {
+            try {
+                parsed = JSON.parse(raw);
+            }
+            catch (err) {
+                console.warn("[LevelLogger] Failed to parse dynamic level rules JSON:", err);
+                return [];
+            }
+        }
+        return LevelLogger.compileDynamicLevelRules(parsed);
+    }
+    static matchesCompiledMatchRule(rule, value, valueLower) {
+        if (!rule)
+            return true;
+        const lower = valueLower ?? value.toLowerCase();
+        if (rule.equals.length > 0 && !rule.equals.some((candidate) => lower === candidate))
+            return false;
+        if (rule.startsWith.length > 0 && !rule.startsWith.some((candidate) => lower.startsWith(candidate)))
+            return false;
+        if (rule.contains.length > 0 && !rule.contains.some((candidate) => lower.includes(candidate)))
+            return false;
+        if (rule.regex.length > 0 && !rule.regex.some((re) => re.test(value)))
+            return false;
+        if (rule.not) {
+            const notMatches = (rule.not.equals.length > 0 && rule.not.equals.some((candidate) => lower === candidate)) ||
+                (rule.not.startsWith.length > 0 && rule.not.startsWith.some((candidate) => lower.startsWith(candidate))) ||
+                (rule.not.contains.length > 0 && rule.not.contains.some((candidate) => lower.includes(candidate))) ||
+                (rule.not.regex.length > 0 && rule.not.regex.some((re) => re.test(value)));
+            if (notMatches)
+                return false;
+        }
+        return true;
+    }
+    static resolveDynamicLevelFromRules(prefix, message, rules) {
+        const prefixLower = prefix.toLowerCase();
+        const messageLower = message.toLowerCase();
+        for (const rule of rules) {
+            const prefixMatch = LevelLogger.matchesCompiledMatchRule(rule.when?.prefix, prefix, prefixLower);
+            if (!prefixMatch)
+                continue;
+            const messageMatch = LevelLogger.matchesCompiledMatchRule(rule.when?.message, message, messageLower);
+            if (!messageMatch)
+                continue;
+            return rule.setLevel;
+        }
+        return undefined;
+    }
+    static resolveDynamicLevel(prefix, message) {
+        return LevelLogger.resolveDynamicLevelFromRules(prefix, message, LevelLogger.compiledDynamicLevelRules);
+    }
+    resolveEffectiveLevel(message, overrideLevel) {
+        if (overrideLevel)
+            return overrideLevel;
+        const instanceDynamic = LevelLogger.resolveDynamicLevelFromRules(this.prefix, message, this.compiledInstanceDynamicLevelRules);
+        const globalDynamic = LevelLogger.resolveDynamicLevel(this.prefix, message);
+        return instanceDynamic ?? globalDynamic ?? this.defaultLevel;
+    }
     /**
      * Logs a debug message
      */
     debug(message, context, overrideLevel) {
-        this.log("debug", message, context, overrideLevel);
+        this._log("debug", message, context, overrideLevel);
     }
     /**
      * Logs an info message
      */
     info(message, context, overrideLevel) {
-        this.log("info", message, context, overrideLevel);
+        this._log("info", message, context, overrideLevel);
     }
     /**
      * Logs a warning message
      */
     warn(message, context, overrideLevel) {
-        this.log("warn", message, context, overrideLevel);
+        this._log("warn", message, context, overrideLevel);
     }
     /**
      * Logs an error message
      */
     error(message, context, overrideLevel) {
-        this.log("error", message, context, overrideLevel);
+        this._log("error", message, context, overrideLevel);
+    }
+    /**
+     * Logs a message at the specified level
+     */
+    log(level, message, context, overrideLevel) {
+        if (level === "silent")
+            return;
+        this._log(level, message, context, overrideLevel);
     }
     /**
      * Tries to parse a string as JSON and format it nicely if it's fully JSON
@@ -1560,8 +1753,8 @@ class LevelLogger {
     /**
      * Core logging method that respects the log level and applies prefix
      */
-    log(requestedLevel, message, context, overrideLevel) {
-        const effectiveLevel = overrideLevel ?? this.defaultLevel;
+    _log(requestedLevel, message, context, overrideLevel) {
+        const effectiveLevel = this.resolveEffectiveLevel(message, overrideLevel);
         // Silent level suppresses all logs
         if (effectiveLevel === "silent") {
             return;
@@ -1654,6 +1847,7 @@ class LevelLogger {
         }
     }
 }
+LevelLogger.compiledDynamicLevelRules = [];
 /**
  * Maps log levels to numeric values for comparison
  */
@@ -3001,20 +3195,7 @@ class NodeExecutor {
         const nodeLogLevel = node?.logLevel ?? "info";
         const logger = new LevelLogger(nodeLogLevel, `[node:${formatNodeRef(this.graph, nodeId)}:${runId}]`);
         const log = (level, message, context) => {
-            switch (level) {
-                case "debug":
-                    logger.debug(message, context);
-                    break;
-                case "info":
-                    logger.info(message, context);
-                    break;
-                case "warn":
-                    logger.warn(message, context);
-                    break;
-                case "error":
-                    logger.error(message, context);
-                    break;
-            }
+            logger.log(level, message, context);
         };
         return {
             nodeId,