vim-web 0.3.40 → 0.3.42-dev.0

package/dist/vim-web.iife.js

@@ -50168,10 +50168,10 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     background: { color: new Color(12698310) },
     skybox: {
       enable: true,
-      skyColor: new Color(15135994),
-      // Light sky blue pastel
-      groundColor: new Color(14671841),
-      // Light earthy brown pastel
+      skyColor: new Color(16777215),
+      // white
+      groundColor: new Color(16185078),
+      // less white
       sharpness: 2
     },
     groundPlane: {
@@ -55236,6 +55236,15 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
       this.reg(canvas, "pointerdown", this.onMouseDown.bind(this));
       this.reg(canvas, "pointermove", this.onMouseMove.bind(this));
       this.reg(canvas, "pointerup", this.onMouseUp.bind(this));
+      this.reg(canvas, "pointerleave", this.onPointerLeave.bind(this));
+    }
+    onPointerLeave(event) {
+      var _a2;
+      if (this.capturedId !== void 0) {
+        return;
+      }
+      this.faceNormal.set(0, 0, 0);
+      (_a2 = this.onFaceEnter) == null ? void 0 : _a2.call(this, this.faceNormal);
     }
     capturePointer(pointerId) {
       this.releasePointer();
@@ -58127,6 +58136,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     get url() {
       return this._messenger.url;
     }
+    get connected() {
+      return this._messenger.state.status === "connected";
+    }
     RPCAddNodeFlags(componentHandle, nodes, flags) {
       const marshal = new Marshal();
       marshal.writeString("RPCAddNodeFlags");
@@ -58823,6 +58835,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
     get url() {
       return this.rpc.url;
     }
+    get connected() {
+      return this.rpc.connected;
+    }
     /*******************************************************************************
      * SCENE MANAGEMENT METHODS
      * Methods for managing the overall scene, including initialization, lighting,
@@ -59159,15 +59174,15 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
      ******************************************************************************/
     /**
      * Loads a VIM file from the local filesystem.
-     * @param fileName - The path to the VIM file (supports file:// protocol)
+     * @param source - The path to the VIM file (supports file:// protocol)
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the filename is invalid or empty
      */
-    async RPCLoadVim(fileName) {
-      if (!Validation.isNonEmptyString(fileName)) return INVALID_HANDLE;
-      fileName = fileName.replace("file:///", "file://");
+    async RPCLoadVim(source) {
+      if (!Validation.isNonEmptyString(source.url)) return INVALID_HANDLE;
+      const url = source.url.replace("file:///", "file://");
       return await this.safeCall(
-        () => this.rpc.RPCLoadVim(fileName),
+        () => this.rpc.RPCLoadVim(url),
         INVALID_HANDLE
       );
     }
@@ -59177,10 +59192,10 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
      * @returns Promise resolving to the handle of the loaded VIM component
      * @throws {Error} If the URL is invalid
      */
-    async RPCLoadVimURL(url) {
-      if (!Validation.isURL(url)) return INVALID_HANDLE;
+    async RPCLoadVimURL(source) {
+      if (!Validation.isURL(source.url)) return INVALID_HANDLE;
       return await this.safeCall(
-        () => this.rpc.RPCLoadVimURL(url, ""),
+        () => this.rpc.RPCLoadVimURL(source.url, source.authToken ?? ""),
         INVALID_HANDLE
       );
     }
@@ -59564,9 +59579,9 @@ data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAAAXNSR0IArs
       this._inputsMouse = new InputMouse(this._canvas, this._rpc, selection, camera2);
       this._inputsTouch = new InputTouch(this._canvas, this._rpc);
       this._keyboard = new InputKeyboard(this._rpc, selection, camera2, this);
-      this.register();
     }
     onConnect() {
+      this.register();
       this._rpc.RPCSetMoveSpeed(this._moveSpeed);
     }
     register() {
@@ -59705,6 +59720,7 @@ Averrage Date/Second ${avgDataRatePS} kb
     ControllablePromise,
     ResolvedPromise
   }, Symbol.toStringTag, { value: "Module" }));
+  const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
   class SocketClient {
     /**
      * Constructs a new Messenger instance.
@@ -59719,6 +59735,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       __publicField(this, "_rpcCallId", 0);
       __publicField(this, "_reconnectTimeout");
       __publicField(this, "_connectionTimeout");
+      __publicField(this, "_attempts", -1);
       __publicField(this, "_validateConnection");
       /**
        * Callback function to handle incoming video frames.
@@ -59769,7 +59786,12 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param url - The WebSocket URL to connect to.
      * @returns A promise that resolves when the connection is established.
      */
-    connect(url) {
+    connect(settings2) {
+      settings2 = {
+        url: (settings2 == null ? void 0 : settings2.url) ?? DEFAULT_LOCAL_ULTRA_SERVER_URL,
+        attempts: (settings2 == null ? void 0 : settings2.attempts) ?? 0
+      };
+      const url = settings2.url;
       if (!isWebSocketUrl(url)) {
         this._disconnect({ status: "error", error: "connection", serverUrl: url });
         return Promise.reject(new Error(`Invalid WebSocket URL: ${url}`));
@@ -59812,7 +59834,7 @@ Averrage Date/Second ${avgDataRatePS} kb
      * Disconnects from the current WebSocket server.
      */
     disconnect(error) {
-      this._logger.log("Disconnecting from " + this._connectingUrl);
+      this._logger.log("Disconnecting from: ", this._connectingUrl);
       this._connectingUrl = void 0;
       this._disconnect(error);
     }
@@ -59898,7 +59920,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         this._disconnect(issues);
         return;
       }
-      this._logger.log("Connected to " + ((_a2 = this._socket) == null ? void 0 : _a2.url));
+      this._logger.log("Connected to: ", (_a2 = this._socket) == null ? void 0 : _a2.url);
       this.updateState({ status: "connected" });
       this._streamLogger.startLoggging();
       this._connectPromise.resolve();
@@ -59911,11 +59933,16 @@ Averrage Date/Second ${avgDataRatePS} kb
       clearTimeout(this._connectionTimeout);
       this._disconnect({ status: "error", error: "connection", serverUrl: this._connectingUrl });
       this._logger.log("WebSocket closed.");
-      this._logger.log("Attempting to reconnect in 5 seconds");
-      this._reconnectTimeout = setTimeout(() => {
-        this.updateState({ status: "connecting" });
-        this.connect(this._connectingUrl);
-      }, 5e3);
+      if (this._attempts != 0) {
+        this._logger.log("Attempting to reconnect in 5 seconds");
+        this._reconnectTimeout = setTimeout(() => {
+          this.updateState({ status: "connecting" });
+          this.connect({
+            url: this._connectingUrl,
+            attempts: this._attempts - 1
+          });
+        }, 5e3);
+      }
     }
     /**
      * Sends binary data over the WebSocket connection.
@@ -60211,7 +60238,10 @@ Averrage Date/Second ${avgDataRatePS} kb
           this._logger.error("Error decoding video chunk: ", e);
         }
       }
-      this._firstDecoded = true;
+      if (!this._firstDecoded) {
+        this._firstDecoded = true;
+        this._logger.log("First frame decoded");
+      }
     }
     /**
      * Clears the decoder state and renderer buffer.
@@ -60421,16 +60451,16 @@ Averrage Date/Second ${avgDataRatePS} kb
       if (this._request) {
         return this._request;
       }
-      this._logger.log("Loading " + this.source);
+      this._logger.log("Loading: ", this.source);
       this._request = new LoadRequest$1();
       this._load(this.source, this._request).then(async (request2) => {
         const result = await request2.getResult();
         if (result.isSuccess) {
-          this._logger.log(`Successfully loaded vim: ${this.source}`);
+          this._logger.log("Successfully loaded vim: ", this.source);
           this.reapplyNodes();
           this.reapplyColors();
         } else {
-          this._logger.log(`Failed to load vim:  ${this.source}`);
+          this._logger.log("Failed to load vim: ", this.source);
         }
       });
       return this._request;
@@ -60463,18 +60493,19 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     /**
      * Requests for the server to load the given URL or file path.
-     * @param url - The URL or file path to load.
+     * @param source - The URL or file path to load.
      * @param result - The load request object to update.
      * @returns The updated load request.
      */
-    async _load(url, result) {
-      const handle = await this._getHandle(url, result);
+    async _load(source, result) {
+      const handle = await this._getHandle(source, result);
       if (result.isCompleted || handle === INVALID_HANDLE) {
         return result;
       }
       while (true) {
         try {
           const state = await this._rpc.RPCGetVimLoadingState(handle);
+          this._logger.log("state :", state);
           result.onProgress(state.progress);
           switch (state.status) {
             // Keep waiting for the loading to complete
@@ -60511,16 +60542,16 @@ Averrage Date/Second ${avgDataRatePS} kb
           return "unknown";
       }
     }
-    async _getHandle(url, result) {
+    async _getHandle(source, result) {
       let handle = void 0;
       try {
-        if (isURL(url)) {
-          handle = await this._rpc.RPCLoadVimURL(url);
-        } else if (isFileURI(url)) {
-          handle = await this._rpc.RPCLoadVim(url);
+        if (isURL(source.url)) {
+          handle = await this._rpc.RPCLoadVimURL(source);
+        } else if (isFileURI(source.url)) {
+          handle = await this._rpc.RPCLoadVim(source);
         } else {
           console.log("Defaulting to file path");
-          handle = await this._rpc.RPCLoadVim(url);
+          handle = await this._rpc.RPCLoadVim(source);
         }
       } catch (e) {
         result.error("downloadingError", e.message);
@@ -60530,6 +60561,7 @@ Averrage Date/Second ${avgDataRatePS} kb
         result.error("downloadingError");
         return INVALID_HANDLE;
       }
+      console.log("handle :", handle);
       return handle;
     }
     /**
@@ -60735,13 +60767,27 @@ Averrage Date/Second ${avgDataRatePS} kb
     return new Promise((resolve) => setTimeout(resolve, ms));
   }
   const defaultLogger = {
-    log: (message) => {
-      console.log("VIM Ultra: " + message);
+    log: (message, obj) => {
+      const caller = getCaller();
+      const msg = `VIM Ultra : ${message}`;
+      if (obj) {
+        console.log(msg, obj, { caller });
+      } else {
+        console.log(msg, { caller });
+      }
     },
     error: (message, e) => {
-      console.error("VIM Ultra: " + message, e);
+      console.error("VIM Ultra " + message, e);
     }
   };
+  function getCaller() {
+    const stack = new Error().stack;
+    if (!stack) return "";
+    const files = stack.split("/");
+    const file = files[files.length - 1];
+    const clean = file.replace(/\?[^:]+/, "");
+    return clean;
+  }
   function debounce(func, delay) {
     let timeoutId;
     return [function(...args) {
@@ -60759,14 +60805,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param canvas - The HTML canvas element to observe and manage
      * @param rpc - RPC client for viewport communication
      */
-    constructor(canvas, rpc) {
+    constructor(canvas, rpc, logger) {
       /** The HTML canvas element used for rendering */
       __publicField(this, "canvas");
       __publicField(this, "_rpc");
+      __publicField(this, "_logger");
       __publicField(this, "_observer");
       __publicField(this, "_clearTimeout");
       this.canvas = canvas;
       this._rpc = rpc;
+      this._logger = logger;
       const [debounced, clear] = debounce(() => this.onResize(), 250);
       this._observer = new ResizeObserver(debounced);
       this._observer.observe(canvas);
@@ -60777,14 +60825,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @private
      */
     onResize() {
-      console.log("Canvas resized to", this.canvas.offsetWidth, "x", this.canvas.offsetHeight);
+      this._logger.log("Canvas resized to :", { x: this.canvas.offsetWidth, y: this.canvas.offsetHeight });
       this.update();
     }
     /**
      * Updates the aspect ratio of the viewport on the server
      */
     update() {
-      this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+      if (this._rpc.connected) {
+        this._rpc.RPCSetAspectRatio(this.canvas.offsetWidth, this.canvas.offsetHeight);
+      }
     }
     /**
      * Cleans up resources by removing resize observer and clearing timeouts
@@ -61330,14 +61380,16 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param rpc - RPC client for communication with the rendering backend
      * @param settings - Optional partial render settings to override defaults
      */
-    constructor(rpc, settings2 = {}) {
+    constructor(rpc, logger, settings2 = {}) {
       __publicField(this, "_rpc");
+      __publicField(this, "_logger");
       __publicField(this, "_settings");
       __publicField(this, "_animationFrame");
       __publicField(this, "_updateLighting", false);
       __publicField(this, "_updateGhostColor", false);
       __publicField(this, "_updateIblRotation", false);
       this._rpc = rpc;
+      this._logger = logger;
       this._settings = { ...defaultRenderSettings, ...settings2 };
     }
     /**
@@ -61346,8 +61398,12 @@ Averrage Date/Second ${avgDataRatePS} kb
      */
     async validateConnection() {
       const success = await this._rpc.RPCStartScene(this._settings);
-      if (success) return void 0;
+      if (success) {
+        this._logger.log("Scene stream started successfully");
+        return void 0;
+      }
       const error = await this._rpc.RPCGetLastError();
+      this._logger.error("Failed to start scene stream", error);
       return {
         status: "error",
         error: "stream",
@@ -61539,7 +61595,6 @@ Averrage Date/Second ${avgDataRatePS} kb
       }
     }
   }
-  const DEFAULT_LOCAL_ULTRA_SERVER_URL = "ws://localhost:8123";
   const INVALID_HANDLE = 4294967295;
   class Viewer {
     /**
@@ -61572,10 +61627,10 @@ Averrage Date/Second ${avgDataRatePS} kb
       this.rpc = new RpcSafeClient(new RpcClient(this._socketClient));
       this._canvas = canvas;
       this._vims = new VimCollection();
-      this._viewport = new Viewport(canvas, this.rpc);
+      this._viewport = new Viewport(canvas, this.rpc, this._logger);
       this._decoder = new Decoder(canvas, this._logger);
       this._selection = new ViewerSelection(this.rpc, this._vims);
-      this._renderer = new Renderer(this.rpc);
+      this._renderer = new Renderer(this.rpc, this._logger);
       this.colors = new ColorManager(this.rpc);
       this._camera = new Camera(this.rpc);
       this._input = new Inputs(canvas, this.rpc, this._selection, this._camera, this._renderer);
@@ -61684,6 +61739,7 @@ Averrage Date/Second ${avgDataRatePS} kb
       const remoteVersion = parseVersion(version2);
       const localParsedVersion = parseVersion(localVersion);
       if (localParsedVersion.major !== remoteVersion.major) {
+        this._logger.error("Major version mismatch", { local: localParsedVersion, remote: remoteVersion });
         return {
           status: "error",
           error: "compatibility",
@@ -61692,6 +61748,7 @@ Averrage Date/Second ${avgDataRatePS} kb
           serverVersion: version2
         };
       }
+      this._logger.log("API version check passed", { local: localParsedVersion, remote: remoteVersion });
       return void 0;
     }
     /**
@@ -61710,8 +61767,8 @@ Averrage Date/Second ${avgDataRatePS} kb
      * @param url - The server URL to connect to. Defaults to 'ws://localhost:8123'.
      * @returns A promise that resolves when the connection is established.
      */
-    async connect(url = DEFAULT_LOCAL_ULTRA_SERVER_URL) {
-      await this._socketClient.connect(url);
+    async connect(settings2) {
+      await this._socketClient.connect(settings2);
     }
     /**
      * Disconnects from the current VIM Ultra server.
@@ -61721,16 +61778,16 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     /**
      * Requests the server to load the given URL or file path.
-     * @param path - The path or URL to the VIM file.
+     * @param source - The path or URL to the VIM file.
      * @returns A load request object that can be used to wait for the load to complete.
      */
-    loadVim(path) {
-      if (typeof path !== "string" || path.trim() === "") {
+    loadVim(source) {
+      if (typeof source.url !== "string" || source.url.trim() === "") {
         const request22 = new LoadRequest$1();
         request22.error("loadingError", "Invalid path");
         return request22;
       }
-      const vim = new Vim(this.rpc, this.colors, path, this._logger);
+      const vim = new Vim(this.rpc, this.colors, source, this._logger);
       this._vims.add(vim);
       const request2 = vim.connect();
       request2.getResult().then((result) => {
@@ -61774,7 +61831,6 @@ Averrage Date/Second ${avgDataRatePS} kb
     __proto__: null,
     Box3,
     ColorHandle,
-    DEFAULT_LOCAL_ULTRA_SERVER_URL,
     INVALID_HANDLE,
     Matrix44: Matrix4,
     RGB,
@@ -74215,6 +74271,8 @@ Averrage Date/Second ${avgDataRatePS} kb
       relay("pointerdown", (s, e) => new PointerEvent(s, e), false);
       relay("pointermove", (s, e) => new PointerEvent(s, e), false);
       relay("pointerup", (s, e) => new PointerEvent(s, e), false);
+      relay("pointerenter", (s, e) => new PointerEvent(s, e));
+      relay("pointerleave", (s, e) => new PointerEvent(s, e));
       relay("touchstart", (s, e) => new TouchEvent(s, e), false);
       relay("touchend", (s, e) => new TouchEvent(s, e), false);
       relay("touchmove", (s, e) => new TouchEvent(s, e), false);
@@ -75658,18 +75716,18 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
     return true;
   }
-  function serverFileDownloadingError(url, server) {
+  function serverFileDownloadingError(url, authToken, server) {
     if (isFilePathOrUri(url)) {
       return fileOpeningError(url);
     }
     return {
       title: "File Downloading Error",
-      body: body$4(server, url),
+      body: body$4(server, authToken, server),
       footer: footer(support),
       canClose: false
     };
   }
-  function body$4(server, url) {
+  function body$4(url, server, authToken) {
     return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: vcRoboto, children: [
       mainText(/* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [
         "Oops, it appears that there’s an ",
@@ -75679,7 +75737,8 @@ Averrage Date/Second ${avgDataRatePS} kb
       subTitle("Error details:"),
       dotList([
         server ? bullet("VIM ULTRA Server:", server) : null,
-        bullet("File URL:", url)
+        bullet("File URL:", url),
+        authToken ? bullet("Auth Token:", authToken) : null
       ]),
       subTitle("Troubleshooting tips:"),
       numList([
@@ -75815,17 +75874,17 @@ Averrage Date/Second ${avgDataRatePS} kb
         return serverStreamError(state.serverUrl);
     }
   }
-  function getRequestErrorMessage(url, error) {
+  function getRequestErrorMessage(source, error) {
     console.log(error);
     switch (error) {
       case "loadingError":
-        return serverFileLoadingError(url);
+        return serverFileLoadingError(source.url);
       case "downloadingError":
       case "unknown":
       case "cancelled":
-        return serverFileDownloadingError(url);
+        return serverFileDownloadingError(source.url);
       case "serverDisconnected":
-        return serverConnectionError(url);
+        return serverConnectionError(source.url);
     }
   }
   function createUltraComponent(container) {
@@ -75880,13 +75939,13 @@ Averrage Date/Second ${avgDataRatePS} kb
     }
   }
   function ToRef(viewer, modal) {
-    function load(url) {
-      const request2 = viewer.loadVim(url);
+    function load(source) {
+      const request2 = viewer.loadVim(source);
       void updateProgress(request2, modal);
       void request2.getResult().then(
         (result) => {
           if (result.isError) {
-            modal.message(getRequestErrorMessage(url, result.error));
+            modal.message(getRequestErrorMessage(source, result.error));
             return;
           }
           if (result.isSuccess) {