@vuu-ui/vuu-data-remote 0.13.107 → 0.13.108

package/esm/inlined-worker.js

@@ -405,18 +405,7 @@ var MENU_RPC_TYPES = [
   "VIEW_PORT_MENU_ROW_RPC",
   "VIEW_PORT_MENU_CELL_RPC"
 ];
-var INVALID_SESSION = "Invalid session";
-var SESSION_LIMIT_EXCEEDED = "User session limit exceeded";
-var INVALID_TOKEN = "Invalid token";
-var TOKEN_EXPIRED = "Token has expired";
-var InvalidLoginMessages = [
-  INVALID_SESSION,
-  SESSION_LIMIT_EXCEEDED,
-  INVALID_TOKEN,
-  TOKEN_EXPIRED
-];
-var isLoginErrorMessage = (message) => typeof message === "string" && InvalidLoginMessages.includes(message);
-var isSelectRequest = (message) => message && typeof message === "object" && "type" in message && (message.type === "SELECT_ROW" || message.type === "DESELECT_ROW" || message.type === "SELECT_ROW_RANGE" || message.type === "SELECT_ALL" || message.type === "DESELECT_ALL");
+var isSelectRequest = (message) => "type" in message && (message.type === "SELECT_ROW" || message.type === "DESELECT_ROW" || message.type === "SELECT_ROW_RANGE" || message.type === "SELECT_ALL" || message.type === "DESELECT_ALL");
 var isRpcServiceRequest = (message) => message.type === "RPC_REQUEST";
 var hasViewPortContext = (message) => message.context.type === "VIEWPORT_CONTEXT";
 var isVuuMenuRpcRequest = (message) => MENU_RPC_TYPES.includes(message["type"]);
@@ -1448,195 +1437,9 @@ var toClientRowTree = ({ rowIndex, rowKey, sel: isSelected, data, ts }, keys) =>
   ].concat(rest);
 };
 
-// src/WebSocketConnection.ts
-var { debug: debug3, debugEnabled: debugEnabled3, info: info2 } = logger("WebSocketConnection");
-var isLoginRejectedMessage = (message) => message !== null && "type" in message && message.type === "LOGIN_REJECTED";
-var DEFAULT_CONNECTION_TIMEOUT = 1e4;
-var parseWebSocketMessage = (message) => {
-  try {
-    return JSON.parse(message);
-  } catch (e) {
-    throw Error(\`Error parsing JSON response from server \${message}\`);
-  }
-};
-var _callback, _confirmedOpen, _connectionPhase, _connectionStatus, _connectionTimeout, _deferredOpen, _protocols, _url, _ws;
-var WebSocketConnection = class extends EventEmitter {
-  constructor({
-    callback,
-    connectionTimeout = DEFAULT_CONNECTION_TIMEOUT,
-    protocols,
-    url
-  }) {
-    super();
-    __privateAdd(this, _callback);
-    /**
-     We are not confirmedOpen until we receive the first message from the
-     server. If we get an unexpected close event before that, we consider
-     the reconnect attempts as still within the connection phase, not true
-     reconnection. This can happen e.g. when connecting to remote host via
-     a proxy.
-    */
-    __privateAdd(this, _confirmedOpen, false);
-    __privateAdd(this, _connectionPhase, "initial-connection");
-    __privateAdd(this, _connectionStatus, "closed");
-    __privateAdd(this, _connectionTimeout);
-    __privateAdd(this, _deferredOpen);
-    __privateAdd(this, _protocols);
-    __privateAdd(this, _url);
-    __privateAdd(this, _ws);
-    __publicField(this, "receive", (evt) => {
-      if (isLoginErrorMessage(evt.data)) {
-        console.log(\`[WebSocketConnection] closed because of login issue\`);
-        if (__privateGet(this, _deferredOpen)) {
-          console.log(\`... and qwe have a deferred connection\`);
-        }
-        __privateGet(this, _callback).call(this, {
-          type: "LOGIN_REJECTED",
-          reason: evt.data
-        });
-        this.close(evt.data);
-      } else {
-        const vuuMessageFromServer = parseWebSocketMessage(evt.data);
-        if (debugEnabled3) {
-          if (vuuMessageFromServer.body.type !== "HB") {
-            debug3(\`\${vuuMessageFromServer.body.type}\`);
-            if (vuuMessageFromServer.body.type === "CHANGE_VP_SUCCESS") {
-              debug3(JSON.stringify(vuuMessageFromServer.body));
-            }
-          }
-        }
-        __privateGet(this, _callback).call(this, vuuMessageFromServer);
-        if (!this.confirmedOpen) {
-          if (vuuMessageFromServer.body.type === "LOGIN_SUCCESS") {
-            this.connectionStatus = __privateGet(this, _connectionPhase) === "initial-connection" ? "connected" : "reconnected";
-            this.confirmedOpen = true;
-          }
-        }
-      }
-    });
-    __publicField(this, "send", (msg) => {
-      var _a;
-      if (msg.body.type === "CHANGE_VP_RANGE") {
-        info2 == null ? void 0 : info2(
-          \`CHANGE_VP_RANGE<#\${msg.requestId}> \${msg.body.from}-\${msg.body.to}\`
-        );
-      }
-      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.send(JSON.stringify(msg));
-    });
-    __privateSet(this, _callback, callback);
-    __privateSet(this, _connectionTimeout, connectionTimeout);
-    __privateSet(this, _url, url);
-    __privateSet(this, _protocols, protocols);
-  }
-  get connectionTimeout() {
-    return __privateGet(this, _connectionTimeout);
-  }
-  get protocols() {
-    return __privateGet(this, _protocols);
-  }
-  get isClosed() {
-    return __privateGet(this, _connectionStatus) === "closed";
-  }
-  get isDisconnected() {
-    return __privateGet(this, _connectionStatus) === "disconnected";
-  }
-  get connectionPhase() {
-    return __privateGet(this, _connectionPhase);
-  }
-  get connectionStatus() {
-    return __privateGet(this, _connectionStatus);
-  }
-  set connectionStatus(connectionStatus) {
-    if (connectionStatus !== "connecting" && connectionStatus !== "reconnecting") {
-      __privateSet(this, _connectionStatus, connectionStatus);
-      this.emit("connection-status", __privateGet(this, _connectionStatus));
-    }
-  }
-  get confirmedOpen() {
-    return __privateGet(this, _confirmedOpen);
-  }
-  /**
-   * We are 'confirmedOpen' when we see the first message transmitted
-   * from the server. This ensures that even if we have one or more
-   * proxies in our route to the endPoint, all connections have been
-   * opened successfully.
-   * First time in here (on our initial successful connection) we switch
-   * from 'connect' phase to 'reconnect' phase. We may have different
-   * retry configurations for these two phases.
-   */
-  set confirmedOpen(confirmedOpen) {
-    __privateSet(this, _confirmedOpen, confirmedOpen);
-    if (confirmedOpen && __privateGet(this, _connectionPhase) === "initial-connection") {
-      __privateSet(this, _connectionPhase, "post-disconnect-reconnection");
-    }
-  }
-  get url() {
-    return __privateGet(this, _url);
-  }
-  async openWebSocket() {
-    var _a;
-    const initialConnect = __privateGet(this, _connectionPhase) === "initial-connection";
-    if (__privateGet(this, _deferredOpen) === void 0) {
-      __privateSet(this, _deferredOpen, new DeferredPromise());
-    }
-    const { connectionTimeout, protocols, url } = this;
-    __privateSet(this, _connectionStatus, initialConnect ? "connecting" : "reconnecting");
-    const timer = setTimeout(() => {
-      throw Error(
-        \`Failed to open WebSocket connection to \${url}, timed out after \${connectionTimeout}ms\`
-      );
-    }, connectionTimeout);
-    const ws = __privateSet(this, _ws, new WebSocket(url, protocols));
-    ws.onopen = () => {
-      this.connectionStatus = "websocket-open";
-      clearTimeout(timer);
-      if (__privateGet(this, _deferredOpen)) {
-        __privateGet(this, _deferredOpen).resolve(void 0);
-        __privateSet(this, _deferredOpen, void 0);
-      }
-    };
-    ws.onerror = () => {
-      clearTimeout(timer);
-    };
-    ws.onclose = () => {
-      if (!this.isClosed) {
-        this.confirmedOpen = false;
-        this.connectionStatus = "disconnected";
-        this.close("failure");
-      }
-    };
-    ws.onmessage = (evt) => {
-      this.receive(evt);
-    };
-    return (_a = __privateGet(this, _deferredOpen)) == null ? void 0 : _a.promise;
-  }
-  close(reason = "shutdown") {
-    var _a;
-    this.connectionStatus = "closed";
-    if (reason === "failure") {
-      if (__privateGet(this, _deferredOpen)) {
-        __privateGet(this, _deferredOpen).reject(Error("connection failed"));
-        __privateSet(this, _deferredOpen, void 0);
-      }
-    } else {
-      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.close();
-    }
-    __privateSet(this, _ws, void 0);
-  }
-};
-_callback = new WeakMap();
-_confirmedOpen = new WeakMap();
-_connectionPhase = new WeakMap();
-_connectionStatus = new WeakMap();
-_connectionTimeout = new WeakMap();
-_deferredOpen = new WeakMap();
-_protocols = new WeakMap();
-_url = new WeakMap();
-_ws = new WeakMap();
-
 // src/server-proxy/server-proxy.ts
 var _requestId = 1;
-var { debug: debug4, debugEnabled: debugEnabled4, error: error2, info: info3, infoEnabled: infoEnabled2, warn: warn2 } = logger("ServerProxy");
+var { debug: debug3, debugEnabled: debugEnabled3, error: error2, info: info2, infoEnabled: infoEnabled2, warn: warn2 } = logger("ServerProxy");
 var nextRequestId = () => \`\${_requestId++}\`;
 var DEFAULT_OPTIONS = {};
 var isActiveViewport = (viewPort) => viewPort.disabled !== true && viewPort.suspended !== true;
@@ -1673,15 +1476,13 @@ var ServerProxy = class {
     __publicField(this, "cachedTableMetaRequests", /* @__PURE__ */ new Map());
     __publicField(this, "cachedTableSchemas", /* @__PURE__ */ new Map());
     __publicField(this, "tableList");
-    __publicField(this, "connectionStatusChanged", (status) => {
-      if (status === "disconnected") {
-        this.sessionId = void 0;
+    __publicField(this, "connectionStatusChanged", (message) => {
+      if (message.connectionStatus === "disconnected") {
         this.clearAllViewports();
-      } else if (status === "reconnected") {
-        this.reconnect();
       }
     });
     __publicField(this, "reconnect", async () => {
+      await this.login(this.authToken);
       const [activeViewports, inactiveViewports] = partition(
         Array.from(this.viewports.values()),
         isActiveViewport
@@ -1717,6 +1518,7 @@ var ServerProxy = class {
     this.postMessageToClient = callback;
     this.viewports = /* @__PURE__ */ new Map();
     this.mapClientToServerViewport = /* @__PURE__ */ new Map();
+    connection.on("reconnected", this.reconnect);
     connection.on("connection-status", this.connectionStatusChanged);
   }
   async login(authToken) {
@@ -1772,8 +1574,8 @@ var ServerProxy = class {
         );
         if (clientResponse) {
           this.postMessageToClient(clientResponse);
-          if (debugEnabled4) {
-            debug4(
+          if (debugEnabled3) {
+            debug3(
               \`post DataSourceSubscribedMessage to client: \${JSON.stringify(
                 clientResponse
               )}\`
@@ -1847,7 +1649,7 @@ var ServerProxy = class {
   unsubscribe(clientViewportId) {
     const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
     if (serverViewportId) {
-      info3 == null ? void 0 : info3(
+      info2 == null ? void 0 : info2(
         \`Unsubscribe Message (Client to Server):
         \${serverViewportId}\`
       );
@@ -1889,26 +1691,26 @@ var ServerProxy = class {
   /**********************************************************************/
   setViewRange(viewport, message) {
     const requestId = nextRequestId();
-    infoEnabled2 && info3(\`setViewRange (\${message.range.from}:\${message.range.to})\`);
+    infoEnabled2 && info2(\`setViewRange (\${message.range.from}:\${message.range.to})\`);
     const [serverRequest, rows, debounceRequest] = viewport.rangeRequest(
       requestId,
       message.range
     );
     if (viewport.status === "subscribed") {
-      info3 == null ? void 0 : info3(\`setViewRange \${message.range.from} - \${message.range.to}\`);
+      info2 == null ? void 0 : info2(\`setViewRange \${message.range.from} - \${message.range.to}\`);
       if (serverRequest) {
         if (true) {
-          info3 == null ? void 0 : info3(
+          info2 == null ? void 0 : info2(
             \`CHANGE_VP_RANGE (\${message.range.from}-\${message.range.to}) => (\${serverRequest.from}-\${serverRequest.to})\`
           );
         }
-        infoEnabled2 && info3(
+        infoEnabled2 && info2(
           \`setViewRange send CHANGE_VP_RANGE<#\${requestId}> (\${serverRequest.from}-\${serverRequest.to})\`
         );
         this.sendMessageToServer(serverRequest, requestId);
       }
       if (rows) {
-        info3 == null ? void 0 : info3(\`setViewRange \${rows.length} rows returned from cache\`);
+        info2 == null ? void 0 : info2(\`setViewRange \${rows.length} rows returned from cache\`);
         this.postMessageToClient({
           mode: "update",
           type: "viewport-update",
@@ -1972,19 +1774,19 @@ var ServerProxy = class {
     viewport.suspend();
     if (escalateToDisable) {
       viewport.suspendTimer = setTimeout(() => {
-        info3 == null ? void 0 : info3("suspendTimer expired, escalate suspend to disable");
+        info2 == null ? void 0 : info2("suspendTimer expired, escalate suspend to disable");
         this.disableViewport(viewport);
       }, escalateDelay);
     }
   }
   resumeViewport(viewport) {
     if (viewport.suspendTimer) {
-      debug4 == null ? void 0 : debug4("clear suspend timer");
+      debug3 == null ? void 0 : debug3("clear suspend timer");
       clearTimeout(viewport.suspendTimer);
       viewport.suspendTimer = null;
     }
     const [size, rows] = viewport.resume();
-    debug4 == null ? void 0 : debug4(\`resumeViewport size \${size}, \${rows.length} rows sent to client\`);
+    debug3 == null ? void 0 : debug3(\`resumeViewport size \${size}, \${rows.length} rows sent to client\`);
     this.postMessageToClient({
       clientViewportId: viewport.clientViewportId,
       mode: "update",
@@ -2234,14 +2036,6 @@ var ServerProxy = class {
   }
   handleMessageFromServer(message) {
     var _a, _b;
-    if (isLoginRejectedMessage(message)) {
-      if (this.pendingLogin) {
-        this.pendingLogin.reject(message.reason);
-        this.pendingLogin = void 0;
-        this.authToken = "";
-      }
-      return;
-    }
     const { body, requestId, sessionId } = message;
     const pendingRequest = this.pendingRequests.get(requestId);
     if (pendingRequest) {
@@ -2271,6 +2065,9 @@ var ServerProxy = class {
           throw Error("LOGIN_SUCCESS did not provide sessionId");
         }
         break;
+      case "LOGIN_FAIL":
+        this.postMessageToClient(body);
+        break;
       case "REMOVE_VP_SUCCESS":
         {
           const viewport = viewports.get(body.viewPortId);
@@ -2317,8 +2114,8 @@ var ServerProxy = class {
             const response = viewport.completeOperation(requestId);
             if (response !== void 0) {
               this.postMessageToClient(response);
-              if (debugEnabled4) {
-                debug4(\`postMessageToClient \${JSON.stringify(response)}\`);
+              if (debugEnabled3) {
+                debug3(\`postMessageToClient \${JSON.stringify(response)}\`);
               }
             }
           }
@@ -2368,28 +2165,28 @@ var ServerProxy = class {
       case "TABLE_ROW":
         {
           const viewportRowMap = groupRowsByViewport(body.rows);
-          if (debugEnabled4) {
+          if (debugEnabled3) {
             const [firstRow] = body.rows;
             if (body.rows.length === 0) {
-              infoEnabled2 && info3("handleMessageFromServer TABLE_ROW 0 rows");
+              infoEnabled2 && info2("handleMessageFromServer TABLE_ROW 0 rows");
             } else if ((firstRow == null ? void 0 : firstRow.rowIndex) === -1) {
               if (body.rows.length === 1) {
                 if (firstRow.updateType === "SIZE") {
-                  infoEnabled2 && info3(
+                  infoEnabled2 && info2(
                     \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE ONLY \${firstRow.vpSize}\`
                   );
                 } else {
-                  infoEnabled2 && info3(
+                  infoEnabled2 && info2(
                     \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE \${firstRow.vpSize} rowIdx \${firstRow.rowIndex}\`
                   );
                 }
               } else {
-                infoEnabled2 && info3(
+                infoEnabled2 && info2(
                   \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows, SIZE \${firstRow.vpSize}, [\${body.rows.map((r) => r.rowIndex).join(",")}]\`
                 );
               }
             } else {
-              infoEnabled2 && info3(
+              infoEnabled2 && info2(
                 \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows [\${body.rows.map((r) => r.rowIndex).join(",")}]\`
               );
             }
@@ -2412,7 +2209,7 @@ var ServerProxy = class {
           const viewport = this.viewports.get(body.viewPortId);
           if (viewport) {
             const { from, to } = body;
-            infoEnabled2 && info3(\`CHANGE_VP_RANGE_SUCCESS<#\${requestId}> \${from} - \${to}\`);
+            infoEnabled2 && info2(\`CHANGE_VP_RANGE_SUCCESS<#\${requestId}> \${from} - \${to}\`);
             viewport.completeOperation(requestId, from, to);
           }
         }
@@ -2557,7 +2354,7 @@ var ServerProxy = class {
         error2(body.msg);
         break;
       default:
-        infoEnabled2 && info3(\`handleMessageFromServer \${body["type"]}.\`);
+        infoEnabled2 && info2(\`handleMessageFromServer \${body["type"]}.\`);
     }
   }
   cacheTableMeta(messageBody) {
@@ -2596,7 +2393,7 @@ var ServerProxy = class {
           const [rows, mode] = result;
           const size = viewport.getNewRowCount();
           if (size !== void 0 || rows && rows.length > 0) {
-            debugEnabled4 && debug4(
+            debugEnabled3 && debug3(
               \`postMessageToClient #\${viewport.clientViewportId} viewport-update \${mode}, \${(_a = rows == null ? void 0 : rows.length) != null ? _a : "no"} rows, size \${size}\`
             );
             if (mode) {
@@ -2615,31 +2412,316 @@ var ServerProxy = class {
   }
 };
 
+// src/WebSocketConnection.ts
+var { debug: debug4, debugEnabled: debugEnabled4, info: info3 } = logger("WebSocketConnection");
+var isNotConnecting = (connectionState) => connectionState.connectionStatus !== "connecting" && connectionState.connectionStatus !== "reconnecting";
+var isWebSocketConnectionMessage = (msg) => {
+  if ("connectionStatus" in msg) {
+    return [
+      "connecting",
+      "connected",
+      "connection-open-awaiting-session",
+      "reconnecting",
+      "reconnected",
+      "disconnected",
+      "closed",
+      "failed"
+    ].includes(msg.connectionStatus);
+  } else {
+    return false;
+  }
+};
+var DEFAULT_RETRY_LIMITS = {
+  connect: 5,
+  reconnect: 8
+};
+var DEFAULT_CONNECTION_TIMEOUT = 1e4;
+var ConnectingEndState = {
+  connecting: "connected",
+  reconnecting: "reconnected"
+};
+var parseWebSocketMessage = (message) => {
+  try {
+    return JSON.parse(message);
+  } catch (e) {
+    throw Error(\`Error parsing JSON response from server \${message}\`);
+  }
+};
+var _callback, _confirmedOpen, _connectionState, _connectionTimeout, _deferredConnection, _protocols, _reconnectAttempts, _requiresLogin, _url, _ws;
+var WebSocketConnection = class extends EventEmitter {
+  constructor({
+    callback,
+    connectionTimeout = DEFAULT_CONNECTION_TIMEOUT,
+    protocols,
+    retryLimits = DEFAULT_RETRY_LIMITS,
+    url
+  }) {
+    super();
+    __privateAdd(this, _callback);
+    /**
+     We are not confirmedOpen until we receive the first message from the
+     server. If we get an unexpected close event before that, we consider
+     the reconnect attempts as still within the connection phase, not true
+     reconnection. This can happen e.g. when connecting to remote host via
+     a proxy.
+    */
+    __privateAdd(this, _confirmedOpen, false);
+    __privateAdd(this, _connectionState);
+    __privateAdd(this, _connectionTimeout);
+    __privateAdd(this, _deferredConnection);
+    __privateAdd(this, _protocols);
+    __privateAdd(this, _reconnectAttempts);
+    __privateAdd(this, _requiresLogin, true);
+    __privateAdd(this, _url);
+    __privateAdd(this, _ws);
+    __publicField(this, "receive", (evt) => {
+      if (evt.data === "Invalid token" || evt.data === "Token has expired") {
+        const closeReason = evt.data === "Invalid token" ? "invalid-token" : "token-expired";
+        this.close(closeReason);
+      } else {
+        const vuuMessageFromServer = parseWebSocketMessage(evt.data);
+        if (vuuMessageFromServer.body.type === "CHANGE_VP_RANGE_SUCCESS") {
+          info3 == null ? void 0 : info3(\`CHANGE_VP_RANGE_SUCCESS<#\${vuuMessageFromServer.requestId}>\`);
+        }
+        if (debugEnabled4) {
+          if (vuuMessageFromServer.body.type !== "HB") {
+            debug4(\`\${vuuMessageFromServer.body.type}\`);
+            if (vuuMessageFromServer.body.type === "CHANGE_VP_SUCCESS") {
+              debug4(JSON.stringify(vuuMessageFromServer.body));
+            }
+          }
+        }
+        __privateGet(this, _callback).call(this, vuuMessageFromServer);
+      }
+    });
+    __publicField(this, "send", (msg) => {
+      var _a;
+      if (msg.body.type === "CHANGE_VP_RANGE") {
+        info3 == null ? void 0 : info3(
+          \`CHANGE_VP_RANGE<#\${msg.requestId}> \${msg.body.from}-\${msg.body.to}\`
+        );
+      }
+      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.send(JSON.stringify(msg));
+    });
+    __privateSet(this, _callback, callback);
+    __privateSet(this, _connectionTimeout, connectionTimeout);
+    __privateSet(this, _url, url);
+    __privateSet(this, _protocols, protocols);
+    __privateSet(this, _reconnectAttempts, {
+      retryAttemptsTotal: retryLimits.reconnect,
+      retryAttemptsRemaining: retryLimits.reconnect,
+      secondsToNextRetry: 1
+    });
+    __privateSet(this, _connectionState, {
+      connectionPhase: "connecting",
+      connectionStatus: "closed",
+      retryAttemptsTotal: retryLimits.connect,
+      retryAttemptsRemaining: retryLimits.connect,
+      secondsToNextRetry: 1
+    });
+  }
+  get connectionTimeout() {
+    return __privateGet(this, _connectionTimeout);
+  }
+  get protocols() {
+    return __privateGet(this, _protocols);
+  }
+  get requiresLogin() {
+    return __privateGet(this, _requiresLogin);
+  }
+  get isClosed() {
+    return this.status === "closed";
+  }
+  get isDisconnected() {
+    return this.status === "disconnected";
+  }
+  get isConnecting() {
+    return __privateGet(this, _connectionState).connectionPhase === "connecting";
+  }
+  get status() {
+    return __privateGet(this, _connectionState).connectionStatus;
+  }
+  set status(connectionStatus) {
+    __privateSet(this, _connectionState, {
+      ...__privateGet(this, _connectionState),
+      connectionStatus
+    });
+    if (isNotConnecting(__privateGet(this, _connectionState))) {
+      this.emit("connection-status", __privateGet(this, _connectionState));
+    }
+  }
+  get connectionState() {
+    return __privateGet(this, _connectionState);
+  }
+  get hasConnectionAttemptsRemaining() {
+    return __privateGet(this, _connectionState).retryAttemptsRemaining > 0;
+  }
+  get confirmedOpen() {
+    return __privateGet(this, _confirmedOpen);
+  }
+  /**
+   * We are 'confirmedOpen' when we see the first message transmitted
+   * from the server. This ensures that even if we have one or more
+   * proxies in our route to the endPoint, all connections have been
+   * opened successfully.
+   * First time in here (on our initial successful connection) we switch
+   * from 'connect' phase to 'reconnect' phase. We may have different
+   * retry configurations for these two phases.
+   */
+  set confirmedOpen(confirmedOpen) {
+    __privateSet(this, _confirmedOpen, confirmedOpen);
+    if (confirmedOpen && this.isConnecting) {
+      __privateSet(this, _connectionState, {
+        ...__privateGet(this, _connectionState),
+        connectionPhase: "reconnecting",
+        ...__privateGet(this, _reconnectAttempts)
+      });
+    } else if (confirmedOpen) {
+      __privateSet(this, _connectionState, {
+        ...__privateGet(this, _connectionState),
+        ...__privateGet(this, _reconnectAttempts)
+      });
+    }
+  }
+  get url() {
+    return __privateGet(this, _url);
+  }
+  async connect(clientCall = true) {
+    var _a;
+    const state = __privateGet(this, _connectionState);
+    if (this.isConnecting && __privateGet(this, _deferredConnection) === void 0) {
+      __privateSet(this, _deferredConnection, new DeferredPromise());
+    }
+    const { connectionTimeout, protocols, url } = this;
+    this.status = state.connectionPhase;
+    const timer = setTimeout(() => {
+      throw Error(
+        \`Failed to open WebSocket connection to \${url}, timed out after \${connectionTimeout}ms\`
+      );
+    }, connectionTimeout);
+    const ws2 = __privateSet(this, _ws, new WebSocket(url, protocols));
+    ws2.onopen = () => {
+      const connectedStatus = ConnectingEndState[state.connectionPhase];
+      this.status = connectedStatus;
+      clearTimeout(timer);
+      if (__privateGet(this, _deferredConnection)) {
+        __privateGet(this, _deferredConnection).resolve(void 0);
+        __privateSet(this, _deferredConnection, void 0);
+      }
+      if (this.isConnecting) {
+        this.emit("connected");
+      } else {
+        this.emit("reconnected");
+      }
+    };
+    ws2.onerror = () => {
+      clearTimeout(timer);
+    };
+    ws2.onclose = () => {
+      if (!this.isClosed) {
+        this.confirmedOpen = false;
+        this.status = "disconnected";
+        if (this.hasConnectionAttemptsRemaining) {
+          this.reconnect();
+        } else {
+          this.close("failure");
+        }
+      }
+    };
+    ws2.onmessage = (evt) => {
+      if (!this.confirmedOpen) {
+        this.confirmedOpen = true;
+      }
+      this.receive(evt);
+    };
+    if (clientCall) {
+      return (_a = __privateGet(this, _deferredConnection)) == null ? void 0 : _a.promise;
+    }
+  }
+  reconnect() {
+    const { retryAttemptsRemaining, secondsToNextRetry } = __privateGet(this, _connectionState);
+    setTimeout(() => {
+      __privateSet(this, _connectionState, {
+        ...__privateGet(this, _connectionState),
+        retryAttemptsRemaining: retryAttemptsRemaining - 1,
+        secondsToNextRetry: secondsToNextRetry * 2
+      });
+      this.connect(false);
+    }, secondsToNextRetry * 1e3);
+  }
+  close(reason = "shutdown") {
+    var _a;
+    this.status = "closed";
+    if (reason === "failure") {
+      if (__privateGet(this, _deferredConnection)) {
+        __privateGet(this, _deferredConnection).reject(Error("connection failed"));
+        __privateSet(this, _deferredConnection, void 0);
+      }
+    } else {
+      (_a = __privateGet(this, _ws)) == null ? void 0 : _a.close();
+    }
+    this.emit("closed", { type: "websocket-closed", reason });
+    __privateSet(this, _ws, void 0);
+  }
+};
+_callback = new WeakMap();
+_confirmedOpen = new WeakMap();
+_connectionState = new WeakMap();
+_connectionTimeout = new WeakMap();
+_deferredConnection = new WeakMap();
+_protocols = new WeakMap();
+_reconnectAttempts = new WeakMap();
+_requiresLogin = new WeakMap();
+_url = new WeakMap();
+_ws = new WeakMap();
+
 // src/worker.ts
-var serverProxy;
-var webSocketConnection;
+var server;
 var { info: info4, infoEnabled: infoEnabled3 } = logger("worker");
+var getRetryLimits = (retryLimitDisconnect, retryLimitStartup) => {
+  if (retryLimitDisconnect !== void 0 && retryLimitStartup !== void 0) {
+    return {
+      connect: retryLimitStartup,
+      reconnect: retryLimitDisconnect
+    };
+  } else if (retryLimitDisconnect !== void 0) {
+    return {
+      connect: retryLimitDisconnect,
+      reconnect: retryLimitDisconnect
+    };
+  } else if (retryLimitStartup !== void 0) {
+    return {
+      connect: retryLimitStartup,
+      reconnect: retryLimitStartup
+    };
+  }
+};
+var ws;
 var sendMessageToClient = (message) => {
   postMessage(message);
 };
-async function connectToServer(url, protocols, token) {
-  if (webSocketConnection === void 0 && serverProxy === void 0) {
-    webSocketConnection = new WebSocketConnection({
-      callback: (msg) => {
-        if (isConnectionQualityMetrics(msg)) {
-          postMessage({ type: "connection-metrics", messages: msg });
-        } else {
-          serverProxy.handleMessageFromServer(msg);
-        }
-      },
-      protocols,
-      url
-    });
-    webSocketConnection.on("connection-status", postMessage);
-    serverProxy = new ServerProxy(webSocketConnection, sendMessageToClient);
+async function connectToServer(url, protocols, token, retryLimitDisconnect, retryLimitStartup) {
+  const websocketConnection = ws = new WebSocketConnection({
+    callback: (msg) => {
+      if (isConnectionQualityMetrics(msg)) {
+        postMessage({ type: "connection-metrics", messages: msg });
+      } else if (isWebSocketConnectionMessage(msg)) {
+        postMessage(msg);
+      } else {
+        server.handleMessageFromServer(msg);
+      }
+    },
+    protocols,
+    retryLimits: getRetryLimits(retryLimitStartup, retryLimitDisconnect),
+    url
+  });
+  websocketConnection.on("connection-status", postMessage);
+  websocketConnection.on("closed", postMessage);
+  await websocketConnection.connect();
+  server = new ServerProxy(websocketConnection, sendMessageToClient);
+  if (websocketConnection.requiresLogin) {
+    return await server.login(token);
   }
-  await webSocketConnection.openWebSocket();
-  return serverProxy.login(token);
 }
 var handleMessageFromClient = async ({
   data: message
@@ -2650,7 +2732,9 @@ var handleMessageFromClient = async ({
         const sessionId = await connectToServer(
           message.url,
           message.protocol,
-          message.token
+          message.token,
+          message.retryLimitDisconnect,
+          message.retryLimitStartup
         );
         postMessage({ type: "connected", sessionId });
       } catch (err) {
@@ -2660,20 +2744,20 @@ var handleMessageFromClient = async ({
     // If any of the messages below are received BEFORE we have connected and created
     // the server - handle accordingly
     case "disconnect":
-      serverProxy.disconnect();
-      webSocketConnection == null ? void 0 : webSocketConnection.close();
+      server.disconnect();
+      ws == null ? void 0 : ws.close();
       break;
     case "subscribe":
       infoEnabled3 && info4(\`client subscribe: \${JSON.stringify(message)}\`);
-      serverProxy.subscribe(message);
+      server.subscribe(message);
       break;
     case "unsubscribe":
       infoEnabled3 && info4(\`client unsubscribe: \${JSON.stringify(message)}\`);
-      serverProxy.unsubscribe(message.viewport);
+      server.unsubscribe(message.viewport);
       break;
     default:
       infoEnabled3 && info4(\`client message: \${JSON.stringify(message)}\`);
-      serverProxy.handleMessageFromClient(message);
+      server.handleMessageFromClient(message);
   }
 };
 self.addEventListener("message", handleMessageFromClient);