@vuu-ui/vuu-data-remote 0.8.93 → 0.8.95

package/esm/inlined-worker.js

@@ -1,7 +1,10 @@
 const workerSourceCode = `
+var __defProp = Object.defineProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
@@ -75,6 +78,8 @@ function getFullRange({ from, to }, bufferSize = 0, totalRowCount = Number.MAX_S
 var withinRange = (value, { from, to }) => value >= from && value < to;
 var WindowRange = class _WindowRange {
   constructor(from, to) {
+    __publicField(this, "from");
+    __publicField(this, "to");
     this.from = from;
     this.to = to;
   }
@@ -91,7 +96,6 @@ var WindowRange = class _WindowRange {
 };
 
 // ../vuu-utils/src/datasource-utils.ts
-var isConnectionStatusMessage = (msg) => msg.type === "connection-status";
 var isConnectionQualityMetrics = (msg) => msg.type === "connection-metrics";
 var isVisualLinkMessage = (msg) => msg.type.endsWith("_VISUAL_LINK");
 var isViewportMessage = (msg) => "viewport" in msg;
@@ -104,29 +108,29 @@ var NO_OP = () => void 0;
 var DEFAULT_DEBUG_LEVEL = false ? "error" : "info";
 var { loggingLevel = DEFAULT_DEBUG_LEVEL } = getLoggingSettings();
 var logger = (category) => {
-  const debugEnabled5 = loggingLevel === "debug";
-  const infoEnabled5 = debugEnabled5 || loggingLevel === "info";
-  const warnEnabled = infoEnabled5 || loggingLevel === "warn";
+  const debugEnabled4 = loggingLevel === "debug";
+  const infoEnabled4 = debugEnabled4 || loggingLevel === "info";
+  const warnEnabled = infoEnabled4 || loggingLevel === "warn";
   const errorEnabled = warnEnabled || loggingLevel === "error";
-  const info5 = infoEnabled5 ? (message) => console.info(\`[\${category}] \${message}\`) : NO_OP;
-  const warn4 = warnEnabled ? (message) => console.warn(\`[\${category}] \${message}\`) : NO_OP;
-  const debug5 = debugEnabled5 ? (message) => console.debug(\`[\${category}] \${message}\`) : NO_OP;
-  const error4 = errorEnabled ? (message) => console.error(\`[\${category}] \${message}\`) : NO_OP;
+  const info4 = infoEnabled4 ? (message) => console.info(\`[\${category}] \${message}\`) : NO_OP;
+  const warn3 = warnEnabled ? (message) => console.warn(\`[\${category}] \${message}\`) : NO_OP;
+  const debug4 = debugEnabled4 ? (message) => console.debug(\`[\${category}] \${message}\`) : NO_OP;
+  const error3 = errorEnabled ? (message) => console.error(\`[\${category}] \${message}\`) : NO_OP;
   if (false) {
     return {
       errorEnabled,
-      error: error4
+      error: error3
     };
   } else {
     return {
-      debugEnabled: debugEnabled5,
-      infoEnabled: infoEnabled5,
+      debugEnabled: debugEnabled4,
+      infoEnabled: infoEnabled4,
       warnEnabled,
       errorEnabled,
-      info: info5,
-      warn: warn4,
-      debug: debug5,
-      error: error4
+      info: info4,
+      warn: warn3,
+      debug: debug4,
+      error: error3
     };
   }
 };
@@ -153,8 +157,8 @@ var { debug, debugEnabled } = logger("range-monitor");
 var RangeMonitor = class {
   constructor(source) {
     this.source = source;
-    this.range = { from: 0, to: 0 };
-    this.timestamp = 0;
+    __publicField(this, "range", { from: 0, to: 0 });
+    __publicField(this, "timestamp", 0);
   }
   isSet() {
     return this.timestamp !== 0;
@@ -174,12 +178,116 @@ var RangeMonitor = class {
   }
 };
 
+// ../vuu-utils/src/event-emitter.ts
+function isArrayOfListeners(listeners) {
+  return Array.isArray(listeners);
+}
+function isOnlyListener(listeners) {
+  return !Array.isArray(listeners);
+}
+var _events;
+var EventEmitter = class {
+  constructor() {
+    __privateAdd(this, _events, /* @__PURE__ */ new Map());
+  }
+  addListener(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (!listeners) {
+      __privateGet(this, _events).set(event, listener);
+    } else if (isArrayOfListeners(listeners)) {
+      listeners.push(listener);
+    } else if (isOnlyListener(listeners)) {
+      __privateGet(this, _events).set(event, [listeners, listener]);
+    }
+  }
+  removeListener(event, listener) {
+    if (!__privateGet(this, _events).has(event)) {
+      return;
+    }
+    const listenerOrListeners = __privateGet(this, _events).get(event);
+    let position = -1;
+    if (listenerOrListeners === listener) {
+      __privateGet(this, _events).delete(event);
+    } else if (Array.isArray(listenerOrListeners)) {
+      for (let i = listenerOrListeners.length; i-- > 0; ) {
+        if (listenerOrListeners[i] === listener) {
+          position = i;
+          break;
+        }
+      }
+      if (position < 0) {
+        return;
+      }
+      if (listenerOrListeners.length === 1) {
+        listenerOrListeners.length = 0;
+        __privateGet(this, _events).delete(event);
+      } else {
+        listenerOrListeners.splice(position, 1);
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event && __privateGet(this, _events).has(event)) {
+      __privateGet(this, _events).delete(event);
+    } else if (event === void 0) {
+      __privateGet(this, _events).clear();
+    }
+  }
+  emit(event, ...args) {
+    if (__privateGet(this, _events)) {
+      const handler = __privateGet(this, _events).get(event);
+      if (handler) {
+        this.invokeHandler(handler, args);
+      }
+    }
+  }
+  once(event, listener) {
+    const handler = (...args) => {
+      this.removeListener(event, handler);
+      listener(...args);
+    };
+    this.on(event, handler);
+  }
+  on(event, listener) {
+    this.addListener(event, listener);
+  }
+  hasListener(event, listener) {
+    const listeners = __privateGet(this, _events).get(event);
+    if (Array.isArray(listeners)) {
+      return listeners.includes(listener);
+    } else {
+      return listeners === listener;
+    }
+  }
+  invokeHandler(handler, args) {
+    if (isArrayOfListeners(handler)) {
+      handler.slice().forEach((listener) => this.invokeHandler(listener, args));
+    } else {
+      switch (args.length) {
+        case 0:
+          handler();
+          break;
+        case 1:
+          handler(args[0]);
+          break;
+        case 2:
+          handler(args[0], args[1]);
+          break;
+        default:
+          handler.call(null, ...args);
+      }
+    }
+  }
+};
+_events = new WeakMap();
+
 // ../vuu-utils/src/keyset.ts
 var EMPTY = [];
 var KeySet = class {
   constructor(range) {
-    this.keys = /* @__PURE__ */ new Map();
-    this.nextKeyValue = 0;
+    __publicField(this, "keys", /* @__PURE__ */ new Map());
+    __publicField(this, "nextKeyValue", 0);
+    __publicField(this, "range");
     this.range = range;
     this.init(range);
   }
@@ -239,6 +347,38 @@ var KeySet = class {
   }
 };
 
+// ../vuu-utils/src/promise-utils.ts
+var _promise, _resolve, _reject, _resolved;
+var DeferredPromise = class {
+  constructor() {
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolve, () => console.log("resolve was not set"));
+    __privateAdd(this, _reject, () => console.log("reject was not set"));
+    __privateAdd(this, _resolved, false);
+    __privateSet(this, _promise, new Promise((resolve, reject) => {
+      __privateSet(this, _resolve, resolve);
+      __privateSet(this, _reject, reject);
+    }));
+  }
+  get promise() {
+    return __privateGet(this, _promise);
+  }
+  get isResolved() {
+    return __privateGet(this, _resolved);
+  }
+  resolve(value) {
+    __privateSet(this, _resolved, true);
+    return __privateGet(this, _resolve).call(this, value);
+  }
+  get reject() {
+    return __privateGet(this, _reject);
+  }
+};
+_promise = new WeakMap();
+_resolve = new WeakMap();
+_reject = new WeakMap();
+_resolved = new WeakMap();
+
 // ../vuu-utils/src/protocol-message-utils.ts
 var MENU_RPC_TYPES = [
   "VIEW_PORT_MENUS_SELECT_RPC",
@@ -411,7 +551,12 @@ var ArrayBackedMovingWindow = class {
   // Note, the buffer is already accounted for in the range passed in here
   constructor({ from: clientFrom, to: clientTo }, { from, to }, bufferSize) {
     __privateAdd(this, _range);
-    this.setRowCount = (rowCount) => {
+    __publicField(this, "bufferSize");
+    __publicField(this, "internalData");
+    __publicField(this, "rowsWithinRange");
+    __publicField(this, "clientRange");
+    __publicField(this, "rowCount");
+    __publicField(this, "setRowCount", (rowCount) => {
       var _a;
       (_a = log.info) == null ? void 0 : _a.call(log, \`setRowCount \${rowCount}\`);
       if (rowCount < this.internalData.length) {
@@ -428,8 +573,8 @@ var ArrayBackedMovingWindow = class {
         }
       }
       this.rowCount = rowCount;
-    };
-    this.bufferBreakout = (from, to) => {
+    });
+    __publicField(this, "bufferBreakout", (from, to) => {
       const bufferPerimeter = this.bufferSize * 0.25;
       if (__privateGet(this, _range).to - to < bufferPerimeter) {
         return true;
@@ -438,7 +583,7 @@ var ArrayBackedMovingWindow = class {
       } else {
         return false;
       }
-    };
+    });
     this.bufferSize = bufferSize;
     this.clientRange = new WindowRange(clientFrom, clientTo);
     __privateSet(this, _range, new WindowRange(from, to));
@@ -618,6 +763,7 @@ var NO_UPDATE_STATUS = {
   size: 0,
   ts: 0
 };
+var _status, _clientRange;
 var Viewport = class {
   constructor({
     aggregations,
@@ -632,29 +778,51 @@ var Viewport = class {
     viewport,
     visualLink
   }, postMessageToClient) {
+    __privateAdd(this, _status, "");
+    __publicField(this, "aggregations");
     /** batchMode is irrelevant for Vuu Table, it was introduced to try and improve rendering performance of AgGrid */
-    this.batchMode = true;
-    this.hasUpdates = false;
-    this.pendingUpdates = [];
-    this.pendingOperations = /* @__PURE__ */ new Map();
-    this.pendingRangeRequests = [];
-    this.rowCountChanged = false;
-    this.selectedRows = [];
-    this.useBatchMode = true;
-    this.lastUpdateStatus = NO_UPDATE_STATUS;
-    this.updateThrottleTimer = void 0;
-    this.rangeMonitor = new RangeMonitor("ViewPort");
-    this.disabled = false;
-    this.isTree = false;
+    __publicField(this, "batchMode", true);
+    __publicField(this, "bufferSize");
+    /**
+     * clientRange is always the range requested by the client. We should assume
+     * these are the rows visible to the user
+     * TODO what is clientRange needed for ?
+     */
+    __privateAdd(this, _clientRange);
+    __publicField(this, "columns");
+    __publicField(this, "dataWindow");
+    __publicField(this, "filter");
+    __publicField(this, "groupBy");
+    __publicField(this, "sort");
+    __publicField(this, "hasUpdates", false);
+    __publicField(this, "pendingUpdates", []);
+    __publicField(this, "keys");
+    __publicField(this, "pendingLinkedParent");
+    __publicField(this, "pendingOperations", /* @__PURE__ */ new Map());
+    __publicField(this, "pendingRangeRequests", []);
+    __publicField(this, "postMessageToClient");
+    __publicField(this, "rowCountChanged", false);
+    __publicField(this, "selectedRows", []);
+    __publicField(this, "useBatchMode", true);
+    __publicField(this, "lastUpdateStatus", NO_UPDATE_STATUS);
+    __publicField(this, "updateThrottleTimer");
+    __publicField(this, "rangeMonitor", new RangeMonitor("ViewPort"));
+    __publicField(this, "clientViewportId");
+    __publicField(this, "disabled", false);
+    __publicField(this, "isTree", false);
+    __publicField(this, "links");
+    __publicField(this, "linkedParent");
+    __publicField(this, "serverViewportId");
     // TODO roll disabled/suspended into status
-    this.status = "";
-    this.suspended = false;
-    this.suspendTimer = null;
+    __publicField(this, "suspended", false);
+    __publicField(this, "suspendTimer", null);
+    __publicField(this, "table");
+    __publicField(this, "title");
     // Records SIZE only updates
-    this.setLastSizeOnlyUpdateSize = (size) => {
+    __publicField(this, "setLastSizeOnlyUpdateSize", (size) => {
       this.lastUpdateStatus.size = size;
-    };
-    this.setLastUpdate = (mode) => {
+    });
+    __publicField(this, "setLastUpdate", (mode) => {
       const { ts: lastTS, mode: lastMode } = this.lastUpdateStatus;
       let elapsedTime = 0;
       if (lastMode === mode) {
@@ -669,8 +837,8 @@ var Viewport = class {
       }
       this.lastUpdateStatus.mode = mode;
       return elapsedTime;
-    };
-    this.rangeRequestAlreadyPending = (range) => {
+    });
+    __publicField(this, "rangeRequestAlreadyPending", (range) => {
       const { bufferSize } = this;
       const bufferThreshold = bufferSize * 0.25;
       let { from: stillPendingFrom } = range;
@@ -684,8 +852,8 @@ var Viewport = class {
         }
       }
       return false;
-    };
-    this.sendThrottledSizeMessage = () => {
+    });
+    __publicField(this, "sendThrottledSizeMessage", () => {
       this.updateThrottleTimer = void 0;
       this.lastUpdateStatus.count = 3;
       this.postMessageToClient({
@@ -694,15 +862,15 @@ var Viewport = class {
         size: this.lastUpdateStatus.size,
         type: "viewport-update"
       });
-    };
+    });
     // If we are receiving multiple SIZE updates but no data, table is loading rows
     // outside of our viewport. We can safely throttle these requests. Doing so will
     // alleviate pressure on UI DataTable.
-    this.shouldThrottleMessage = (mode) => {
+    __publicField(this, "shouldThrottleMessage", (mode) => {
       const elapsedTime = this.setLastUpdate(mode);
       return mode === "size-only" && elapsedTime > 0 && elapsedTime < 500 && this.lastUpdateStatus.count > 3;
-    };
-    this.throttleMessage = (mode) => {
+    });
+    __publicField(this, "throttleMessage", (mode) => {
       if (this.shouldThrottleMessage(mode)) {
         info == null ? void 0 : info("throttling updates setTimeout to 2000");
         if (this.updateThrottleTimer === void 0) {
@@ -717,16 +885,16 @@ var Viewport = class {
         this.updateThrottleTimer = void 0;
       }
       return false;
-    };
-    this.getNewRowCount = () => {
+    });
+    __publicField(this, "getNewRowCount", () => {
       if (this.rowCountChanged && this.dataWindow) {
         this.rowCountChanged = false;
         return this.dataWindow.rowCount;
       }
-    };
+    });
     this.aggregations = aggregations;
     this.bufferSize = bufferSize;
-    this.clientRange = range;
+    __privateSet(this, _clientRange, range);
     this.clientViewportId = viewport;
     this.columns = columns;
     this.filter = filter;
@@ -740,7 +908,7 @@ var Viewport = class {
       \`constructor #\${viewport} \${table.table} bufferSize=\${bufferSize}\`
     ));
     this.dataWindow = new ArrayBackedMovingWindow(
-      this.clientRange,
+      __privateGet(this, _clientRange),
       range,
       this.bufferSize
     );
@@ -756,13 +924,22 @@ var Viewport = class {
     var _a;
     return (_a = this.dataWindow.rowCount) != null ? _a : 0;
   }
+  get clientRange() {
+    return __privateGet(this, _clientRange);
+  }
+  get status() {
+    return __privateGet(this, _status);
+  }
+  set status(status) {
+    __privateSet(this, _status, status);
+  }
   subscribe() {
     const { filter } = this.filter;
-    this.status = this.status === "subscribed" ? "resubscribing" : "subscribing";
+    this.status = __privateGet(this, _status) === "subscribed" ? "resubscribing" : "subscribing";
     return {
       type: CREATE_VP,
       table: this.table,
-      range: getFullRange(this.clientRange, this.bufferSize),
+      range: getFullRange(__privateGet(this, _clientRange), this.bufferSize),
       aggregations: this.aggregations,
       columns: this.columns,
       sort: this.sort,
@@ -1269,6 +1446,8 @@ var Viewport = class {
     }
   }
 };
+_status = new WeakMap();
+_clientRange = new WeakMap();
 var toClientRow = ({ rowIndex, rowKey, sel: isSelected, data }, keys, selectedRows) => {
   return [
     rowIndex,
@@ -1321,36 +1500,56 @@ function addLabelsToLinks(links, viewports) {
 }
 var ServerProxy = class {
   constructor(connection, callback) {
-    this.authToken = "";
-    this.user = "user";
-    this.pendingRequests = /* @__PURE__ */ new Map();
-    this.queuedRequests = [];
-    this.cachedTableMetaRequests = /* @__PURE__ */ new Map();
-    this.cachedTableSchemas = /* @__PURE__ */ new Map();
+    __publicField(this, "connection");
+    __publicField(this, "postMessageToClient");
+    __publicField(this, "viewports");
+    __publicField(this, "mapClientToServerViewport");
+    __publicField(this, "authToken", "");
+    __publicField(this, "user", "user");
+    __publicField(this, "pendingLogin");
+    __publicField(this, "pendingRequests", /* @__PURE__ */ new Map());
+    __publicField(this, "sessionId");
+    __publicField(this, "queuedRequests", []);
+    __publicField(this, "cachedTableMetaRequests", /* @__PURE__ */ new Map());
+    __publicField(this, "cachedTableSchemas", /* @__PURE__ */ new Map());
+    __publicField(this, "tableList");
+    __publicField(this, "reconnect", async () => {
+      await this.login(this.authToken);
+      const [activeViewports, inactiveViewports] = partition(
+        Array.from(this.viewports.values()),
+        isActiveViewport
+      );
+      this.viewports.clear();
+      this.mapClientToServerViewport.clear();
+      const reconnectViewports = (viewports) => {
+        viewports.forEach((viewport) => {
+          const { clientViewportId } = viewport;
+          this.awaitResponseToMessage(
+            viewport.subscribe(),
+            clientViewportId
+          ).then((msg) => {
+            if (msg.type === "CREATE_VP_SUCCESS") {
+              this.mapClientToServerViewport.set(
+                clientViewportId,
+                msg.viewPortId
+              );
+              this.viewports.set(msg.viewPortId, viewport);
+              viewport.status = "subscribed";
+              viewport.serverViewportId = msg.viewPortId;
+            }
+          });
+        });
+      };
+      reconnectViewports(activeViewports);
+      setTimeout(() => {
+        reconnectViewports(inactiveViewports);
+      }, 2e3);
+    });
     this.connection = connection;
     this.postMessageToClient = callback;
     this.viewports = /* @__PURE__ */ new Map();
     this.mapClientToServerViewport = /* @__PURE__ */ new Map();
-  }
-  async reconnect() {
-    await this.login(this.authToken);
-    const [activeViewports, inactiveViewports] = partition(
-      Array.from(this.viewports.values()),
-      isActiveViewport
-    );
-    this.viewports.clear();
-    this.mapClientToServerViewport.clear();
-    const reconnectViewports = (viewports) => {
-      viewports.forEach((viewport) => {
-        const { clientViewportId } = viewport;
-        this.viewports.set(clientViewportId, viewport);
-        this.sendMessageToServer(viewport.subscribe(), clientViewportId);
-      });
-    };
-    reconnectViewports(activeViewports);
-    setTimeout(() => {
-      reconnectViewports(inactiveViewports);
-    }, 2e3);
+    connection.on("reconnected", this.reconnect);
   }
   async login(authToken, user = "user") {
     if (authToken) {
@@ -1367,6 +1566,16 @@ var ServerProxy = class {
       error2("login, cannot login until auth token has been obtained");
     }
   }
+  disconnect() {
+    this.viewports.forEach((viewport) => {
+      const { clientViewportId } = viewport;
+      this.unsubscribe(clientViewportId);
+      this.postMessageToClient({
+        clientViewportId,
+        type: "viewport-clear"
+      });
+    });
+  }
   subscribe(message) {
     if (!this.mapClientToServerViewport.has(message.viewport)) {
       const pendingTableSchema = this.getTableMeta(message.table);
@@ -1432,30 +1641,38 @@ var ServerProxy = class {
       error2(\`spurious subscribe call \${message.viewport}\`);
     }
   }
+  /**
+   * Currently we only queue range requests, this may change
+   */
+  addRequestToQueue(queuedRequest) {
+    const isDifferentTypeViewport = (qr) => qr.clientViewportId !== queuedRequest.clientViewportId || queuedRequest.message.type !== qr.message.type;
+    if (!this.queuedRequests.every(isDifferentTypeViewport)) {
+      this.queuedRequests = this.queuedRequests.filter(isDifferentTypeViewport);
+    }
+    this.queuedRequests.push(queuedRequest);
+  }
   processQueuedRequests() {
-    const messageTypesProcessed = {};
-    while (this.queuedRequests.length) {
-      const queuedRequest = this.queuedRequests.pop();
-      if (queuedRequest) {
-        const { clientViewportId, message, requestId } = queuedRequest;
-        if (message.type === "CHANGE_VP_RANGE") {
-          if (messageTypesProcessed.CHANGE_VP_RANGE) {
-            continue;
-          }
-          messageTypesProcessed.CHANGE_VP_RANGE = true;
-          const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
-          if (serverViewportId) {
-            this.sendMessageToServer(
-              {
-                ...message,
-                viewPortId: serverViewportId
-              },
-              requestId
-            );
-          }
-        }
+    const newQueue = [];
+    for (const queuedRequest of this.queuedRequests) {
+      const { clientViewportId, message, requestId } = queuedRequest;
+      const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
+      if (serverViewportId) {
+        this.sendMessageToServer(
+          {
+            ...message,
+            viewPortId: serverViewportId
+          },
+          requestId
+        );
+      } else if (this.viewports.has(clientViewportId)) {
+        newQueue.push(queuedRequest);
+      } else {
+        console.warn(
+          \`ServerProxy processQueuedRequests, \${message.type} request not found \${clientViewportId}\`
+        );
       }
     }
+    this.queuedRequests = newQueue;
   }
   unsubscribe(clientViewportId) {
     const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
@@ -1506,36 +1723,33 @@ var ServerProxy = class {
       requestId,
       message.range
     );
-    info2 == null ? void 0 : info2(\`setViewRange \${message.range.from} - \${message.range.to}\`);
-    if (serverRequest) {
-      if (true) {
-        info2 == null ? void 0 : info2(
-          \`CHANGE_VP_RANGE [\${message.range.from}-\${message.range.to}] => [\${serverRequest.from}-\${serverRequest.to}]\`
-        );
+    if (viewport.status === "subscribed") {
+      info2 == null ? void 0 : info2(\`setViewRange \${message.range.from} - \${message.range.to}\`);
+      if (serverRequest) {
+        if (true) {
+          info2 == null ? void 0 : info2(
+            \`CHANGE_VP_RANGE [\${message.range.from}-\${message.range.to}] => [\${serverRequest.from}-\${serverRequest.to}]\`
+          );
+        }
+        this.sendMessageToServer(serverRequest, requestId);
       }
-      const sentToServer = this.sendIfReady(
-        serverRequest,
-        requestId,
-        viewport.status === "subscribed"
-      );
-      if (!sentToServer) {
-        this.queuedRequests.push({
-          clientViewportId: message.viewport,
-          message: serverRequest,
-          requestId
+      if (rows) {
+        info2 == null ? void 0 : info2(\`setViewRange \${rows.length} rows returned from cache\`);
+        this.postMessageToClient({
+          mode: "batch",
+          type: "viewport-update",
+          clientViewportId: viewport.clientViewportId,
+          rows
         });
+      } else if (debounceRequest) {
+        this.postMessageToClient(debounceRequest);
       }
-    }
-    if (rows) {
-      info2 == null ? void 0 : info2(\`setViewRange \${rows.length} rows returned from cache\`);
-      this.postMessageToClient({
-        mode: "batch",
-        type: "viewport-update",
-        clientViewportId: viewport.clientViewportId,
-        rows
+    } else if (serverRequest) {
+      this.addRequestToQueue({
+        clientViewportId: message.viewport,
+        message: serverRequest,
+        requestId
       });
-    } else if (debounceRequest) {
-      this.postMessageToClient(debounceRequest);
     }
   }
   setConfig(viewport, message) {
@@ -1751,6 +1965,8 @@ var ServerProxy = class {
       );
     } else if (isVuuMenuRpcRequest(message)) {
       return this.menuRpcCall(message);
+    } else if (message.type === "disconnect") {
+      return this.disconnect();
     } else {
       const { type, requestId } = message;
       switch (type) {
@@ -2064,13 +2280,12 @@ var ServerProxy = class {
         }
         break;
       case "VIEW_PORT_MENU_REJ": {
-        console.log(\`send menu error back to client\`);
-        const { error: error4, rpcName, vpId } = body;
+        const { error: error3, rpcName, vpId } = body;
         const viewport = this.viewports.get(vpId);
         if (viewport) {
           this.postMessageToClient({
             clientViewportId: viewport.clientViewportId,
-            error: error4,
+            error: error3,
             rpcName,
             type: "VIEW_PORT_MENU_REJ",
             requestId
@@ -2198,233 +2413,295 @@ var ServerProxy = class {
   }
 };
 
-// src/websocket-connection.ts
-var { debug: debug4, debugEnabled: debugEnabled4, error: error3, info: info3, infoEnabled: infoEnabled3, warn: warn3 } = logger(
-  "websocket-connection"
-);
-var connectionAttemptStatus = {};
-var setWebsocket = Symbol("setWebsocket");
-var connectionCallback = Symbol("connectionCallback");
-async function connect(connectionString, protocol, callback, retryLimitDisconnect = 10, retryLimitStartup = 5) {
-  connectionAttemptStatus[connectionString] = {
-    status: "connecting",
-    connect: {
-      allowed: retryLimitStartup,
-      remaining: retryLimitStartup
-    },
-    reconnect: {
-      allowed: retryLimitDisconnect,
-      remaining: retryLimitDisconnect
-    }
-  };
-  return makeConnection(connectionString, protocol, callback);
-}
-async function reconnect(_) {
-  throw Error("connection broken");
-}
-async function makeConnection(url, protocol, callback, connection) {
-  const {
-    status: currentStatus,
-    connect: connectStatus,
-    reconnect: reconnectStatus
-  } = connectionAttemptStatus[url];
-  const trackedStatus = currentStatus === "connecting" ? connectStatus : reconnectStatus;
-  try {
-    callback({ type: "connection-status", status: "connecting" });
-    const reconnecting = typeof connection !== "undefined";
-    const ws = await createWebsocket(url, protocol);
-    console.info(
-      "%c\u26A1 %cconnected",
-      "font-size: 24px;color: green;font-weight: bold;",
-      "color:green; font-size: 14px;"
-    );
-    if (connection !== void 0) {
-      connection[setWebsocket](ws);
-    }
-    const websocketConnection = connection != null ? connection : new WebsocketConnection(ws, url, protocol, callback);
-    const status = reconnecting ? "reconnected" : "connection-open-awaiting-session";
-    callback({ type: "connection-status", status });
-    websocketConnection.status = status;
-    trackedStatus.remaining = trackedStatus.allowed;
-    return websocketConnection;
-  } catch (err) {
-    const retry = --trackedStatus.remaining > 0;
-    callback({
-      type: "connection-status",
-      status: "disconnected",
-      reason: "failed to connect",
-      retry
-    });
-    if (retry) {
-      return makeConnectionIn(url, protocol, callback, connection, 2e3);
-    } else {
-      callback({
-        type: "connection-status",
-        status: "failed",
-        reason: "unable to connect",
-        retry
-      });
-      throw Error("Failed to establish connection");
-    }
+// src/WebSocketConnection.ts
+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 makeConnectionIn = (url, protocol, callback, connection, delay) => new Promise((resolve) => {
-  setTimeout(() => {
-    resolve(makeConnection(url, protocol, callback, connection));
-  }, delay);
-});
-var createWebsocket = (websocketUrl, protocol) => new Promise((resolve, reject) => {
-  if (infoEnabled3 && protocol !== void 0) {
-    info3(\`WebSocket Protocol \${protocol == null ? void 0 : protocol.toString()}\`);
-  }
-  const ws = new WebSocket(websocketUrl, protocol);
-  ws.onopen = () => resolve(ws);
-  ws.onerror = (evt) => reject(evt);
-});
-var closeWarn = () => {
-  warn3 == null ? void 0 : warn3(\`Connection cannot be closed, socket not yet opened\`);
 };
-var sendWarn = (msg) => {
-  warn3 == null ? void 0 : warn3(\`Message cannot be sent, socket closed \${msg.body.type}\`);
+var DEFAULT_RETRY_LIMITS = {
+  connect: 5,
+  reconnect: 8
 };
-var parseMessage = (message) => {
+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 WebsocketConnection = class {
-  constructor(ws, url, protocol, callback) {
-    this.close = closeWarn;
-    this.requiresLogin = true;
-    this.send = sendWarn;
-    this.status = "ready";
-    this.messagesCount = 0;
-    this.connectionMetricsInterval = null;
-    this.handleWebsocketMessage = (evt) => {
-      const vuuMessageFromServer = parseMessage(evt.data);
-      this.messagesCount += 1;
-      if (true) {
-        if (debugEnabled4 && vuuMessageFromServer.body.type !== "HB") {
-          debug4 == null ? void 0 : debug4(\`<<< \${vuuMessageFromServer.body.type}\`);
-        }
-      }
-      this[connectionCallback](vuuMessageFromServer);
-    };
-    this.url = url;
-    this.protocol = protocol;
-    this[connectionCallback] = callback;
-    this[setWebsocket](ws);
+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) => {
+      const vuuMessageFromServer = parseWebSocketMessage(evt.data);
+      __privateGet(this, _callback).call(this, vuuMessageFromServer);
+    });
+    __publicField(this, "send", (msg) => {
+      var _a;
+      (_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
+    });
   }
-  reconnect() {
-    reconnect(this);
-  }
-  [(connectionCallback, setWebsocket)](ws) {
-    const callback = this[connectionCallback];
-    ws.onmessage = (evt) => {
-      this.status = "connected";
-      ws.onmessage = this.handleWebsocketMessage;
-      this.handleWebsocketMessage(evt);
-    };
-    this.connectionMetricsInterval = setInterval(() => {
-      callback({
-        type: "connection-metrics",
-        messagesLength: this.messagesCount
+  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)
       });
-      this.messagesCount = 0;
-    }, 2e3);
-    ws.onerror = () => {
-      error3(\`\u26A1 connection error\`);
-      callback({
-        type: "connection-status",
-        status: "disconnected",
-        reason: "error"
+    } else if (confirmedOpen) {
+      __privateSet(this, _connectionState, {
+        ...__privateGet(this, _connectionState),
+        ...__privateGet(this, _reconnectAttempts)
       });
-      if (this.connectionMetricsInterval) {
-        clearInterval(this.connectionMetricsInterval);
-        this.connectionMetricsInterval = null;
+    }
+  }
+  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.status === "connection-open-awaiting-session") {
-        error3(
-          \`Websocket connection lost before Vuu session established, check websocket configuration\`
-        );
-      } else if (this.status !== "closed") {
-        reconnect(this);
-        this.send = queue;
+      if (this.isConnecting) {
+        this.emit("connected");
+      } else {
+        this.emit("reconnected");
       }
+      console.log("connected");
     };
-    ws.onclose = () => {
-      info3 == null ? void 0 : info3(\`\u26A1 connection close\`);
-      callback({
-        type: "connection-status",
-        status: "disconnected",
-        reason: "close"
-      });
-      if (this.connectionMetricsInterval) {
-        clearInterval(this.connectionMetricsInterval);
-        this.connectionMetricsInterval = null;
-      }
-      if (this.status !== "closed") {
-        reconnect(this);
-        this.send = queue;
-      }
+    ws2.onerror = () => {
+      clearTimeout(timer);
     };
-    const send = (msg) => {
-      if (true) {
-        if (debugEnabled4 && msg.body.type !== "HB_RESP") {
-          debug4 == null ? void 0 : debug4(\`>>> \${msg.body.type}\`);
+    ws2.onclose = () => {
+      if (!this.isClosed) {
+        this.confirmedOpen = false;
+        this.status = "disconnected";
+        if (this.hasConnectionAttemptsRemaining) {
+          this.reconnect();
+        } else {
+          this.close("failure");
         }
       }
-      ws.send(JSON.stringify(msg));
     };
-    const queue = (msg) => {
-      info3 == null ? void 0 : info3(\`TODO queue message until websocket reconnected \${msg.body.type}\`);
-    };
-    this.send = send;
-    this.close = () => {
-      this.status = "closed";
-      ws.close();
-      this.close = closeWarn;
-      this.send = sendWarn;
-      info3 == null ? void 0 : info3("close websocket");
+    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", 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 server;
-var { info: info4, infoEnabled: infoEnabled4 } = logger("worker");
-async function connectToServer(url, protocol, token, username, onConnectionStatusChange, retryLimitDisconnect, retryLimitStartup) {
-  const connection = await connect(
-    url,
-    protocol,
-    // if this was called during connect, we would get a ReferenceError, but it will
-    // never be called until subscriptions have been made, so this is safe.
-    //TODO do we need to listen in to the connection messages here so we can lock back in, in the event of a reconnenct ?
-    (msg) => {
+var { info: info3, 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, username, retryLimitDisconnect, retryLimitStartup) {
+  const websocketConnection = ws = new WebSocketConnection({
+    callback: (msg) => {
       if (isConnectionQualityMetrics(msg)) {
         postMessage({ type: "connection-metrics", messages: msg });
-      } else if (isConnectionStatusMessage(msg)) {
-        onConnectionStatusChange(msg);
-        if (msg.status === "reconnected") {
-          server.reconnect();
-        }
+      } else if (isWebSocketConnectionMessage(msg)) {
+        postMessage(msg);
       } else {
         server.handleMessageFromServer(msg);
       }
     },
-    retryLimitDisconnect,
-    retryLimitStartup
-  );
-  server = new ServerProxy(connection, (msg) => sendMessageToClient(msg));
-  if (connection.requiresLogin) {
+    protocols,
+    retryLimits: getRetryLimits(retryLimitStartup, retryLimitDisconnect),
+    url
+  });
+  websocketConnection.on("connection-status", postMessage);
+  await websocketConnection.connect();
+  server = new ServerProxy(websocketConnection, sendMessageToClient);
+  if (websocketConnection.requiresLogin) {
     await server.login(token, username);
   }
 }
-function sendMessageToClient(message) {
-  postMessage(message);
-}
 var handleMessageFromClient = async ({
   data: message
 }) => {
@@ -2436,7 +2713,6 @@ var handleMessageFromClient = async ({
           message.protocol,
           message.token,
           message.username,
-          postMessage,
           message.retryLimitDisconnect,
           message.retryLimitStartup
         );
@@ -2445,16 +2721,20 @@ var handleMessageFromClient = async ({
         postMessage({ type: "connection-failed", reason: String(err) });
       }
       break;
+    case "disconnect":
+      server.disconnect();
+      ws == null ? void 0 : ws.close();
+      break;
     case "subscribe":
-      infoEnabled4 && info4(\`client subscribe: \${JSON.stringify(message)}\`);
+      infoEnabled3 && info3(\`client subscribe: \${JSON.stringify(message)}\`);
       server.subscribe(message);
       break;
     case "unsubscribe":
-      infoEnabled4 && info4(\`client unsubscribe: \${JSON.stringify(message)}\`);
+      infoEnabled3 && info3(\`client unsubscribe: \${JSON.stringify(message)}\`);
       server.unsubscribe(message.viewport);
       break;
     default:
-      infoEnabled4 && info4(\`client message: \${JSON.stringify(message)}\`);
+      infoEnabled3 && info3(\`client message: \${JSON.stringify(message)}\`);
       server.handleMessageFromClient(message);
   }
 };