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

package/dist/vim-web.js

@@ -50825,6 +50825,164 @@ function isFilePathOrUri(input) {
   }
   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
@@ -50934,23 +51092,6 @@ class Validation {
     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) {
@@ -51037,6 +51178,13 @@ class Validation {
     }
     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),
@@ -57317,155 +57465,6 @@ const index$8 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   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 Camera3 {
   /** 
    * Creates a new Camera instance
@@ -58324,35 +58323,7 @@ class RemoteColor {
    * @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.
@@ -58365,6 +58336,12 @@ class RemoteColor {
     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 {
   /**
@@ -58384,39 +58361,40 @@ class ColorManager {
    * @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 i = 0; i < c.length; i++) {
-      const color = c[i];
-      if (this._hexToColor.has(color.hex)) {
-        result[i] = this._hexToColor.get(color.hex);
-      } else if (hexToIndices.has(color.hex)) {
-        hexToIndices.get(color.hex).push(i);
+    for (let i = 0; i < colors.length; i++) {
+      const color = colors[i];
+      const hex = color.getHex();
+      if (this._hexToColor.has(hex)) {
+        result[i] = this._hexToColor.get(hex);
+      } else if (hexToIndices.has(hex)) {
+        hexToIndices.get(hex).push(i);
       } else {
         toCreate.push(color);
-        hexToIndices.set(color.hex, [i]);
+        hexToIndices.set(hex, [i]);
       }
     }
-    const colors = await this._createColors(toCreate);
-    if (!colors) return void 0;
-    for (let i = 0; i < colors.length; i++) {
+    const remoteColors = await this._createColors(toCreate);
+    if (!remoteColors) return void 0;
+    for (let i = 0; i < remoteColors.length; i++) {
       const color = toCreate[i];
-      const indices = hexToIndices.get(color.hex);
+      const indices = hexToIndices.get(color.getHex());
       for (const index2 of indices) {
-        result[index2] = colors[i];
+        result[index2] = remoteColors[i];
       }
     }
     return result;
@@ -58459,7 +58437,8 @@ class ColorManager {
     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 i = 0; i < colors.length; i++) {
       const color = this._createColor(colors[i], instances[i]);
@@ -58476,7 +58455,7 @@ class ColorManager {
    */
   _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;
   }
@@ -59743,7 +59722,8 @@ class RpcSafeClient {
 }
 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 Renderer2 {
   /**
@@ -59790,7 +59770,8 @@ class Renderer2 {
    * 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();
@@ -59798,11 +59779,14 @@ class Renderer2 {
   // 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
@@ -59843,20 +59827,26 @@ class Renderer2 {
    * @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
@@ -59914,12 +59904,12 @@ class Renderer2 {
   }
   /**
    * 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();
   }
@@ -59939,7 +59929,10 @@ class Renderer2 {
   }
   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;
@@ -60864,7 +60857,7 @@ class Vim2 {
     // 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);
@@ -60884,6 +60877,7 @@ class Vim2 {
       // default state
     );
   }
+  //TODO: Rename this to getElementFromNode, prefer using element instead
   getElement(elementIndex) {
     if (this._objects.has(elementIndex)) {
       return this._objects.get(elementIndex);
@@ -60896,7 +60890,7 @@ class Vim2 {
     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.");
@@ -61017,12 +61011,12 @@ class Vim2 {
     }
     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) {
@@ -61035,9 +61029,9 @@ class Vim2 {
       const c = color[i];
       const n = nodes[i];
       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);
     }
@@ -61045,9 +61039,9 @@ class Vim2 {
   }
   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") {
@@ -61059,7 +61053,7 @@ class Vim2 {
   }
   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() {
@@ -61076,7 +61070,7 @@ class Vim2 {
   }
   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);
@@ -61404,9 +61398,6 @@ const index$7 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.definePrope
   INVALID_HANDLE,
   InputMode,
   MaterialHandles,
-  RGB,
-  RGBA,
-  RGBA32,
   Segment,
   Viewer: Viewer$2,
   VimLoadingStatus,
@@ -76278,6 +76269,7 @@ function createAdapter(viewer) {
         obj.state = VisibilityState.HIGHLIGHTED;
       });
     },
+    // TODO: Change this api to use elements
     isolate: (instances) => {
       hide("all");
       viewer.selection.getAll().forEach((obj) => {
@@ -76311,11 +76303,9 @@ function createAdapter(viewer) {
         }
       }
     },
-    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) => {