@viji-dev/core 0.4.0 → 0.4.1

package/dist/{index-DZzYWg7c.js → index-G2N9Tgtd.js}

@@ -590,7 +590,7 @@ class IFrameManager {
 }
 function WorkerWrapper(options) {
   return new Worker(
-    "" + new URL("assets/viji.worker-BoI8e3NI.js", import.meta.url).href,
+    "" + new URL("assets/viji.worker-4gGFik2A.js", import.meta.url).href,
     {
       type: "module",
       name: options?.name
@@ -1752,7 +1752,7 @@ class EssentiaOnsetDetection {
     this.initPromise = (async () => {
       try {
         const essentiaModule = await import("./essentia.js-core.es-DnrJE0uR.js");
-        const wasmModule = await import("./essentia-wasm.web-CdUmKTbm.js").then((n) => n.e);
+        const wasmModule = await import("./essentia-wasm.web-CCpzl5zi.js").then((n) => n.e);
         const EssentiaClass = essentiaModule.Essentia || essentiaModule.default?.Essentia || essentiaModule.default;
         let WASMModule = wasmModule.default || wasmModule.EssentiaWASM || wasmModule.default?.EssentiaWASM;
         if (!WASMModule) {
@@ -3143,7 +3143,7 @@ class TempoInduction {
       candidates.push({ bpm: detectedBPM / 1.5, type: "other" });
     }
     for (const candidate of candidates) {
-      let existing = this.hypotheses.find(
+      const existing = this.hypotheses.find(
         (h) => Math.abs(h.bpm - candidate.bpm) / candidate.bpm < 0.05
       );
       if (existing) {
@@ -9721,27 +9721,30 @@ class SpectralClustering {
     const totalEnergy = onset.bands.reduce((a, b) => a + b, 0);
     if (totalEnergy < 0.01) return false;
     switch (label) {
-      case "kick":
+      case "kick": {
         if (low < 0.2 && lowMid < 0.25) {
           return false;
         }
         const bassEnergy = low + lowMid * 0.5;
         const bassRatio = bassEnergy / totalEnergy;
         return bassRatio > 0.3;
-      case "snare":
+      }
+      case "snare": {
         if (mid < 0.2) {
           return false;
         }
         const midEnergy = lowMid * 0.5 + mid + highMid * 0.3;
         const midRatio = midEnergy / totalEnergy;
         return midRatio > 0.25;
-      case "hat":
+      }
+      case "hat": {
         if (high < 0.2 && highMid < 0.25) {
           return false;
         }
         const trebleEnergy = highMid * 0.7 + high;
         const trebleRatio = trebleEnergy / totalEnergy;
         return trebleRatio > 0.35;
+      }
       default:
         return true;
     }
@@ -10905,7 +10908,7 @@ class BeatStateManager {
     const lowFloor = this.getAdaptiveFloor("low");
     const midFloor = this.getAdaptiveFloor("mid");
     const highFloor = this.getAdaptiveFloor("high");
-    let hasKickEnergy = lowEnergy > Math.max(3e-4, lowFloor * 1.02);
+    const hasKickEnergy = lowEnergy > Math.max(3e-4, lowFloor * 1.02);
     let hasSnareEnergy = midEnergy > Math.max(5e-5, midFloor * 1.15);
     let hasHatEnergy = highEnergy > Math.max(5e-6, highFloor * 0.6);
     const snareConfidence = Math.min(1, Math.max(0, (bands.mid.strength - 0.05) / 0.6));
@@ -11082,9 +11085,9 @@ class BeatStateManager {
         }
       }
     }
-    let kickFinal = kick;
-    let snareFinal = snare;
-    let hatFinal = hat;
+    const kickFinal = kick;
+    const snareFinal = snare;
+    const hatFinal = hat;
     const hasIOIHistory = kick || snare || hat;
     if ((kick || snare || hat) && hasIOIHistory) {
       if (kick) this.updateIOITracker("kick", now);
@@ -13462,7 +13465,7 @@ class AudioSystem {
               try {
                 ch.workletNode.port.onmessage = null;
                 ch.workletNode.disconnect();
-              } catch (_) {
+              } catch {
               }
               ch.workletNode = null;
             }
@@ -14591,6 +14594,256 @@ class SceneAnalyzer {
     return "2d";
   }
 }
+function parseColorInput(input) {
+  if (typeof input === "string") {
+    return parseColorString(input);
+  }
+  if (input && typeof input === "object") {
+    const obj = input;
+    const hasRgbKeys = "r" in obj && "g" in obj && "b" in obj;
+    const hasHsbKeys = "h" in obj && "s" in obj && "b" in obj;
+    if (hasHsbKeys && !("r" in obj) && !("g" in obj)) {
+      return hsbObjectToHex(obj);
+    }
+    if (hasRgbKeys) {
+      return rgbObjectToHex(obj);
+    }
+    throw new Error(
+      `Invalid color object: expected {r,g,b} or {h,s,b} keys, got ${JSON.stringify(input)}`
+    );
+  }
+  throw new Error(`Invalid color input: expected string or object, got ${typeof input}`);
+}
+function rgbToHex(r, g, b) {
+  const rByte = clampByte(r, "r");
+  const gByte = clampByte(g, "g");
+  const bByte = clampByte(b, "b");
+  return "#" + toHexByte(rByte) + toHexByte(gByte) + toHexByte(bByte);
+}
+function hsbToHex(h, s, b) {
+  if (typeof h !== "number" || typeof s !== "number" || typeof b !== "number" || !isFinite(h) || !isFinite(s) || !isFinite(b)) {
+    throw new Error(`Invalid HSB: h=${h}, s=${s}, b=${b}`);
+  }
+  if (s < 0 || s > 100) {
+    throw new Error(`HSB saturation must be 0..100, got: ${s}`);
+  }
+  if (b < 0 || b > 100) {
+    throw new Error(`HSB brightness must be 0..100, got: ${b}`);
+  }
+  const hue = (h % 360 + 360) % 360;
+  const sN = s / 100;
+  const bN = b / 100;
+  const c = bN * sN;
+  const hPrime = hue / 60;
+  const x = c * (1 - Math.abs(hPrime % 2 - 1));
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (hPrime < 1) {
+    r1 = c;
+    g1 = x;
+    b1 = 0;
+  } else if (hPrime < 2) {
+    r1 = x;
+    g1 = c;
+    b1 = 0;
+  } else if (hPrime < 3) {
+    r1 = 0;
+    g1 = c;
+    b1 = x;
+  } else if (hPrime < 4) {
+    r1 = 0;
+    g1 = x;
+    b1 = c;
+  } else if (hPrime < 5) {
+    r1 = x;
+    g1 = 0;
+    b1 = c;
+  } else {
+    r1 = c;
+    g1 = 0;
+    b1 = x;
+  }
+  const m = bN - c;
+  return rgbToHex(
+    Math.round((r1 + m) * 255),
+    Math.round((g1 + m) * 255),
+    Math.round((b1 + m) * 255)
+  );
+}
+function parseColorString(input) {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("#")) {
+    return parseHexString(trimmed);
+  }
+  const fnMatch = trimmed.match(/^(rgb|hsl|hsb|vec3)\s*\(([^)]*)\)$/i);
+  if (fnMatch) {
+    const fnName = fnMatch[1].toLowerCase();
+    const args = fnMatch[2];
+    switch (fnName) {
+      case "rgb":
+        return parseRgbFunction(args);
+      case "hsl":
+        return parseHslFunction(args);
+      case "hsb":
+        return parseHsbFunction(args);
+      case "vec3":
+        return parseVec3Function(args);
+    }
+  }
+  throw new Error(
+    `Invalid color string: '${input}'. Expected #rrggbb, #rgb, rgb(...), hsl(...), hsb(...), or vec3(...)`
+  );
+}
+function parseHexString(hex) {
+  if (/^#[0-9a-fA-F]{6}$/.test(hex)) {
+    return hex.toLowerCase();
+  }
+  if (/^#[0-9a-fA-F]{3}$/.test(hex)) {
+    const r = hex[1];
+    const g = hex[2];
+    const b = hex[3];
+    return ("#" + r + r + g + g + b + b).toLowerCase();
+  }
+  throw new Error(`Invalid hex color: '${hex}'. Expected #rrggbb or #rgb`);
+}
+function parseRgbFunction(args) {
+  const parts = splitArgs(args);
+  if (parts.length !== 3) {
+    throw new Error(`rgb() requires 3 arguments, got ${parts.length}: rgb(${args})`);
+  }
+  const r = parseNumber(parts[0], "r");
+  const g = parseNumber(parts[1], "g");
+  const b = parseNumber(parts[2], "b");
+  return rgbToHex(r, g, b);
+}
+function parseHslFunction(args) {
+  const parts = splitArgs(args);
+  if (parts.length !== 3) {
+    throw new Error(`hsl() requires 3 arguments, got ${parts.length}: hsl(${args})`);
+  }
+  const h = parseNumber(parts[0], "h");
+  const s = parsePercent(parts[1], "s");
+  const l = parsePercent(parts[2], "l");
+  return hslToHex(h, s, l);
+}
+function parseHsbFunction(args) {
+  const parts = splitArgs(args);
+  if (parts.length !== 3) {
+    throw new Error(`hsb() requires 3 arguments, got ${parts.length}: hsb(${args})`);
+  }
+  const h = parseNumber(parts[0], "h");
+  const s = parseNumber(parts[1], "s");
+  const b = parseNumber(parts[2], "b");
+  return hsbToHex(h, s, b);
+}
+function parseVec3Function(args) {
+  const parts = splitArgs(args);
+  if (parts.length !== 3) {
+    throw new Error(`vec3() requires 3 arguments, got ${parts.length}: vec3(${args})`);
+  }
+  const r = parseNumber(parts[0], "r");
+  const g = parseNumber(parts[1], "g");
+  const b = parseNumber(parts[2], "b");
+  if (r < 0 || r > 1 || g < 0 || g > 1 || b < 0 || b > 1) {
+    throw new Error(`vec3() components must be in 0..1, got: vec3(${r}, ${g}, ${b})`);
+  }
+  return rgbToHex(
+    Math.round(r * 255),
+    Math.round(g * 255),
+    Math.round(b * 255)
+  );
+}
+function rgbObjectToHex(obj) {
+  const r = numericField(obj.r, "r");
+  const g = numericField(obj.g, "g");
+  const b = numericField(obj.b, "b");
+  return rgbToHex(r, g, b);
+}
+function hsbObjectToHex(obj) {
+  const h = numericField(obj.h, "h");
+  const s = numericField(obj.s, "s");
+  const b = numericField(obj.b, "b");
+  return hsbToHex(h, s, b);
+}
+function hslToHex(h, s, l) {
+  if (s < 0 || s > 100) {
+    throw new Error(`HSL saturation must be 0..100%, got: ${s}%`);
+  }
+  if (l < 0 || l > 100) {
+    throw new Error(`HSL lightness must be 0..100%, got: ${l}%`);
+  }
+  const hue = (h % 360 + 360) % 360;
+  const sN = s / 100;
+  const lN = l / 100;
+  const c = (1 - Math.abs(2 * lN - 1)) * sN;
+  const hPrime = hue / 60;
+  const x = c * (1 - Math.abs(hPrime % 2 - 1));
+  let r1 = 0, g1 = 0, b1 = 0;
+  if (hPrime < 1) {
+    r1 = c;
+    g1 = x;
+    b1 = 0;
+  } else if (hPrime < 2) {
+    r1 = x;
+    g1 = c;
+    b1 = 0;
+  } else if (hPrime < 3) {
+    r1 = 0;
+    g1 = c;
+    b1 = x;
+  } else if (hPrime < 4) {
+    r1 = 0;
+    g1 = x;
+    b1 = c;
+  } else if (hPrime < 5) {
+    r1 = x;
+    g1 = 0;
+    b1 = c;
+  } else {
+    r1 = c;
+    g1 = 0;
+    b1 = x;
+  }
+  const m = lN - c / 2;
+  return rgbToHex(
+    Math.round((r1 + m) * 255),
+    Math.round((g1 + m) * 255),
+    Math.round((b1 + m) * 255)
+  );
+}
+function splitArgs(args) {
+  return args.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function parseNumber(token, fieldName) {
+  const n = parseFloat(token);
+  if (!isFinite(n)) {
+    throw new Error(`Invalid number for '${fieldName}': '${token}'`);
+  }
+  return n;
+}
+function parsePercent(token, fieldName) {
+  if (!token.endsWith("%")) {
+    throw new Error(`Field '${fieldName}' must use percent notation (e.g., 50%), got: '${token}'`);
+  }
+  return parseNumber(token.slice(0, -1), fieldName);
+}
+function numericField(value, fieldName) {
+  if (typeof value !== "number" || !isFinite(value)) {
+    throw new Error(`Invalid color field '${fieldName}': expected finite number, got ${value}`);
+  }
+  return value;
+}
+function clampByte(value, fieldName) {
+  if (typeof value !== "number" || !isFinite(value)) {
+    throw new Error(`RGB component '${fieldName}' must be a finite number, got: ${value}`);
+  }
+  if (value < 0 || value > 255) {
+    throw new Error(`RGB component '${fieldName}' must be 0..255, got: ${value}`);
+  }
+  return Math.round(value);
+}
+function toHexByte(byte) {
+  return byte.toString(16).padStart(2, "0");
+}
 const simdLoaderJs = new URL("assets/wasm/vision_wasm_internal.js", import.meta.url).href;
 const simdBinary = new URL("assets/wasm/vision_wasm_internal.wasm", import.meta.url).href;
 const nosimdLoaderJs = new URL("assets/wasm/vision_wasm_nosimd_internal.js", import.meta.url).href;
@@ -15160,6 +15413,29 @@ class VijiCore {
     }
     return void 0;
   }
+  /**
+   * For color parameters, accept rich input forms (hex, RGB/HSB objects, CSS / GLSL strings)
+   * and normalize them to canonical lowercase hex `#rrggbb` before they go on the wire.
+   * This keeps the host<->worker contract simple (always a hex string) while letting
+   * external callers use whichever form is most convenient.
+   *
+   * Non-color values are returned unchanged.
+   */
+  normalizeColorInputIfNeeded(name, value) {
+    const def = this.getParameterDefinition(name);
+    if (def?.type !== "color") {
+      return value;
+    }
+    try {
+      return parseColorInput(value);
+    } catch (err) {
+      throw new VijiCoreError(
+        `Invalid color value for parameter '${name}': ${err.message}`,
+        "INVALID_COLOR_VALUE",
+        { name, value }
+      );
+    }
+  }
   /**
    * Set a single parameter value
    * Handles all parameter types including images intelligently
@@ -15177,17 +15453,18 @@ class VijiCore {
       await this.handleImageParameter(name, value);
       return;
     }
+    const normalizedValue = this.normalizeColorInputIfNeeded(name, value);
     const oldValue = this.parameterValues.get(name);
-    this.parameterValues.set(name, value);
+    this.parameterValues.set(name, normalizedValue);
     if (this.workerManager) {
       this.workerManager.postMessage("parameter-update", {
         name,
-        value
+        value: normalizedValue
       });
     }
-    const isEqual = paramDef?.type === "coordinate" ? isCoordinateValueEqual(oldValue, value) : oldValue === value;
+    const isEqual = paramDef?.type === "coordinate" ? isCoordinateValueEqual(oldValue, normalizedValue) : oldValue === normalizedValue;
     if (!isEqual) {
-      this.notifyParameterListeners(name, value);
+      this.notifyParameterListeners(name, normalizedValue);
     }
   }
   /**
@@ -15249,7 +15526,10 @@ class VijiCore {
     }
   }
   /**
-   * Set multiple parameter values efficiently
+   * Set multiple parameter values efficiently.
+   *
+   * For color parameters, accepts the same rich input forms as `setParameter`
+   * (hex, RGB/HSB objects, CSS / GLSL strings); they are normalized to canonical hex.
    */
   async setParameters(values) {
     this.validateReady();
@@ -15263,16 +15543,17 @@ class VijiCore {
         console.warn(`Unknown parameter: ${name}`);
         continue;
       }
+      const normalizedValue = this.normalizeColorInputIfNeeded(name, value);
       const oldValue = this.parameterValues.get(name);
-      this.parameterValues.set(name, value);
+      this.parameterValues.set(name, normalizedValue);
       updates.push({
         name,
-        value
+        value: normalizedValue
       });
       const paramDef = this.getParameterDefinition(name);
-      const isEqual = paramDef?.type === "coordinate" ? isCoordinateValueEqual(oldValue, value) : oldValue === value;
+      const isEqual = paramDef?.type === "coordinate" ? isCoordinateValueEqual(oldValue, normalizedValue) : oldValue === normalizedValue;
       if (!isEqual) {
-        changedParams.push({ name, value });
+        changedParams.push({ name, value: normalizedValue });
       }
     }
     if (updates.length > 0 && this.workerManager) {
@@ -16192,7 +16473,7 @@ class VijiCore {
   async detectScreenRefreshRate() {
     return new Promise((resolve) => {
       let frameCount = 0;
-      let startTime = performance.now();
+      const startTime = performance.now();
       const measureFrames = () => {
         frameCount++;
         if (frameCount === 60) {
@@ -16467,4 +16748,4 @@ export {
   VijiCoreError as b,
   getDefaultExportFromCjs as g
 };
-//# sourceMappingURL=index-DZzYWg7c.js.map
+//# sourceMappingURL=index-G2N9Tgtd.js.map