@viji-dev/core 0.3.39 → 0.4.1

package/dist/assets/{viji.worker-BoI8e3NI.js → viji.worker-4gGFik2A.js}

@@ -1,3 +1,300 @@
+function parseColorInput(input2) {
+  if (typeof input2 === "string") {
+    return parseColorString(input2);
+  }
+  if (input2 && typeof input2 === "object") {
+    const obj = input2;
+    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(input2)}`
+    );
+  }
+  throw new Error(`Invalid color input: expected string or object, got ${typeof input2}`);
+}
+function hexToRgb255(hex) {
+  const m = /^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i.exec(hex);
+  if (!m) {
+    throw new Error(`Expected canonical hex '#rrggbb', got: ${hex}`);
+  }
+  return {
+    r: parseInt(m[1], 16),
+    g: parseInt(m[2], 16),
+    b: parseInt(m[3], 16)
+  };
+}
+function hexToHsb(hex) {
+  const { r, g, b } = hexToRgb255(hex);
+  const rN = r / 255;
+  const gN = g / 255;
+  const bN = b / 255;
+  const max = Math.max(rN, gN, bN);
+  const min = Math.min(rN, gN, bN);
+  const delta = max - min;
+  let h = 0;
+  if (delta > 0) {
+    if (max === rN) {
+      h = (gN - bN) / delta % 6;
+    } else if (max === gN) {
+      h = (bN - rN) / delta + 2;
+    } else {
+      h = (rN - gN) / delta + 4;
+    }
+    h *= 60;
+    if (h < 0) h += 360;
+  }
+  const s = max === 0 ? 0 : delta / max * 100;
+  const brightness = max * 100;
+  return {
+    h: roundTo(h, 4),
+    s: roundTo(s, 4),
+    b: roundTo(brightness, 4)
+  };
+}
+function hexToRgb01(hex) {
+  const { r, g, b } = hexToRgb255(hex);
+  return [r / 255, g / 255, b / 255];
+}
+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(input2) {
+  const trimmed = input2.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: '${input2}'. 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");
+}
+function roundTo(value, digits) {
+  const factor = 10 ** digits;
+  return Math.round(value * factor) / factor;
+}
 class ParameterSystem {
   // Parameter system for Phase 2 (new object-based approach)
   parameterDefinitions = /* @__PURE__ */ new Map();
@@ -61,8 +358,11 @@ class ParameterSystem {
   }
   createColorParameter(defaultValue, config) {
     const paramName = config.label;
+    const hex = parseColorInput(defaultValue);
     const colorObject = {
-      value: defaultValue,
+      value: hex,
+      rgb: Object.freeze(hexToRgb255(hex)),
+      hsb: Object.freeze(hexToHsb(hex)),
       label: config.label,
       description: config.description ?? "",
       group: config.group ?? "general",
@@ -70,7 +370,7 @@ class ParameterSystem {
     };
     const definition = {
       type: "color",
-      defaultValue,
+      defaultValue: hex,
       label: colorObject.label,
       description: colorObject.description,
       group: colorObject.group,
@@ -259,6 +559,14 @@ class ParameterSystem {
       console.warn(`Unknown parameter: ${name}. Available parameters:`, Array.from(this.parameterDefinitions.keys()));
       return false;
     }
+    if (definition.type === "color") {
+      try {
+        value = parseColorInput(value);
+      } catch (err) {
+        console.error(`Parameter '${name}' invalid color: ${err.message}`);
+        return false;
+      }
+    }
     if (!this.validateParameterValue(name, value, definition)) {
       console.warn(`Validation failed for parameter ${name} = ${value}`);
       return false;
@@ -273,6 +581,11 @@ class ParameterSystem {
     const parameterObject = this.parameterObjects.get(name);
     if (parameterObject) {
       parameterObject.value = value;
+      if (definition.type === "color") {
+        const hex = value;
+        parameterObject.rgb = Object.freeze(hexToRgb255(hex));
+        parameterObject.hsb = Object.freeze(hexToHsb(hex));
+      }
     }
     return true;
   }
@@ -298,8 +611,8 @@ class ParameterSystem {
         }
         break;
       case "color":
-        if (typeof value !== "string" || !/^#[0-9A-Fa-f]{6}$/.test(value)) {
-          console.error(`Parameter '${name}' must be a valid hex color, got: ${value}`);
+        if (typeof value !== "string" || !/^#[0-9a-f]{6}$/.test(value)) {
+          console.error(`Parameter '${name}' must be normalized lowercase hex '#rrggbb', got: ${value}`);
           return false;
         }
         break;
@@ -337,7 +650,7 @@ class ParameterSystem {
           return false;
         }
         break;
-      case "coordinate":
+      case "coordinate": {
         if (!value || typeof value !== "object" || !("x" in value) || !("y" in value)) {
           console.error(`Parameter '${name}' must be an object with x and y properties, got: ${value}`);
           return false;
@@ -352,6 +665,7 @@ class ParameterSystem {
           return false;
         }
         break;
+      }
     }
     return true;
   }
@@ -2298,7 +2612,7 @@ class ShaderParameterParser {
    */
   static parseKeyValuePairs(configStr) {
     const config = {};
-    const keyValueRegex = /(\w+):((?:"[^"]*"|\[[^\]]*\]|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|[^\s]+))/g;
+    const keyValueRegex = /(\w+):((?:"[^"]*"|\[[^\]]*\]|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{3}|(?:rgb|hsl|hsb|vec3)\s*\([^)]*\)|[^\s]+))/g;
     let match2;
     while ((match2 = keyValueRegex.exec(configStr)) !== null) {
       const [, key, value] = match2;
@@ -2330,6 +2644,9 @@ class ShaderParameterParser {
     if (value.startsWith("#")) {
       return value;
     }
+    if (/^(?:rgb|hsl|hsb|vec3)\s*\(/i.test(value)) {
+      return value;
+    }
     if (value === "true") return true;
     if (value === "false") return false;
     const num = parseFloat(value);
@@ -2360,8 +2677,12 @@ class ShaderParameterParser {
         if (param.config.default === void 0) {
           throw new Error(`Parameter ${param.uniformName} of type 'color' missing required 'default' key`);
         }
-        if (!param.config.default.startsWith("#")) {
-          throw new Error(`Parameter ${param.uniformName} of type 'color' default must be hex color (e.g., #ff0000)`);
+        try {
+          param.config.default = parseColorInput(param.config.default);
+        } catch (err) {
+          throw new Error(
+            `Parameter ${param.uniformName} of type 'color' has invalid default: ${err.message}`
+          );
         }
         break;
       case "toggle":
@@ -2516,6 +2837,10 @@ class ShaderWorkerAdapter {
   accumulatorWarned = /* @__PURE__ */ new Set();
   // Cache of scalar uniform values for accumulator built-in rate lookups
   scalarUniformCache = /* @__PURE__ */ new Map();
+  // Cache of hex -> normalized [r, g, b] (0..1) for color uniforms.
+  // Avoids re-parsing the hex string on every frame; invalidated when the hex value changes.
+  colorVec3Cache = /* @__PURE__ */ new Map();
+  colorVec3CacheKey = /* @__PURE__ */ new Map();
   // Backbuffer support (ping-pong framebuffers)
   backbufferFramebuffer = null;
   backbufferTexture = null;
@@ -3746,17 +4071,23 @@ ${error}`);
         case "number":
           this.setUniform(param.uniformName, "float", value);
           break;
-        case "color":
-          const rgb = this.hexToRgb(value);
-          this.setUniform(param.uniformName, "vec3", rgb);
+        case "color": {
+          const hex = value;
+          if (this.colorVec3CacheKey.get(param.uniformName) !== hex) {
+            this.colorVec3Cache.set(param.uniformName, hexToRgb01(hex));
+            this.colorVec3CacheKey.set(param.uniformName, hex);
+          }
+          this.setUniform(param.uniformName, "vec3", this.colorVec3Cache.get(param.uniformName));
           break;
+        }
         case "toggle":
           this.setUniform(param.uniformName, "bool", value);
           break;
-        case "select":
+        case "select": {
           const index = param.config.options?.indexOf(value) || 0;
           this.setUniform(param.uniformName, "int", index);
           break;
+        }
         case "image":
           if (value) {
             this.updateImageTexture(param.uniformName, value);
@@ -3827,20 +4158,6 @@ ${error}`);
         break;
     }
   }
-  /**
-   * Convert hex color to RGB [0-1]
-   */
-  hexToRgb(hex) {
-    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    if (result) {
-      return [
-        parseInt(result[1], 16) / 255,
-        parseInt(result[2], 16) / 255,
-        parseInt(result[3], 16) / 255
-      ];
-    }
-    return [0, 0, 0];
-  }
   /**
    * Update audio FFT texture
    */
@@ -27128,4 +27445,4 @@ async function setSceneCode(sceneCode) {
   }
 }
 self.setSceneCode = setSceneCode;
-//# sourceMappingURL=viji.worker-BoI8e3NI.js.map
+//# sourceMappingURL=viji.worker-4gGFik2A.js.map