vim-web 0.5.0-dev.5 → 0.5.0-dev.7

package/dist/vim-web.iife.js

@@ -50841,6 +50841,164 @@ void main() {
     }
     return true;
   }
+  class Segment {
+    constructor(origin = new Vector3(), target = new Vector3()) {
+      __publicField(this, "origin");
+      __publicField(this, "target");
+      this.origin = origin;
+      this.target = target;
+    }
+    static fromArray(array) {
+      return new Segment(
+        new Vector3(array[0], array[1], array[2]),
+        new Vector3(array[3], array[4], array[5])
+      );
+    }
+    toArray() {
+      return [this.origin.x, this.origin.y, this.origin.z, this.target.x, this.target.y, this.target.z];
+    }
+    isValid() {
+      return !this.origin.equals(this.target);
+    }
+    equals(segment) {
+      return this.origin.equals(segment.origin) && this.target.equals(segment.target);
+    }
+  }
+  class RGBA {
+    constructor(r, g, b, a = 1) {
+      __publicField(this, "r");
+      __publicField(this, "g");
+      __publicField(this, "b");
+      __publicField(this, "a");
+      this.r = r;
+      this.g = g;
+      this.b = b;
+      this.a = a;
+    }
+    static fromThree(color, opacity = 1) {
+      return new RGBA(color.r, color.g, color.b, opacity);
+    }
+    toThree() {
+      return new Color(this.r, this.g, this.b);
+    }
+    clone() {
+      return new RGBA(this.r, this.g, this.b, this.a);
+    }
+    isValid() {
+      return Number.isFinite(this.r) && Number.isFinite(this.g) && Number.isFinite(this.b) && Number.isFinite(this.a);
+    }
+    equals(color) {
+      return this.r === color.r && this.g === color.g && this.b === color.b && this.a === color.a;
+    }
+    static fromString(str) {
+      str = str.trim();
+      if (str.startsWith("(")) {
+        str = str.substring(1);
+      }
+      if (str.endsWith(")")) {
+        str = str.substring(0, str.length - 1);
+      }
+      const parts = str.split(",");
+      if (parts.length < 3 || parts.length > 4) {
+        throw new Error("Invalid color string format. Expected 3 or 4 components.");
+      }
+      const r = parseFloat(parts[0]);
+      const g = parseFloat(parts[1]);
+      const b = parseFloat(parts[2]);
+      const a = parts.length === 4 ? parseFloat(parts[3]) : 1;
+      if ([r, g, b, a].some((n) => isNaN(n))) {
+        throw new Error("Invalid number in color string.");
+      }
+      return new RGBA(r, g, b, a);
+    }
+  }
+  class RGB {
+    constructor(r, g, b) {
+      __publicField(this, "r");
+      __publicField(this, "g");
+      __publicField(this, "b");
+      this.r = r;
+      this.g = g;
+      this.b = b;
+    }
+  }
+  class RGBA32 {
+    constructor(hex) {
+      __publicField(this, "hex");
+      if (!Number.isInteger(hex) || hex < 0 || hex > 4294967295) {
+        throw new Error("Invalid value: must be a 32-bit unsigned integer");
+      }
+      this.hex = hex;
+    }
+    static fromThree(color, opacity = 1) {
+      return this.fromFloats(color.r, color.g, color.b, opacity);
+    }
+    static fromInts(r, g, b, a = 1) {
+      if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255) {
+        throw new Error("Each RGBA component must be in the range 0-255.");
+      }
+      const hex = r * 2 ** 24 + g * 2 ** 16 + b * 2 ** 8 + a;
+      return new RGBA32(hex);
+    }
+    static fromFloats(r, g, b, a = 1) {
+      return this.fromInts(
+        remap(r, 255),
+        remap(g, 255),
+        remap(b, 255),
+        remap(a, 255)
+      );
+    }
+    static fromString(str) {
+      if (str.startsWith("#")) {
+        str = str.slice(1);
+      }
+      if (str.length === 3 || str.length === 4) {
+        str = str.split("").map((c) => c + c).join("");
+      }
+      let r = 0;
+      let g = 0;
+      let b = 0;
+      let a = 255;
+      if (str.length === 6 || str.length === 8) {
+        r = parseInt(str.slice(0, 2), 16);
+        g = parseInt(str.slice(2, 4), 16);
+        b = parseInt(str.slice(4, 6), 16);
+        if (str.length === 8) {
+          a = parseInt(str.slice(6, 8), 16);
+        }
+      } else {
+        throw new Error("Invalid color string format");
+      }
+      if ([r, g, b, a].some((v) => isNaN(v))) {
+        throw new Error("Invalid color string format");
+      }
+      return this.fromInts(r, g, b, a);
+    }
+    /**
+     * The red component of the color in the range [0-255].
+     */
+    get r() {
+      return this.hex >>> 24;
+    }
+    /**
+     * The green component of the color in the range [0-255].
+     */
+    get g() {
+      return this.hex >>> 16 & 255;
+    }
+    /**
+     * The blue component of the color in the range [0-255].
+     */
+    get b() {
+      return this.hex >>> 8 & 255;
+    }
+    /**
+     * The alpha component of the color in the range [0-255].
+     */
+    get a() {
+      return this.hex & 255;
+    }
+  }
   class Validation {
     //= ===========================================================================
     // BASIC NUMBER VALIDATIONS
@@ -50950,23 +51108,6 @@ void main() {
       return true;
     }
     //= ===========================================================================
-    // COLOR VALIDATIONS
-    //= ===========================================================================
-    static isRelativeRGBA(color) {
-      if (color.r < 0 || color.r > 1 || color.g < 0 || color.g > 1 || color.b < 0 || color.b > 1) {
-        console.warn("Invalid value: must be a relative color (0-1, 0-1, 0-1)");
-        return false;
-      }
-      return true;
-    }
-    static isRelativeRGB(color) {
-      if (color.r < 0 || color.r > 1 || color.g < 0 || color.g > 1 || color.b < 0 || color.b > 1) {
-        console.warn("Invalid value: must be a relative color (0-1, 0-1, 0-1)");
-        return false;
-      }
-      return true;
-    }
-    //= ===========================================================================
     // STRING AND URL VALIDATIONS
     //= ===========================================================================
     static isNonEmptyString(value) {
@@ -51053,6 +51194,13 @@ void main() {
       }
       return value;
     }
+    static clampColor01(value) {
+      return new Color(
+        this.clamp01(value.r),
+        this.clamp01(value.g),
+        this.clamp01(value.b)
+      );
+    }
     static clampRGBA01(value) {
       return new RGBA(
         this.clamp01(value.r),
@@ -57333,155 +57481,6 @@ void main() {
     getDefaultVimSettings,
     request: requestVim
   }, Symbol.toStringTag, { value: "Module" }));
-  class Segment {
-    constructor(origin = new Vector3(), target = new Vector3()) {
-      __publicField(this, "origin");
-      __publicField(this, "target");
-      this.origin = origin;
-      this.target = target;
-    }
-    static fromArray(array) {
-      return new Segment(
-        new Vector3(array[0], array[1], array[2]),
-        new Vector3(array[3], array[4], array[5])
-      );
-    }
-    toArray() {
-      return [this.origin.x, this.origin.y, this.origin.z, this.target.x, this.target.y, this.target.z];
-    }
-    isValid() {
-      return !this.origin.equals(this.target);
-    }
-    equals(segment) {
-      return this.origin.equals(segment.origin) && this.target.equals(segment.target);
-    }
-  }
-  class RGBA {
-    constructor(r, g, b, a = 1) {
-      __publicField(this, "r");
-      __publicField(this, "g");
-      __publicField(this, "b");
-      __publicField(this, "a");
-      this.r = r;
-      this.g = g;
-      this.b = b;
-      this.a = a;
-    }
-    clone() {
-      return new RGBA(this.r, this.g, this.b, this.a);
-    }
-    isValid() {
-      return Number.isFinite(this.r) && Number.isFinite(this.g) && Number.isFinite(this.b) && Number.isFinite(this.a);
-    }
-    equals(color) {
-      return this.r === color.r && this.g === color.g && this.b === color.b && this.a === color.a;
-    }
-    static fromString(str) {
-      str = str.trim();
-      if (str.startsWith("(")) {
-        str = str.substring(1);
-      }
-      if (str.endsWith(")")) {
-        str = str.substring(0, str.length - 1);
-      }
-      const parts = str.split(",");
-      if (parts.length < 3 || parts.length > 4) {
-        throw new Error("Invalid color string format. Expected 3 or 4 components.");
-      }
-      const r = parseFloat(parts[0]);
-      const g = parseFloat(parts[1]);
-      const b = parseFloat(parts[2]);
-      const a = parts.length === 4 ? parseFloat(parts[3]) : 1;
-      if ([r, g, b, a].some((n) => isNaN(n))) {
-        throw new Error("Invalid number in color string.");
-      }
-      return new RGBA(r, g, b, a);
-    }
-  }
-  class RGB {
-    constructor(r, g, b) {
-      __publicField(this, "r");
-      __publicField(this, "g");
-      __publicField(this, "b");
-      this.r = r;
-      this.g = g;
-      this.b = b;
-    }
-  }
-  class RGBA32 {
-    constructor(hex) {
-      __publicField(this, "hex");
-      if (!Number.isInteger(hex) || hex < 0 || hex > 4294967295) {
-        throw new Error("Invalid value: must be a 32-bit unsigned integer");
-      }
-      this.hex = hex;
-    }
-    static fromInts(r, g, b, a = 1) {
-      if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 || a > 255) {
-        throw new Error("Each RGBA component must be in the range 0-255.");
-      }
-      const hex = r * 2 ** 24 + g * 2 ** 16 + b * 2 ** 8 + a;
-      return new RGBA32(hex);
-    }
-    static fromFloats(r, g, b, a = 1) {
-      return this.fromInts(
-        remap(r, 255),
-        remap(g, 255),
-        remap(b, 255),
-        remap(a, 255)
-      );
-    }
-    static fromString(str) {
-      if (str.startsWith("#")) {
-        str = str.slice(1);
-      }
-      if (str.length === 3 || str.length === 4) {
-        str = str.split("").map((c) => c + c).join("");
-      }
-      let r = 0;
-      let g = 0;
-      let b = 0;
-      let a = 255;
-      if (str.length === 6 || str.length === 8) {
-        r = parseInt(str.slice(0, 2), 16);
-        g = parseInt(str.slice(2, 4), 16);
-        b = parseInt(str.slice(4, 6), 16);
-        if (str.length === 8) {
-          a = parseInt(str.slice(6, 8), 16);
-        }
-      } else {
-        throw new Error("Invalid color string format");
-      }
-      if ([r, g, b, a].some((v) => isNaN(v))) {
-        throw new Error("Invalid color string format");
-      }
-      return this.fromInts(r, g, b, a);
-    }
-    /**
-     * The red component of the color in the range [0-255].
-     */
-    get r() {
-      return this.hex >>> 24;
-    }
-    /**
-     * The green component of the color in the range [0-255].
-     */
-    get g() {
-      return this.hex >>> 16 & 255;
-    }
-    /**
-     * The blue component of the color in the range [0-255].
-     */
-    get b() {
-      return this.hex >>> 8 & 255;
-    }
-    /**
-     * The alpha component of the color in the range [0-255].
-     */
-    get a() {
-      return this.hex & 255;
-    }
-  }
   class Camera {
     /** 
      * Creates a new Camera instance
@@ -58340,35 +58339,7 @@ void main() {
      * @returns {number} The color value as a hexadecimal number.
      */
     get hex() {
-      return this.color.hex;
-    }
-    /**
-     * Gets the red component of the color.
-     * @returns {number} The red component value in the range [0-255].
-     */
-    get r() {
-      return this.color.r;
-    }
-    /**
-     * Gets the green component of the color.
-     * @returns {number} The green component value in the range [0-255].
-     */
-    get g() {
-      return this.color.g;
-    }
-    /**
-     * Gets the blue component of the color.
-     * @returns {number} The blue component value in the range [0-255].
-     */
-    get b() {
-      return this.color.b;
-    }
-    /**
-     * Gets the alpha (opacity) component of the color.
-     * @returns {number} The alpha component value in the range [0-255].
-     */
-    get a() {
-      return this.color.a;
+      return this.color.getHex();
     }
     /**
      * Disposes of the color handle and releases associated resources.
@@ -58381,6 +58352,12 @@ void main() {
       this._disposed = true;
     }
   }
+  function RGBAfromThree(color, opacity = 1) {
+    return new RGBA(color.r, color.g, color.b, opacity);
+  }
+  function RGBA32fromThree(color, opacity = 1) {
+    return RGBA32.fromFloats(color.r, color.g, color.b, opacity);
+  }
   const MAX_BATCH_SIZE = 3e3;
   class ColorManager {
     /**
@@ -58400,39 +58377,40 @@ void main() {
      * @param hex - The RGBA32 color value
      * @returns Promise resolving to a ColorHandle, or undefined if creation fails
      */
-    async getColor(hex) {
-      const colors = await this.getColors([hex]);
+    async getColor(color) {
+      const colors = await this.getColors([color]);
       if (!colors) return void 0;
       return colors[0];
     }
     /**
      * Creates or retrieves cached color instances for multiple hex values.
-     * @param c - Array of RGBA32 color values
+     * @param colors - Array of RGBA32 color values
      * @returns Promise resolving to an array of ColorHandles in the same order as input, or undefined if creation fails
      * @remarks Duplicate hex values will be mapped to the same color instance for efficiency
      */
-    async getColors(c) {
-      const result = new Array(c.length);
+    async getColors(colors) {
+      const result = new Array(colors.length);
       const hexToIndices = /* @__PURE__ */ new Map();
       const toCreate = [];
-      for (let i2 = 0; i2 < c.length; i2++) {
-        const color = c[i2];
-        if (this._hexToColor.has(color.hex)) {
-          result[i2] = this._hexToColor.get(color.hex);
-        } else if (hexToIndices.has(color.hex)) {
-          hexToIndices.get(color.hex).push(i2);
+      for (let i2 = 0; i2 < colors.length; i2++) {
+        const color = colors[i2];
+        const hex = color.getHex();
+        if (this._hexToColor.has(hex)) {
+          result[i2] = this._hexToColor.get(hex);
+        } else if (hexToIndices.has(hex)) {
+          hexToIndices.get(hex).push(i2);
         } else {
           toCreate.push(color);
-          hexToIndices.set(color.hex, [i2]);
+          hexToIndices.set(hex, [i2]);
         }
       }
-      const colors = await this._createColors(toCreate);
-      if (!colors) return void 0;
-      for (let i2 = 0; i2 < colors.length; i2++) {
+      const remoteColors = await this._createColors(toCreate);
+      if (!remoteColors) return void 0;
+      for (let i2 = 0; i2 < remoteColors.length; i2++) {
         const color = toCreate[i2];
-        const indices = hexToIndices.get(color.hex);
+        const indices = hexToIndices.get(color.getHex());
         for (const index2 of indices) {
-          result[index2] = colors[i2];
+          result[index2] = remoteColors[i2];
         }
       }
       return result;
@@ -58475,7 +58453,8 @@ void main() {
       if (colors.length === 0) {
         return result;
       }
-      const instances = await this._rpc.RPCCreateMaterialInstances(MaterialHandles.StandardOpaque, 1, colors);
+      const rpcColors = colors.map((c) => RGBA32fromThree(c));
+      const instances = await this._rpc.RPCCreateMaterialInstances(MaterialHandles.StandardOpaque, 1, rpcColors);
       if (!instances) return void 0;
       for (let i2 = 0; i2 < colors.length; i2++) {
         const color = this._createColor(colors[i2], instances[i2]);
@@ -58492,7 +58471,7 @@ void main() {
      */
     _createColor(color, id2) {
       const handle = new RemoteColor(color, id2, this);
-      this._hexToColor.set(color.hex, handle);
+      this._hexToColor.set(color.getHex(), handle);
       this._idToColor.set(handle.id, handle);
       return handle;
     }
@@ -59759,7 +59738,8 @@ void main() {
   }
   const defaultRenderSettings = {
     ...defaultSceneSettings,
-    ghostColor: new RGBA(14 / 255, 14 / 255, 14 / 255, 64 / 255)
+    ghostColor: new Color(14 / 255, 14 / 255, 14 / 255),
+    ghostOpacity: 64 / 255
   };
   class Renderer {
     /**
@@ -59806,7 +59786,8 @@ void main() {
      * Sets up initial scene settings, ghost color, and IBL rotation
      */
     onConnect() {
-      this._rpc.RPCSetGhostColor(this._settings.ghostColor);
+      const color = RGBAfromThree(this._settings.ghostColor, this._settings.ghostOpacity);
+      this._rpc.RPCSetGhostColor(color);
     }
     notifySceneUpdated() {
       this._onSceneUpdated.dispatch();
@@ -59814,11 +59795,14 @@ void main() {
     // Getters
     /**
      * Gets the ghost color used for transparent rendering
-     * @returns Current ghost color as RGBA
+     * @returns Current ghost color as a THREE.Color
      */
     get ghostColor() {
       return this._settings.ghostColor;
     }
+    get ghostOpacity() {
+      return this._settings.ghostOpacity;
+    }
     /**
      * Gets the tone mapping white point value
      * @returns Current tone mapping white point
@@ -59859,20 +59843,26 @@ void main() {
      * @returns Current background color as RGBA
      */
     get backgroundColor() {
-      return this._settings.backgroundColor;
+      return this._settings.backgroundColor.toThree();
     }
     // Setters
     /**
      * Updates the ghost color used for transparent rendering
-     * @param value - New ghost color as RGBA
+     * @param value - New ghost color as THREE.Color
      */
     set ghostColor(value) {
-      value = Validation.clampRGBA01(value);
       if (this._settings.ghostColor.equals(value)) return;
       this._settings.ghostColor = value;
       this._updateGhostColor = true;
       this.requestSettingsUpdate();
     }
+    set ghostOpacity(value) {
+      value = Validation.clamp01(value);
+      if (this._settings.ghostOpacity === value) return;
+      this._settings.ghostOpacity = value;
+      this._updateGhostColor = true;
+      this.requestSettingsUpdate();
+    }
     /**
      * Sets the tone mapping white point value
      * @param value - New tone mapping white point value
@@ -59930,12 +59920,12 @@ void main() {
     }
     /**
      * Sets the background color
-     * @param value - New background color as RGBA
+     * @param value - New background color as THREE.Color
      */
     set backgroundColor(value) {
-      value = Validation.clampRGBA01(value);
-      if (this._settings.backgroundColor.equals(value)) return;
-      this._settings.backgroundColor = value;
+      const color = RGBAfromThree(value, 1);
+      if (this._settings.backgroundColor.equals(color)) return;
+      this._settings.backgroundColor = color;
       this._updateLighting = true;
       this.requestSettingsUpdate();
     }
@@ -59955,7 +59945,10 @@ void main() {
     }
     async applySettings() {
       if (this._updateLighting) await this._rpc.RPCSetLighting(this._settings);
-      if (this._updateGhostColor) await this._rpc.RPCSetGhostColor(this._settings.ghostColor);
+      if (this._updateGhostColor) {
+        const color = RGBAfromThree(this._settings.ghostColor, this._settings.ghostOpacity);
+        await this._rpc.RPCSetGhostColor(color);
+      }
       this._updateLighting = false;
       this._updateGhostColor = false;
       this._animationFrame = void 0;
@@ -60880,7 +60873,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       // Should be private
       __publicField(this, "visibility");
       // Color tracking remains unchanged.
-      __publicField(this, "_nodeColors", /* @__PURE__ */ new Map());
+      __publicField(this, "_elementColors", /* @__PURE__ */ new Map());
       __publicField(this, "_updatedColors", /* @__PURE__ */ new Set());
       // Delayed update flag.
       __publicField(this, "_updateScheduled", false);
@@ -60900,6 +60893,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         // default state
       );
     }
+    //TODO: Rename this to getElementFromNode, prefer using element instead
     getElement(elementIndex) {
       if (this._objects.has(elementIndex)) {
         return this._objects.get(elementIndex);
@@ -60912,7 +60906,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       throw new Error("Method not implemented.");
     }
     getElementFromIndex(element) {
-      throw new Error("Method not implemented.");
+      return this.getElement(element);
     }
     getObjectsInBox(box) {
       throw new Error("Method not implemented.");
@@ -61033,12 +61027,12 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
       return await this._rpc.RPCGetAABBForVim(this._handle);
     }
-    getColor(node) {
-      return this._nodeColors.get(node);
+    getColor(elementIndex) {
+      return this._elementColors.get(elementIndex);
     }
-    async setColor(nodes, color) {
-      const colors = new Array(nodes.length).fill(color);
-      this.applyColor(nodes, colors);
+    async setColor(elementIndex, color) {
+      const colors = new Array(elementIndex.length).fill(color);
+      this.applyColor(elementIndex, colors);
     }
     async setColors(nodes, color) {
       if (color.length !== nodes.length) {
@@ -61051,9 +61045,9 @@ Averrage Date/Second ${avgDataRatePS} kb
         const c = color[i2];
         const n = nodes[i2];
         if (c === void 0) {
-          this._nodeColors.delete(n);
+          this._elementColors.delete(n);
         } else {
-          this._nodeColors.set(n, c);
+          this._elementColors.set(n, c);
         }
         this._updatedColors.add(n);
       }
@@ -61061,9 +61055,9 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     clearColor(elements) {
       if (elements === "all") {
-        this._nodeColors.clear();
+        this._elementColors.clear();
       } else {
-        elements.forEach((n) => this._nodeColors.delete(n));
+        elements.forEach((n) => this._elementColors.delete(n));
       }
       if (!this.connected) return;
       if (elements === "all") {
@@ -61075,7 +61069,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     reapplyColors() {
       this._updatedColors.clear();
-      this._nodeColors.forEach((c, n) => this._updatedColors.add(n));
+      this._elementColors.forEach((c, n) => this._updatedColors.add(n));
       this.scheduleColorUpdate();
     }
     scheduleColorUpdate() {
@@ -61092,7 +61086,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     async updateRemoteColors() {
       const nodes = Array.from(this._updatedColors);
-      const colors = nodes.map((n) => this._nodeColors.get(n));
+      const colors = nodes.map((n) => this._elementColors.get(n));
       const remoteColors = await this._colors.getColors(colors);
       const colorIds = remoteColors.map((c) => (c == null ? void 0 : c.id) ?? -1);
       this._rpc.RPCSetMaterialOverridesForElements(this._handle, nodes, colorIds);
@@ -61420,9 +61414,6 @@ Averrage Date/Second ${avgDataRatePS} kb
     INVALID_HANDLE,
     InputMode,
     MaterialHandles,
-    RGB,
-    RGBA,
-    RGBA32,
     Segment,
     Viewer: Viewer$2,
     VimLoadingStatus,
@@ -76294,6 +76285,7 @@ Averrage Date/Second ${avgDataRatePS} kb
           obj.state = VisibilityState.HIGHLIGHTED;
         });
       },
+      // TODO: Change this api to use elements
       isolate: (instances) => {
         hide("all");
         viewer.selection.getAll().forEach((obj) => {
@@ -76327,11 +76319,9 @@ Averrage Date/Second ${avgDataRatePS} kb
           }
         }
       },
-      getGhostOpacity: () => viewer.renderer.ghostColor.a,
+      getGhostOpacity: () => viewer.renderer.ghostOpacity,
       setGhostOpacity: (opacity) => {
-        const c = viewer.renderer.ghostColor.clone();
-        c.a = opacity;
-        viewer.renderer.ghostColor = c;
+        viewer.renderer.ghostOpacity = opacity;
       },
       getShowRooms: () => true,
       setShowRooms: (show) => {