@vuu-ui/vuu-data-remote 0.13.9 → 0.13.10

package/cjs/inlined-worker.js

@@ -0,0 +1,2828 @@
+'use strict';
+
+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);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// ../vuu-utils/src/array-utils.ts
+function partition(array, test, pass = [], fail = []) {
+  for (let i = 0, len = array.length; i < len; i++) {
+    (test(array[i], i) ? pass : fail).push(array[i]);
+  }
+  return [pass, fail];
+}
+
+// ../vuu-utils/src/column-utils.ts
+var KEY = 6;
+var metadataKeys = {
+  IDX: 0,
+  RENDER_IDX: 1,
+  IS_LEAF: 2,
+  IS_EXPANDED: 3,
+  DEPTH: 4,
+  COUNT: 5,
+  KEY,
+  SELECTED: 7,
+  count: 8,
+  // TODO following only used in datamodel
+  PARENT_IDX: "parent_idx",
+  IDX_POINTER: "idx_pointer",
+  FILTER_COUNT: "filter_count",
+  NEXT_FILTER_IDX: "next_filter_idx"
+};
+var { DEPTH, IS_LEAF } = metadataKeys;
+
+// ../vuu-utils/src/cookie-utils.ts
+var getCookieValue = (name) => {
+  var _a, _b;
+  if (((_a = globalThis.document) == null ? void 0 : _a.cookie) !== void 0) {
+    return (_b = globalThis.document.cookie.split("; ").find((row) => row.startsWith(\`\${name}=\`))) == null ? void 0 : _b.split("=")[1];
+  }
+};
+
+// ../vuu-utils/src/range-utils.ts
+var defaultRangeOptions = {
+  renderBufferSize: 0,
+  rowCount: -1
+};
+var _baseFrom, _renderBufferSize, _rowCount, _baseTo;
+var _RangeImpl = class _RangeImpl {
+  constructor(from, to, rangeOptions = defaultRangeOptions) {
+    __privateAdd(this, _baseFrom);
+    __privateAdd(this, _renderBufferSize, 0);
+    __privateAdd(this, _rowCount, -1);
+    __privateAdd(this, _baseTo);
+    // We have to keep these as simple public properties (not getters) so they survive structuredClone
+    __publicField(this, "from", 0);
+    __publicField(this, "to", 0);
+    var _a, _b;
+    __privateSet(this, _baseFrom, from);
+    __privateSet(this, _baseTo, to);
+    this.renderBufferSize = (_a = rangeOptions.renderBufferSize) != null ? _a : defaultRangeOptions.renderBufferSize;
+    this.rowCount = (_b = rangeOptions.rowCount) != null ? _b : defaultRangeOptions.rowCount;
+  }
+  get firstRowInViewport() {
+    return __privateGet(this, _baseFrom) + 1;
+  }
+  get lastRowInViewport() {
+    if (__privateGet(this, _rowCount) > 0) {
+      return Math.min(__privateGet(this, _baseTo), __privateGet(this, _rowCount));
+    } else {
+      return __privateGet(this, _baseTo);
+    }
+  }
+  get renderBufferSize() {
+    return __privateGet(this, _renderBufferSize);
+  }
+  set renderBufferSize(value) {
+    __privateSet(this, _renderBufferSize, value);
+    this.from = Math.max(0, __privateGet(this, _baseFrom) - value);
+    if (__privateGet(this, _rowCount) > 0) {
+      this.to = Math.max(__privateGet(this, _baseTo) + __privateGet(this, _renderBufferSize), __privateGet(this, _rowCount));
+    } else {
+      this.to = __privateGet(this, _baseTo) + __privateGet(this, _renderBufferSize);
+    }
+  }
+  get rowCount() {
+    return __privateGet(this, _rowCount);
+  }
+  set rowCount(value) {
+    __privateSet(this, _rowCount, value);
+    if (value > 0) {
+      this.to = Math.min(__privateGet(this, _baseTo) + __privateGet(this, _renderBufferSize), value);
+    } else {
+      this.to = __privateGet(this, _baseTo) + __privateGet(this, _renderBufferSize);
+    }
+  }
+  get reset() {
+    return new _RangeImpl(0, __privateGet(this, _baseTo) - __privateGet(this, _baseFrom), {
+      rowCount: __privateGet(this, _rowCount),
+      renderBufferSize: __privateGet(this, _renderBufferSize)
+    });
+  }
+  equals(range) {
+    return range.from === __privateGet(this, _baseFrom) && range.to === __privateGet(this, _baseTo);
+  }
+  toJson() {
+    return {
+      from: this.from,
+      to: this.to,
+      baseFrom: __privateGet(this, _baseFrom),
+      baseTo: __privateGet(this, _baseTo),
+      renderBufferSize: __privateGet(this, _renderBufferSize),
+      rowCount: __privateGet(this, _rowCount)
+    };
+  }
+};
+_baseFrom = new WeakMap();
+_renderBufferSize = new WeakMap();
+_rowCount = new WeakMap();
+_baseTo = new WeakMap();
+var RangeImpl = _RangeImpl;
+var Range = (from, to, rangeOptions) => new RangeImpl(from, to, rangeOptions);
+var NULL_RANGE = Range(0, 0);
+function getFullRange({ from, to }, bufferSize = 0, totalRowCount = Number.MAX_SAFE_INTEGER) {
+  if (from === 0 && to === 0) {
+    return { from, to };
+  } else if (bufferSize === 0) {
+    if (totalRowCount < from) {
+      return { from: 0, to: 0 };
+    } else {
+      return { from, to: Math.min(to, totalRowCount) };
+    }
+  } else if (from === 0) {
+    return { from, to: Math.min(to + bufferSize, totalRowCount) };
+  } else {
+    const shortfallBefore = from - bufferSize < 0;
+    const shortfallAfter = totalRowCount - (to + bufferSize) < 0;
+    if (shortfallBefore && shortfallAfter) {
+      return { from: 0, to: totalRowCount };
+    } else if (shortfallBefore) {
+      return { from: 0, to: to + bufferSize };
+    } else if (shortfallAfter) {
+      return {
+        from: Math.max(0, from - bufferSize),
+        to: totalRowCount
+      };
+    } else {
+      return { from: from - bufferSize, to: to + bufferSize };
+    }
+  }
+}
+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;
+  }
+  isWithin(index) {
+    return withinRange(index, this);
+  }
+  //find the overlap of this range and a new one
+  overlap(from, to) {
+    return from >= this.to || to < this.from ? [0, 0] : [Math.max(from, this.from), Math.min(to, this.to)];
+  }
+  copy() {
+    return new _WindowRange(this.from, this.to);
+  }
+};
+
+// ../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;
+        // slower
+        default:
+          handler.call(null, ...args);
+      }
+    }
+  }
+};
+_events = new WeakMap();
+
+// ../vuu-utils/src/datasource/datasource-utils.ts
+var isConnectionQualityMetrics = (msg) => msg.type === "connection-metrics";
+var isVisualLinkMessage = (msg) => msg.type.endsWith("_VISUAL_LINK");
+var isViewportMessage = (msg) => "viewport" in msg;
+
+// ../vuu-utils/src/logging-utils.ts
+var logLevels = ["error", "warn", "info", "debug"];
+var isValidLogLevel = (value) => typeof value === "string" && logLevels.includes(value);
+var DEFAULT_LOG_LEVEL = "error";
+var NO_OP = () => void 0;
+var DEFAULT_DEBUG_LEVEL = false ? "error" : "info";
+var { loggingLevel = DEFAULT_DEBUG_LEVEL } = getLoggingSettings();
+var logger = (category) => {
+  const debugEnabled4 = loggingLevel === "debug";
+  const infoEnabled4 = debugEnabled4 || loggingLevel === "info";
+  const warnEnabled = infoEnabled4 || loggingLevel === "warn";
+  const errorEnabled = warnEnabled || loggingLevel === "error";
+  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: error3
+    };
+  } else {
+    return {
+      debugEnabled: debugEnabled4,
+      infoEnabled: infoEnabled4,
+      warnEnabled,
+      errorEnabled,
+      info: info4,
+      warn: warn3,
+      debug: debug4,
+      error: error3
+    };
+  }
+};
+function getLoggingSettings() {
+  if (typeof loggingSettings !== "undefined") {
+    return loggingSettings;
+  } else {
+    return {
+      loggingLevel: getLoggingLevelFromCookie()
+    };
+  }
+}
+function getLoggingLevelFromCookie() {
+  const value = getCookieValue("vuu-logging-level");
+  if (isValidLogLevel(value)) {
+    return value;
+  } else {
+    return DEFAULT_LOG_LEVEL;
+  }
+}
+
+// ../vuu-utils/src/debug-utils.ts
+var { debug, debugEnabled } = logger("range-monitor");
+var RangeMonitor = class {
+  constructor(source) {
+    this.source = source;
+    __publicField(this, "range", { from: 0, to: 0 });
+    __publicField(this, "timestamp", 0);
+  }
+  isSet() {
+    return this.timestamp !== 0;
+  }
+  set({ from, to }) {
+    const { timestamp } = this;
+    this.range.from = from;
+    this.range.to = to;
+    this.timestamp = performance.now();
+    if (timestamp) {
+      debugEnabled && debug(
+        \`<\${this.source}> [\${from}-\${to}], \${(this.timestamp - timestamp).toFixed(0)} ms elapsed\`
+      );
+    } else {
+      return 0;
+    }
+  }
+};
+
+// ../vuu-utils/src/keyset.ts
+var EMPTY = [];
+var KeySet = class {
+  constructor(range) {
+    __publicField(this, "keys", /* @__PURE__ */ new Map());
+    __publicField(this, "nextKeyValue", 0);
+    __publicField(this, "range");
+    this.range = range;
+    this.init(range);
+  }
+  next(free = EMPTY) {
+    if (free.length > 0) {
+      return free.shift();
+    } else {
+      return this.nextKeyValue++;
+    }
+  }
+  init({ from, to }) {
+    this.keys.clear();
+    this.nextKeyValue = 0;
+    for (let rowIndex = from; rowIndex < to; rowIndex++) {
+      const nextKeyValue = this.next();
+      this.keys.set(rowIndex, nextKeyValue);
+    }
+    return true;
+  }
+  reset(range) {
+    const { from, to } = range;
+    const newSize = to - from;
+    const currentSize = this.range.to - this.range.from;
+    this.range = range;
+    if (currentSize > newSize) {
+      return this.init(range);
+    }
+    const freeKeys = [];
+    this.keys.forEach((keyValue, rowIndex) => {
+      if (rowIndex < from || rowIndex >= to) {
+        freeKeys.push(keyValue);
+        this.keys.delete(rowIndex);
+      }
+    });
+    for (let rowIndex = from; rowIndex < to; rowIndex++) {
+      if (!this.keys.has(rowIndex)) {
+        const nextKeyValue = this.next(freeKeys);
+        this.keys.set(rowIndex, nextKeyValue);
+      }
+    }
+    return false;
+  }
+  keyFor(rowIndex) {
+    const key = this.keys.get(rowIndex);
+    if (key === void 0) {
+      console.log(\`key not found
+        keys: \${this.toDebugString()}
+      \`);
+      throw Error(\`KeySet, no key found for rowIndex \${rowIndex}\`);
+    }
+    return key;
+  }
+  toDebugString() {
+    return \`\${this.keys.size} keys
+\${Array.from(this.keys.entries()).sort(([key1], [key2]) => key1 - key2).map(([k, v]) => \`\${k}=>\${v}\`).join(",")}]
+\`;
+  }
+};
+
+// ../vuu-utils/src/selection-utils.ts
+var { SELECTED } = metadataKeys;
+var RowSelected = {
+  False: 0,
+  True: 1,
+  First: 2,
+  Last: 4
+};
+var rangeIncludes = (range, index) => index >= range[0] && index <= range[1];
+var SINGLE_SELECTED_ROW = RowSelected.True + RowSelected.First + RowSelected.Last;
+var FIRST_SELECTED_ROW_OF_BLOCK = RowSelected.True + RowSelected.First;
+var LAST_SELECTED_ROW_OF_BLOCK = RowSelected.True + RowSelected.Last;
+var getSelectionStatus = (selected, itemIndex) => {
+  for (const item of selected) {
+    if (typeof item === "number") {
+      if (item === itemIndex) {
+        return SINGLE_SELECTED_ROW;
+      }
+    } else if (rangeIncludes(item, itemIndex)) {
+      if (itemIndex === item[0]) {
+        return FIRST_SELECTED_ROW_OF_BLOCK;
+      } else if (itemIndex === item[1]) {
+        return LAST_SELECTED_ROW_OF_BLOCK;
+      } else {
+        return RowSelected.True;
+      }
+    }
+  }
+  return RowSelected.False;
+};
+var expandSelection = (selected) => {
+  if (selected.every((selectedItem) => typeof selectedItem === "number")) {
+    return selected;
+  }
+  const expandedSelected = [];
+  for (const selectedItem of selected) {
+    if (typeof selectedItem === "number") {
+      expandedSelected.push(selectedItem);
+    } else {
+      for (let i = selectedItem[0]; i <= selectedItem[1]; i++) {
+        expandedSelected.push(i);
+      }
+    }
+  }
+  return expandedSelected;
+};
+
+// ../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",
+  "VIEW_PORT_MENU_TABLE_RPC",
+  "VIEW_PORT_MENU_ROW_RPC",
+  "VIEW_PORT_MENU_CELL_RPC",
+  "VP_EDIT_CELL_RPC",
+  "VP_EDIT_ROW_RPC",
+  "VP_EDIT_ADD_ROW_RPC",
+  "VP_EDIT_DELETE_CELL_RPC",
+  "VP_EDIT_DELETE_ROW_RPC",
+  "VP_EDIT_SUBMIT_FORM_RPC"
+];
+var isVuuMenuRpcRequest = (message) => MENU_RPC_TYPES.includes(message["type"]);
+var isOpenDialogAction = (action) => action !== void 0 && action.type === "OPEN_DIALOG_ACTION";
+var isSessionTable = (table) => {
+  if (table !== null && typeof table === "object" && "table" in table && "module" in table) {
+    return table.table.startsWith("session");
+  }
+  return false;
+};
+function isActionMessage(rpcResponse) {
+  return rpcResponse.type === "VIEW_PORT_MENU_RESP" || rpcResponse.type === "VIEW_PORT_RPC_REPONSE";
+}
+function isSessionTableActionMessage(rpcResponse) {
+  var _a;
+  return isActionMessage(rpcResponse) && isOpenDialogAction(rpcResponse.action) && isSessionTable(rpcResponse.action.table) && ((_a = rpcResponse.action) == null ? void 0 : _a.renderComponent) === "inline-form";
+}
+
+// src/message-utils.ts
+var isVuuRpcRequest = (message) => message["type"] === "VIEW_PORT_RPC_CALL";
+var stripRequestId = ({
+  requestId,
+  ...rest
+}) => [requestId, rest];
+var getFirstAndLastRows = (rows) => {
+  let firstRow = rows.at(0);
+  if (firstRow.updateType === "SIZE") {
+    if (rows.length === 1) {
+      return rows;
+    } else {
+      firstRow = rows.at(1);
+    }
+  }
+  const lastRow = rows.at(-1);
+  return [firstRow, lastRow];
+};
+var insertRow = (rows, row) => {
+  const lastRow = rows.at(-1);
+  if (lastRow === void 0 || row.rowIndex > lastRow.rowIndex) {
+    rows.push(row);
+  } else {
+    for (let i = 0; i < rows.length; i++) {
+      if (row.rowIndex < rows[i].rowIndex) {
+        rows.splice(i, 0, row);
+        return;
+      } else if (row.rowIndex === rows[i].rowIndex) {
+        if (row.ts < rows[i].ts) {
+        } else {
+          rows[i] = row;
+        }
+        return;
+      }
+    }
+    throw Error("don't expect to get this far");
+  }
+};
+var groupRowsByViewport = (rows) => {
+  const result = {};
+  for (const row of rows) {
+    const rowsForViewport = result[row.viewPortId] || (result[row.viewPortId] = []);
+    insertRow(rowsForViewport, row);
+  }
+  return result;
+};
+var createSchemaFromTableMetadata = ({
+  columns,
+  dataTypes,
+  key,
+  table
+}) => {
+  return {
+    table,
+    columns: columns.map((col, idx) => ({
+      name: col,
+      serverDataType: dataTypes[idx]
+    })),
+    key
+  };
+};
+var gapBetweenLastRowSentToClient = (lastRowsReturnedToClient, pendingUpdates, clientRange) => {
+  const firstPendingUpdate = pendingUpdates.at(0);
+  const lastPendingUpdate = pendingUpdates.at(-1);
+  if (firstPendingUpdate && lastPendingUpdate) {
+    const [firstRowIndex, lastRowIndex] = lastRowsReturnedToClient;
+    if (lastRowIndex < firstPendingUpdate.rowIndex - 1 && clientRange.from < firstPendingUpdate.rowIndex) {
+      return {
+        from: Math.max(lastRowIndex + 1, clientRange.from),
+        to: firstPendingUpdate.rowIndex
+      };
+    } else if (firstRowIndex > lastPendingUpdate.rowIndex + 1 && clientRange.to > lastPendingUpdate.rowIndex) {
+      return {
+        from: lastPendingUpdate.rowIndex + 1,
+        to: Math.min(clientRange.to, firstRowIndex)
+      };
+    }
+  }
+};
+
+// src/server-proxy/messages.ts
+var CHANGE_VP_SUCCESS = "CHANGE_VP_SUCCESS";
+var CLOSE_TREE_NODE = "CLOSE_TREE_NODE";
+var CLOSE_TREE_SUCCESS = "CLOSE_TREE_SUCCESS";
+var CREATE_VP = "CREATE_VP";
+var DISABLE_VP = "DISABLE_VP";
+var DISABLE_VP_SUCCESS = "DISABLE_VP_SUCCESS";
+var ENABLE_VP = "ENABLE_VP";
+var ENABLE_VP_SUCCESS = "ENABLE_VP_SUCCESS";
+var GET_VP_VISUAL_LINKS = "GET_VP_VISUAL_LINKS";
+var GET_VIEW_PORT_MENUS = "GET_VIEW_PORT_MENUS";
+var HB = "HB";
+var HB_RESP = "HB_RESP";
+var LOGIN = "LOGIN";
+var OPEN_TREE_NODE = "OPEN_TREE_NODE";
+var OPEN_TREE_SUCCESS = "OPEN_TREE_SUCCESS";
+var REMOVE_VP = "REMOVE_VP";
+var SET_SELECTION_SUCCESS = "SET_SELECTION_SUCCESS";
+
+// src/server-proxy/rpc-services.ts
+var getRpcServiceModule = (service) => {
+  switch (service) {
+    case "TypeAheadRpcHandler":
+      return "TYPEAHEAD";
+    default:
+      return "SIMUL";
+  }
+};
+
+// src/server-proxy/array-backed-moving-window.ts
+var EMPTY_ARRAY = [];
+var log = logger("array-backed-moving-window");
+function dataIsUnchanged(newRow, existingRow) {
+  if (!existingRow) {
+    return false;
+  }
+  if (existingRow.data.length !== newRow.data.length) {
+    return false;
+  }
+  if (existingRow.sel !== newRow.sel) {
+    return false;
+  }
+  for (let i = 0; i < existingRow.data.length; i++) {
+    if (existingRow.data[i] !== newRow.data[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+var _range;
+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);
+    __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) {
+        this.internalData.length = rowCount;
+      }
+      if (rowCount < this.rowCount) {
+        this.rowsWithinRange = 0;
+        const end = Math.min(rowCount, this.clientRange.to);
+        for (let i = this.clientRange.from; i < end; i++) {
+          const rowIndex = i - __privateGet(this, _range).from;
+          if (this.internalData[rowIndex] !== void 0) {
+            this.rowsWithinRange += 1;
+          }
+        }
+      }
+      this.rowCount = rowCount;
+    });
+    __publicField(this, "bufferBreakout", (from, to) => {
+      const bufferPerimeter = this.bufferSize * 0.25;
+      if (__privateGet(this, _range).to - to < bufferPerimeter) {
+        return true;
+      } else if (__privateGet(this, _range).from > 0 && from - __privateGet(this, _range).from < bufferPerimeter) {
+        return true;
+      } else {
+        return false;
+      }
+    });
+    this.bufferSize = bufferSize;
+    this.clientRange = new WindowRange(clientFrom, clientTo);
+    __privateSet(this, _range, new WindowRange(from, to));
+    this.internalData = new Array(bufferSize);
+    this.rowsWithinRange = 0;
+    this.rowCount = 0;
+  }
+  get range() {
+    return __privateGet(this, _range);
+  }
+  // TODO we should probably have a hasAllClientRowsWithinRange
+  get hasAllRowsWithinRange() {
+    return this.rowsWithinRange === this.clientRange.to - this.clientRange.from || // this.rowsWithinRange === this.range.to - this.range.from ||
+    this.rowCount > 0 && this.clientRange.from + this.rowsWithinRange === this.rowCount;
+  }
+  // Check to see if set of rows is outside the current viewport range, indicating
+  // that veiwport is being scrolled quickly and server is not able to keep up.
+  outOfRange(firstIndex, lastIndex) {
+    const { from, to } = this.range;
+    if (lastIndex < from) {
+      return true;
+    }
+    if (firstIndex >= to) {
+      return true;
+    }
+  }
+  setAtIndex(row) {
+    const { rowIndex: index } = row;
+    const internalIndex = index - __privateGet(this, _range).from;
+    if (dataIsUnchanged(row, this.internalData[internalIndex])) {
+      return false;
+    }
+    const isWithinClientRange = this.isWithinClientRange(index);
+    if (isWithinClientRange || this.isWithinRange(index)) {
+      if (!this.internalData[internalIndex] && isWithinClientRange) {
+        this.rowsWithinRange += 1;
+      }
+      this.internalData[internalIndex] = row;
+    }
+    return isWithinClientRange;
+  }
+  getAtIndex(index) {
+    return __privateGet(this, _range).isWithin(index) && this.internalData[index - __privateGet(this, _range).from] != null ? this.internalData[index - __privateGet(this, _range).from] : void 0;
+  }
+  isWithinRange(index) {
+    return __privateGet(this, _range).isWithin(index);
+  }
+  isWithinClientRange(index) {
+    return this.clientRange.isWithin(index);
+  }
+  // Returns [false] or [serverDataRequired, clientRows, holdingRows]
+  setClientRange(from, to) {
+    var _a;
+    (_a = log.debug) == null ? void 0 : _a.call(log, \`setClientRange \${from} - \${to}\`);
+    const currentFrom = this.clientRange.from;
+    const currentTo = Math.min(this.clientRange.to, this.rowCount);
+    if (from === currentFrom && to === currentTo) {
+      return [
+        false,
+        EMPTY_ARRAY
+        /*, EMPTY_ARRAY*/
+      ];
+    }
+    const originalRange = this.clientRange.copy();
+    this.clientRange.from = from;
+    this.clientRange.to = to;
+    this.rowsWithinRange = 0;
+    for (let i = from; i < to; i++) {
+      const internalIndex = i - __privateGet(this, _range).from;
+      if (this.internalData[internalIndex]) {
+        this.rowsWithinRange += 1;
+      }
+    }
+    let clientRows = EMPTY_ARRAY;
+    const offset = __privateGet(this, _range).from;
+    if (this.hasAllRowsWithinRange) {
+      if (to > originalRange.to) {
+        const start = Math.max(from, originalRange.to);
+        clientRows = this.internalData.slice(start - offset, to - offset);
+      } else {
+        const end = Math.min(originalRange.from, to);
+        clientRows = this.internalData.slice(from - offset, end - offset);
+      }
+    }
+    const serverDataRequired = this.bufferBreakout(from, to);
+    return [serverDataRequired, clientRows];
+  }
+  setRange(from, to) {
+    var _a, _b;
+    if (from !== __privateGet(this, _range).from || to !== __privateGet(this, _range).to) {
+      (_a = log.debug) == null ? void 0 : _a.call(log, \`setRange \${from} - \${to}\`);
+      const [overlapFrom, overlapTo] = __privateGet(this, _range).overlap(from, to);
+      const newData = new Array(to - from);
+      this.rowsWithinRange = 0;
+      for (let i = overlapFrom; i < overlapTo; i++) {
+        const row = this.getAtIndex(i);
+        if (row) {
+          const index = i - from;
+          newData[index] = row;
+          if (this.isWithinClientRange(i)) {
+            this.rowsWithinRange += 1;
+          }
+        }
+      }
+      this.internalData = newData;
+      __privateGet(this, _range).from = from;
+      __privateGet(this, _range).to = to;
+    } else {
+      (_b = log.debug) == null ? void 0 : _b.call(log, \`setRange \${from} - \${to} IGNORED because not changed\`);
+    }
+  }
+  //TODO temp
+  get data() {
+    return this.internalData;
+  }
+  getData() {
+    var _a;
+    const { from, to } = __privateGet(this, _range);
+    const { from: clientFrom, to: clientTo } = this.clientRange;
+    const startOffset = Math.max(0, clientFrom - from);
+    const endOffset = Math.min(
+      to - from,
+      to,
+      clientTo - from,
+      (_a = this.rowCount) != null ? _a : to
+    );
+    return this.internalData.slice(startOffset, endOffset);
+  }
+  clear() {
+    var _a;
+    (_a = log.debug) == null ? void 0 : _a.call(log, "clear");
+    this.internalData.length = 0;
+    this.rowsWithinRange = 0;
+    this.setRowCount(0);
+  }
+  // used only for debugging
+  getCurrentDataRange() {
+    const rows = this.internalData;
+    const len = rows.length;
+    let [firstRow] = this.internalData;
+    let lastRow = this.internalData[len - 1];
+    if (firstRow && lastRow) {
+      return [firstRow.rowIndex, lastRow.rowIndex];
+    } else {
+      for (let i = 0; i < len; i++) {
+        if (rows[i] !== void 0) {
+          firstRow = rows[i];
+          break;
+        }
+      }
+      for (let i = len - 1; i >= 0; i--) {
+        if (rows[i] !== void 0) {
+          lastRow = rows[i];
+          break;
+        }
+      }
+      if (firstRow && lastRow) {
+        return [firstRow.rowIndex, lastRow.rowIndex];
+      } else {
+        return [-1, -1];
+      }
+    }
+  }
+};
+_range = new WeakMap();
+
+// src/server-proxy/viewport.ts
+var { debug: debug2, debugEnabled: debugEnabled2, error, info, infoEnabled, warn } = logger("Viewport");
+var isLeafUpdate = ({ rowKey, updateType }) => updateType === "U" && !rowKey.startsWith("$root");
+var NO_DATA_UPDATE = [
+  void 0,
+  void 0
+];
+var NO_UPDATE_STATUS = {
+  count: 0,
+  mode: void 0,
+  size: 0,
+  ts: 0
+};
+var _status, _clientRange;
+var Viewport = class {
+  constructor({
+    aggregations,
+    bufferSize = 50,
+    columns,
+    filterSpec: filter,
+    groupBy = [],
+    table,
+    range,
+    sort,
+    title,
+    viewport,
+    visualLink
+  }, postMessageToClient) {
+    __privateAdd(this, _status, "");
+    __publicField(this, "aggregations");
+    __publicField(this, "batchMode", false);
+    __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, "lastUpdateStatus", NO_UPDATE_STATUS);
+    __publicField(this, "updateThrottleTimer");
+    __publicField(this, "lastRowsReturnedToClient", [-1, -1]);
+    __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
+    __publicField(this, "suspended", false);
+    __publicField(this, "suspendTimer", null);
+    __publicField(this, "table");
+    __publicField(this, "title");
+    // Records SIZE only updates
+    __publicField(this, "setLastSizeOnlyUpdateSize", (size) => {
+      this.lastUpdateStatus.size = size;
+    });
+    __publicField(this, "setLastUpdate", (mode) => {
+      const { ts: lastTS, mode: lastMode } = this.lastUpdateStatus;
+      let elapsedTime = 0;
+      if (lastMode === mode) {
+        const ts = Date.now();
+        this.lastUpdateStatus.count += 1;
+        this.lastUpdateStatus.ts = ts;
+        elapsedTime = lastTS === 0 ? 0 : ts - lastTS;
+      } else {
+        this.lastUpdateStatus.count = 1;
+        this.lastUpdateStatus.ts = 0;
+        elapsedTime = 0;
+      }
+      this.lastUpdateStatus.mode = mode;
+      return elapsedTime;
+    });
+    __publicField(this, "rangeRequestAlreadyPending", (range) => {
+      const { bufferSize } = this;
+      const bufferThreshold = bufferSize * 0.25;
+      let { from: stillPendingFrom } = range;
+      for (const { from, to } of this.pendingRangeRequests) {
+        if (stillPendingFrom >= from && stillPendingFrom < to) {
+          if (range.to + bufferThreshold <= to) {
+            return true;
+          } else {
+            stillPendingFrom = to;
+          }
+        }
+      }
+      return false;
+    });
+    __publicField(this, "sendThrottledSizeMessage", () => {
+      this.updateThrottleTimer = void 0;
+      this.lastUpdateStatus.count = 3;
+      this.postMessageToClient({
+        clientViewportId: this.clientViewportId,
+        mode: "size-only",
+        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.
+    __publicField(this, "shouldThrottleMessage", (mode) => {
+      const elapsedTime = this.setLastUpdate(mode);
+      return mode === "size-only" && elapsedTime > 0 && elapsedTime < 500 && this.lastUpdateStatus.count > 3;
+    });
+    __publicField(this, "throttleMessage", (mode) => {
+      if (this.shouldThrottleMessage(mode)) {
+        info == null ? void 0 : info("throttling updates setTimeout to 2000");
+        if (this.updateThrottleTimer === void 0) {
+          this.updateThrottleTimer = setTimeout(
+            this.sendThrottledSizeMessage,
+            2e3
+          );
+        }
+        return true;
+      } else if (this.updateThrottleTimer !== void 0) {
+        clearTimeout(this.updateThrottleTimer);
+        this.updateThrottleTimer = void 0;
+      }
+      return false;
+    });
+    __publicField(this, "getNewRowCount", () => {
+      if (this.rowCountChanged && this.dataWindow) {
+        this.rowCountChanged = false;
+        return this.dataWindow.rowCount;
+      }
+    });
+    this.aggregations = aggregations;
+    this.bufferSize = bufferSize;
+    __privateSet(this, _clientRange, range);
+    this.clientViewportId = viewport;
+    this.columns = columns;
+    this.filter = filter;
+    this.groupBy = groupBy;
+    this.keys = new KeySet(range);
+    this.pendingLinkedParent = visualLink;
+    this.table = table;
+    this.sort = sort;
+    this.title = title;
+    infoEnabled && (info == null ? void 0 : info(
+      \`constructor #\${viewport} \${table.table} bufferSize=\${bufferSize}\`
+    ));
+    this.dataWindow = new ArrayBackedMovingWindow(
+      __privateGet(this, _clientRange),
+      range,
+      this.bufferSize
+    );
+    this.postMessageToClient = postMessageToClient;
+  }
+  get hasUpdatesToProcess() {
+    if (this.suspended) {
+      return false;
+    }
+    return this.rowCountChanged || this.hasUpdates;
+  }
+  get size() {
+    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 = __privateGet(this, _status) === "subscribed" ? "resubscribing" : "subscribing";
+    return {
+      type: CREATE_VP,
+      table: this.table,
+      range: getFullRange(__privateGet(this, _clientRange), this.bufferSize),
+      aggregations: this.aggregations,
+      columns: this.columns,
+      sort: this.sort,
+      groupBy: this.groupBy,
+      filterSpec: { filter }
+    };
+  }
+  handleSubscribed({
+    viewPortId,
+    aggregations,
+    columns,
+    filterSpec: filter,
+    range,
+    sort,
+    groupBy,
+    table
+  }, baseTableSchema) {
+    this.serverViewportId = viewPortId;
+    this.status = "subscribed";
+    this.aggregations = aggregations;
+    this.columns = columns;
+    this.groupBy = groupBy;
+    this.isTree = groupBy && groupBy.length > 0;
+    this.dataWindow.setRange(range.from, range.to);
+    const tableSchema = table === baseTableSchema.table.table ? baseTableSchema : {
+      ...baseTableSchema,
+      table: {
+        ...baseTableSchema.table,
+        session: table
+      }
+    };
+    return {
+      aggregations,
+      type: "subscribed",
+      clientViewportId: this.clientViewportId,
+      columns,
+      filterSpec: filter,
+      groupBy,
+      range,
+      sort,
+      tableSchema
+    };
+  }
+  awaitOperation(requestId, msg) {
+    this.pendingOperations.set(requestId, msg);
+  }
+  // Return a message if we need to communicate this to client UI
+  completeOperation(requestId, ...params) {
+    var _a;
+    const { clientViewportId, pendingOperations } = this;
+    const pendingOperation = pendingOperations.get(requestId);
+    if (!pendingOperation) {
+      error(
+        \`no matching operation found to complete for requestId \${requestId}\`
+      );
+      return;
+    }
+    const { type } = pendingOperation;
+    info == null ? void 0 : info(\`completeOperation \${type}\`);
+    pendingOperations.delete(requestId);
+    if (type === "CHANGE_VP_RANGE") {
+      const [from, to] = params;
+      infoEnabled && info(
+        \`completeOperation CHANGE_VP_RANGE
+        window setRange (\${from}:\${to}) \${this.pendingRangeRequests.length} range requests pending\`
+      );
+      (_a = this.dataWindow) == null ? void 0 : _a.setRange(from, to);
+      for (let i = this.pendingRangeRequests.length - 1; i >= 0; i--) {
+        const pendingRangeRequest = this.pendingRangeRequests[i];
+        if (pendingRangeRequest.requestId === requestId) {
+          pendingRangeRequest.acked = true;
+          break;
+        } else {
+          warn == null ? void 0 : warn("range requests sent faster than they are being ACKed");
+        }
+      }
+    } else if (type === "config") {
+      const {
+        aggregations,
+        columns,
+        filterSpec: filter,
+        groupBy,
+        sort
+      } = pendingOperation.data;
+      this.aggregations = aggregations;
+      this.columns = columns;
+      this.filter = filter;
+      this.groupBy = groupBy;
+      this.sort = sort;
+      if (groupBy.length > 0) {
+        this.isTree = true;
+      } else if (this.isTree) {
+        this.isTree = false;
+      }
+      debug2 == null ? void 0 : debug2(\`config change confirmed, isTree : \${this.isTree}\`);
+      return {
+        clientViewportId,
+        type,
+        config: pendingOperation.data
+      };
+    } else if (type === "selection") {
+    } else if (type === "disable") {
+      this.disabled = true;
+      return {
+        type: "disabled",
+        clientViewportId
+      };
+    } else if (type === "enable") {
+      this.disabled = false;
+      return {
+        type: "enabled",
+        clientViewportId
+      };
+    } else if (type === "CREATE_VISUAL_LINK") {
+      const [colName, parentViewportId, parentColName] = params;
+      this.linkedParent = {
+        colName,
+        parentViewportId,
+        parentColName
+      };
+      this.pendingLinkedParent = void 0;
+      return {
+        requestId,
+        type: "vuu-link-created",
+        clientViewportId,
+        colName,
+        parentViewportId,
+        parentColName
+      };
+    } else if (type === "REMOVE_VISUAL_LINK") {
+      this.linkedParent = void 0;
+      return {
+        requestId,
+        type: "vuu-link-removed",
+        clientViewportId
+      };
+    }
+  }
+  // TODO when a range request arrives, consider the viewport to be scrolling
+  // until data arrives and we have the full range.
+  // When not scrolling, any server data is an update
+  // When scrolling, we are in batch mode
+  rangeRequest(requestId, range) {
+    var _a, _b;
+    if (debugEnabled2) {
+      this.rangeMonitor.set(range);
+    }
+    infoEnabled && info(
+      \`(bufferSize \${this.bufferSize}) rangeRequest (\${range.from}:\${range.to}) 
+            current: window client (\${this.dataWindow.clientRange.from}:\${this.dataWindow.clientRange.to}), full (\${this.dataWindow.range.from}:\${this.dataWindow.range.to}) \`
+    );
+    const type = "CHANGE_VP_RANGE";
+    if (this.dataWindow) {
+      const [serverDataRequired, clientRows] = this.dataWindow.setClientRange(
+        range.from,
+        range.to
+      );
+      infoEnabled && info(
+        \`updated: window client (\${this.dataWindow.clientRange.from}:\${this.dataWindow.clientRange.to}), full (\${this.dataWindow.range.from}:\${this.dataWindow.range.to})
+          serverDataRequired \${serverDataRequired ? "Y" : "N"}
+          \${clientRows.length} rows returned from local buffer\`
+      );
+      let debounceRequest;
+      const maxRange = this.dataWindow.rowCount || void 0;
+      const serverRequest = serverDataRequired && !this.rangeRequestAlreadyPending(range) ? {
+        type,
+        viewPortId: this.serverViewportId,
+        ...getFullRange(range, this.bufferSize, maxRange)
+      } : null;
+      if (serverRequest) {
+        infoEnabled && info(
+          \`create CHANGE_VP_RANGE: (\${serverRequest.from} - \${serverRequest.to})\`
+        );
+        debugEnabled2 && (debug2 == null ? void 0 : debug2(
+          \`create CHANGE_VP_RANGE: [\${serverRequest.from} - \${serverRequest.to}]\`
+        ));
+        this.awaitOperation(requestId, { type });
+        const pendingRequest = this.pendingRangeRequests.at(-1);
+        if (pendingRequest) {
+          if (pendingRequest.acked) {
+            console.warn("Range Request before previous request is filled");
+          } else {
+            const { from, to } = pendingRequest;
+            if (this.dataWindow.outOfRange(from, to)) {
+              debounceRequest = {
+                clientViewportId: this.clientViewportId,
+                type: "debounce-begin"
+              };
+            } else {
+              warn == null ? void 0 : warn("Range Request before previous request is acked");
+            }
+          }
+        }
+        this.pendingRangeRequests.push({ ...serverRequest, requestId });
+      } else if (clientRows.length > 0) {
+        this.batchMode = false;
+      }
+      this.keys.reset(this.dataWindow.clientRange);
+      const toClient = this.isTree ? toClientRowTree : toClientRow;
+      if (clientRows.length) {
+        this.lastRowsReturnedToClient[0] = clientRows[0].rowIndex;
+        this.lastRowsReturnedToClient[1] = (_b = (_a = clientRows.at(-1)) == null ? void 0 : _a.rowIndex) != null ? _b : -1;
+        return [
+          serverRequest,
+          clientRows.map((row) => {
+            return toClient(row, this.keys, this.selectedRows);
+          })
+        ];
+      } else if (debounceRequest) {
+        return [serverRequest, void 0, debounceRequest];
+      } else {
+        return [serverRequest];
+      }
+    } else {
+      return [null];
+    }
+  }
+  setLinks(links) {
+    this.links = links.filter(
+      (link) => link.parentVpId !== this.serverViewportId
+    );
+    return [
+      {
+        type: "vuu-links",
+        links: this.links,
+        clientViewportId: this.clientViewportId
+      },
+      this.pendingLinkedParent
+    ];
+  }
+  setMenu(menu) {
+    return {
+      type: "vuu-menu",
+      menu,
+      clientViewportId: this.clientViewportId
+    };
+  }
+  openTreeNode(requestId, message) {
+    const treeKey = message.index === void 0 ? message.key : this.getKeyForRowAtIndex(message.index);
+    infoEnabled && info(\`treeKey \${treeKey}\`);
+    return {
+      type: OPEN_TREE_NODE,
+      vpId: this.serverViewportId,
+      treeKey
+    };
+  }
+  closeTreeNode(requestId, message) {
+    const treeKey = message.index === void 0 ? message.key : this.getKeyForRowAtIndex(message.index);
+    return {
+      type: CLOSE_TREE_NODE,
+      vpId: this.serverViewportId,
+      treeKey
+    };
+  }
+  createLink(requestId, vuuCreateVisualLink) {
+    const message = {
+      ...vuuCreateVisualLink,
+      childVpId: this.serverViewportId
+    };
+    this.awaitOperation(requestId, message);
+    return message;
+  }
+  removeLink(requestId) {
+    const message = {
+      type: "REMOVE_VISUAL_LINK",
+      childVpId: this.serverViewportId
+    };
+    this.awaitOperation(requestId, message);
+    return message;
+  }
+  suspend() {
+    this.suspended = true;
+    info == null ? void 0 : info("suspend");
+  }
+  resume() {
+    this.suspended = false;
+    if (debugEnabled2) {
+      debug2 == null ? void 0 : debug2(\`resume: \${this.currentData()}\`);
+    }
+    return [this.size, this.currentData()];
+  }
+  currentData() {
+    const out = [];
+    if (this.dataWindow) {
+      const records = this.dataWindow.getData();
+      const { keys } = this;
+      const toClient = this.isTree ? toClientRowTree : toClientRow;
+      for (const row of records) {
+        if (row) {
+          out.push(toClient(row, keys, this.selectedRows));
+        }
+      }
+    }
+    return out;
+  }
+  enable(requestId) {
+    this.awaitOperation(requestId, { type: "enable" });
+    info == null ? void 0 : info(\`enable: \${this.serverViewportId}\`);
+    return {
+      type: ENABLE_VP,
+      viewPortId: this.serverViewportId
+    };
+  }
+  disable(requestId) {
+    this.awaitOperation(requestId, { type: "disable" });
+    info == null ? void 0 : info(\`disable: \${this.serverViewportId}\`);
+    this.suspended = false;
+    return {
+      type: DISABLE_VP,
+      viewPortId: this.serverViewportId
+    };
+  }
+  setConfig(requestId, config) {
+    var _a;
+    this.awaitOperation(requestId, { type: "config", data: config });
+    const { filterSpec: filter, ...remainingConfig } = config;
+    debugEnabled2 ? debug2 == null ? void 0 : debug2(\`setConfig \${JSON.stringify(config)}\`) : info == null ? void 0 : info(\`setConfig\`);
+    if (!this.isTree && config.groupBy.length > 0) {
+      (_a = this.dataWindow) == null ? void 0 : _a.clear();
+      this.lastRowsReturnedToClient[0] = -1;
+      this.lastRowsReturnedToClient[1] = -1;
+    }
+    return this.createRequest(
+      {
+        ...remainingConfig,
+        filterSpec: typeof (filter == null ? void 0 : filter.filter) === "string" ? {
+          filter: filter.filter
+        } : {
+          filter: ""
+        }
+      },
+      true
+    );
+  }
+  selectRequest(requestId, selected) {
+    this.selectedRows = selected;
+    this.awaitOperation(requestId, { type: "selection", data: selected });
+    info == null ? void 0 : info(\`selectRequest: \${selected}\`);
+    return {
+      type: "SET_SELECTION",
+      vpId: this.serverViewportId,
+      selection: expandSelection(selected)
+    };
+  }
+  removePendingRangeRequest(firstIndex, lastIndex) {
+    for (let i = this.pendingRangeRequests.length - 1; i >= 0; i--) {
+      const { from, to } = this.pendingRangeRequests[i];
+      let isLast = true;
+      if (firstIndex >= from && firstIndex < to || lastIndex > from && lastIndex < to) {
+        if (!isLast) {
+          console.warn(
+            "removePendingRangeRequest TABLE_ROWS are not for latest request"
+          );
+        }
+        this.pendingRangeRequests.splice(i, 1);
+        break;
+      } else {
+        isLast = false;
+      }
+    }
+  }
+  updateRows(rows) {
+    var _a, _b, _c;
+    const [firstRow, lastRow] = getFirstAndLastRows(rows);
+    if (firstRow && lastRow) {
+      this.removePendingRangeRequest(firstRow.rowIndex, lastRow.rowIndex);
+    }
+    if (rows.length === 1) {
+      if (firstRow.vpSize === 0 && this.disabled) {
+        debug2 == null ? void 0 : debug2(
+          \`ignore a SIZE=0 message on disabled viewport (\${rows.length} rows)\`
+        );
+        return;
+      } else if (firstRow.updateType === "SIZE") {
+        this.setLastSizeOnlyUpdateSize(firstRow.vpSize);
+      }
+    }
+    for (const row of rows) {
+      if (this.isTree && isLeafUpdate(row)) {
+        continue;
+      } else {
+        if (row.updateType === "SIZE" || ((_a = this.dataWindow) == null ? void 0 : _a.rowCount) !== row.vpSize) {
+          (_b = this.dataWindow) == null ? void 0 : _b.setRowCount(row.vpSize);
+          this.rowCountChanged = true;
+        }
+        if (row.updateType === "U") {
+          if ((_c = this.dataWindow) == null ? void 0 : _c.setAtIndex(row)) {
+            this.hasUpdates = true;
+            if (!this.batchMode) {
+              this.pendingUpdates.push(row);
+            }
+          }
+        }
+      }
+    }
+  }
+  getKeyForRowAtIndex(rowIndex) {
+    const row = this.dataWindow.getAtIndex(rowIndex);
+    return row == null ? void 0 : row.rowKey;
+  }
+  // This is called only after new data has been received from server - data
+  // returned direcly from buffer does not use this.
+  getClientRows() {
+    var _a, _b, _c, _d;
+    let out = void 0;
+    let mode = "size-only";
+    if (!this.hasUpdates && !this.rowCountChanged) {
+      return NO_DATA_UPDATE;
+    }
+    if (this.hasUpdates) {
+      const { keys, selectedRows } = this;
+      const toClient = this.isTree ? toClientRowTree : toClientRow;
+      if (this.updateThrottleTimer) {
+        self.clearTimeout(this.updateThrottleTimer);
+        this.updateThrottleTimer = void 0;
+      }
+      if (this.pendingUpdates.length > 0 && this.dataWindow.hasAllRowsWithinRange) {
+        out = [];
+        mode = "update";
+        const missingRows = gapBetweenLastRowSentToClient(
+          this.lastRowsReturnedToClient,
+          this.pendingUpdates,
+          this.dataWindow.clientRange
+        );
+        if (missingRows) {
+          for (let i = missingRows.from; i < missingRows.to; i++) {
+            const row = this.dataWindow.getAtIndex(i);
+            if (row) {
+              out.push(toClient(row, keys, selectedRows));
+            } else {
+              throw Error("[Viewport] missing row not in data cache");
+            }
+          }
+          for (const row of this.pendingUpdates) {
+            out.push(toClient(row, keys, selectedRows));
+          }
+          out.sort(
+            ([idx1], [idx2]) => idx1 - idx2
+          );
+        } else {
+          for (const row of this.pendingUpdates) {
+            out.push(toClient(row, keys, selectedRows));
+          }
+        }
+        this.lastRowsReturnedToClient[0] = (_b = (_a = out.at(0)) == null ? void 0 : _a[0]) != null ? _b : -1;
+        this.lastRowsReturnedToClient[1] = (_d = (_c = out.at(-1)) == null ? void 0 : _c[0]) != null ? _d : -1;
+      }
+      this.pendingUpdates.length = 0;
+      this.hasUpdates = false;
+    }
+    if (this.throttleMessage(mode)) {
+      return NO_DATA_UPDATE;
+    } else {
+      return [out, mode];
+    }
+  }
+  createRequest(params, overWrite = false) {
+    if (overWrite) {
+      return {
+        type: "CHANGE_VP",
+        viewPortId: this.serverViewportId,
+        ...params
+      };
+    } else {
+      return {
+        type: "CHANGE_VP",
+        viewPortId: this.serverViewportId,
+        aggregations: this.aggregations,
+        columns: this.columns,
+        sort: this.sort,
+        groupBy: this.groupBy,
+        filterSpec: {
+          filter: this.filter.filter
+        },
+        ...params
+      };
+    }
+  }
+};
+_status = new WeakMap();
+_clientRange = new WeakMap();
+var toClientRow = ({ rowIndex, rowKey, sel: isSelected, data }, keys, selectedRows) => {
+  return [
+    rowIndex,
+    keys.keyFor(rowIndex),
+    true,
+    false,
+    0,
+    0,
+    rowKey,
+    isSelected ? getSelectionStatus(selectedRows, rowIndex) : 0
+  ].concat(data);
+};
+var toClientRowTree = ({ rowIndex, rowKey, sel: isSelected, data }, keys, selectedRows) => {
+  const [depth, isExpanded, , isLeaf, , count, ...rest] = data;
+  return [
+    rowIndex,
+    keys.keyFor(rowIndex),
+    isLeaf,
+    isExpanded,
+    depth,
+    count,
+    rowKey,
+    isSelected ? getSelectionStatus(selectedRows, rowIndex) : 0
+  ].concat(rest);
+};
+
+// src/server-proxy/server-proxy.ts
+var _requestId = 1;
+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;
+var addTitleToLinks = (links, serverViewportId, label) => links.map(
+  (link) => link.parentVpId === serverViewportId ? { ...link, label } : link
+);
+function addLabelsToLinks(links, viewports) {
+  return links.map((linkDescriptor) => {
+    const { parentVpId } = linkDescriptor;
+    const viewport = viewports.get(parentVpId);
+    if (viewport) {
+      return {
+        ...linkDescriptor,
+        parentClientVpId: viewport.clientViewportId,
+        label: viewport.title
+      };
+    } else {
+      throw Error("addLabelsToLinks viewport not found");
+    }
+  });
+}
+var ServerProxy = class {
+  constructor(connection, callback) {
+    __publicField(this, "connection");
+    __publicField(this, "postMessageToClient");
+    __publicField(this, "viewports");
+    __publicField(this, "mapClientToServerViewport");
+    __publicField(this, "authToken", "");
+    __publicField(this, "user", "user");
+    __publicField(this, "pendingLogin");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    __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();
+    connection.on("reconnected", this.reconnect);
+  }
+  async login(authToken, user = "user") {
+    if (authToken) {
+      this.authToken = authToken;
+      this.user = user;
+      return new Promise((resolve, reject) => {
+        this.sendMessageToServer(
+          { type: LOGIN, token: this.authToken, user },
+          ""
+        );
+        this.pendingLogin = { resolve, reject };
+      });
+    } else if (this.authToken === "") {
+      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);
+      const viewport = new Viewport(message, this.postMessageToClient);
+      this.viewports.set(message.viewport, viewport);
+      const pendingSubscription = this.awaitResponseToMessage(
+        viewport.subscribe(),
+        message.viewport
+      );
+      const pendingResponses = [pendingSubscription, pendingTableSchema];
+      const awaitPendingReponses = Promise.all(pendingResponses);
+      awaitPendingReponses.then(([subscribeResponse, tableSchema]) => {
+        const { viewPortId: serverViewportId } = subscribeResponse;
+        const { status: previousViewportStatus } = viewport;
+        if (message.viewport !== serverViewportId) {
+          this.viewports.delete(message.viewport);
+          this.viewports.set(serverViewportId, viewport);
+        }
+        this.mapClientToServerViewport.set(message.viewport, serverViewportId);
+        const clientResponse = viewport.handleSubscribed(
+          subscribeResponse,
+          tableSchema
+        );
+        if (clientResponse) {
+          this.postMessageToClient(clientResponse);
+          if (debugEnabled3) {
+            debug3(
+              \`post DataSourceSubscribedMessage to client: \${JSON.stringify(
+                clientResponse
+              )}\`
+            );
+          }
+        }
+        if (message.selectedIndexValues) {
+          infoEnabled2 && info2(\`selected = \${JSON.stringify(message.selectedIndexValues)}\`);
+          this.select(viewport, { selected: message.selectedIndexValues });
+        }
+        if (viewport.disabled) {
+          this.disableViewport(viewport);
+        }
+        if (this.queuedRequests.length > 0) {
+          this.processQueuedRequests();
+        }
+        if (previousViewportStatus === "subscribing" && // A session table will never have Visual Links, nor Context Menus
+        !isSessionTable(viewport.table)) {
+          this.sendMessageToServer({
+            type: GET_VP_VISUAL_LINKS,
+            vpId: serverViewportId
+          });
+          this.sendMessageToServer({
+            type: GET_VIEW_PORT_MENUS,
+            vpId: serverViewportId
+          });
+          Array.from(this.viewports.entries()).filter(
+            ([id, { disabled, status }]) => id !== serverViewportId && !disabled && status === "subscribed"
+          ).forEach(([vpId]) => {
+            this.sendMessageToServer({
+              type: GET_VP_VISUAL_LINKS,
+              vpId
+            });
+          });
+        }
+      });
+    } else {
+      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 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);
+    if (serverViewportId) {
+      info2 == null ? void 0 : info2(
+        \`Unsubscribe Message (Client to Server):
+        \${serverViewportId}\`
+      );
+      this.sendMessageToServer({
+        type: REMOVE_VP,
+        viewPortId: serverViewportId
+      });
+    } else {
+      error2(
+        \`failed to unsubscribe client viewport \${clientViewportId}, viewport not found\`
+      );
+    }
+  }
+  getViewportForClient(clientViewportId, throws = true) {
+    const serverViewportId = this.mapClientToServerViewport.get(clientViewportId);
+    if (serverViewportId) {
+      const viewport = this.viewports.get(serverViewportId);
+      if (viewport) {
+        return viewport;
+      } else if (throws) {
+        throw Error(
+          \`Viewport not found for client viewport \${clientViewportId}\`
+        );
+      } else {
+        return null;
+      }
+    } else if (this.viewports.has(clientViewportId)) {
+      return this.viewports.get(clientViewportId);
+    } else if (throws) {
+      throw Error(
+        \`Viewport server id not found for client viewport \${clientViewportId}\`
+      );
+    } else {
+      return null;
+    }
+  }
+  /**********************************************************************/
+  /* Handle messages from client                                        */
+  /**********************************************************************/
+  setViewRange(viewport, message) {
+    const requestId = nextRequestId();
+    infoEnabled2 && info2(\`setViewRange (\${message.range.from}:\${message.range.to})\`);
+    const [serverRequest, rows, debounceRequest] = viewport.rangeRequest(
+      requestId,
+      message.range
+    );
+    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})\`
+          );
+        }
+        infoEnabled2 && info2(
+          \`setViewRange send CHANGE_VP_RANGE<#\${requestId}> (\${serverRequest.from}-\${serverRequest.to})\`
+        );
+        this.sendMessageToServer(serverRequest, requestId);
+      }
+      if (rows) {
+        info2 == null ? void 0 : info2(\`setViewRange \${rows.length} rows returned from cache\`);
+        this.postMessageToClient({
+          mode: "update",
+          type: "viewport-update",
+          clientViewportId: viewport.clientViewportId,
+          range: message.range,
+          rows
+        });
+      } else if (debounceRequest) {
+        this.postMessageToClient(debounceRequest);
+      }
+    } else if (serverRequest) {
+      this.addRequestToQueue({
+        clientViewportId: message.viewport,
+        message: serverRequest,
+        requestId
+      });
+    }
+  }
+  // TODO check config has actually changed
+  setConfig(viewport, message) {
+    const requestId = nextRequestId();
+    const request = viewport.setConfig(requestId, message.config);
+    this.sendIfReady(request, requestId, viewport.status === "subscribed");
+  }
+  setTitle(viewport, message) {
+    if (viewport) {
+      viewport.title = message.title;
+      this.updateTitleOnVisualLinks(viewport);
+    }
+  }
+  select(viewport, message) {
+    const requestId = nextRequestId();
+    const { selected } = message;
+    const request = viewport.selectRequest(requestId, selected);
+    this.sendIfReady(request, requestId, viewport.status === "subscribed");
+  }
+  disableViewport(viewport) {
+    const requestId = nextRequestId();
+    const request = viewport.disable(requestId);
+    this.sendIfReady(request, requestId, viewport.status === "subscribed");
+  }
+  enableViewport(viewport) {
+    if (viewport.disabled) {
+      const requestId = nextRequestId();
+      const request = viewport.enable(requestId);
+      this.sendIfReady(request, requestId, viewport.status === "subscribed");
+    }
+  }
+  suspendViewport(viewport) {
+    viewport.suspend();
+    viewport.suspendTimer = setTimeout(() => {
+      info2 == null ? void 0 : info2("suspendTimer expired, escalate suspend to disable");
+      this.disableViewport(viewport);
+    }, 3e3);
+  }
+  resumeViewport(viewport) {
+    if (viewport.suspendTimer) {
+      debug3 == null ? void 0 : debug3("clear suspend timer");
+      clearTimeout(viewport.suspendTimer);
+      viewport.suspendTimer = null;
+    }
+    const [size, rows] = viewport.resume();
+    debug3 == null ? void 0 : debug3(\`resumeViewport size \${size}, \${rows.length} rows sent to client\`);
+    this.postMessageToClient({
+      clientViewportId: viewport.clientViewportId,
+      mode: "update",
+      rows,
+      size,
+      type: "viewport-update"
+    });
+  }
+  openTreeNode(viewport, message) {
+    if (viewport.serverViewportId) {
+      const requestId = nextRequestId();
+      this.sendIfReady(
+        viewport.openTreeNode(requestId, message),
+        requestId,
+        viewport.status === "subscribed"
+      );
+    }
+  }
+  closeTreeNode(viewport, message) {
+    if (viewport.serverViewportId) {
+      const requestId = nextRequestId();
+      this.sendIfReady(
+        viewport.closeTreeNode(requestId, message),
+        requestId,
+        viewport.status === "subscribed"
+      );
+    }
+  }
+  createLink(viewport, message) {
+    const [requestId, visualLinkRequest] = stripRequestId(message);
+    const parentVpId = this.mapClientToServerViewport.get(message.parentVpId);
+    if (parentVpId) {
+      const request = viewport.createLink(requestId, {
+        ...visualLinkRequest,
+        parentVpId
+      });
+      this.sendMessageToServer(request, requestId);
+    } else {
+      throw Error(\`createLink parent viewport not found \${message.parentVpId}\`);
+    }
+  }
+  removeLink(viewport, message) {
+    const { requestId } = message;
+    const request = viewport.removeLink(requestId);
+    this.sendMessageToServer(request, requestId);
+  }
+  updateTitleOnVisualLinks(viewport) {
+    var _a;
+    const { serverViewportId, title } = viewport;
+    for (const vp of this.viewports.values()) {
+      if (vp !== viewport && vp.links && serverViewportId && title) {
+        if ((_a = vp.links) == null ? void 0 : _a.some((link) => link.parentVpId === serverViewportId)) {
+          const [messageToClient] = vp.setLinks(
+            addTitleToLinks(vp.links, serverViewportId, title)
+          );
+          this.postMessageToClient(messageToClient);
+        }
+      }
+    }
+  }
+  removeViewportFromVisualLinks(serverViewportId) {
+    var _a;
+    for (const vp of this.viewports.values()) {
+      if ((_a = vp.links) == null ? void 0 : _a.some(({ parentVpId }) => parentVpId === serverViewportId)) {
+        const [messageToClient] = vp.setLinks(
+          vp.links.filter(({ parentVpId }) => parentVpId !== serverViewportId)
+        );
+        this.postMessageToClient(messageToClient);
+      }
+    }
+  }
+  menuRpcCall(message) {
+    const viewport = this.getViewportForClient(message.vpId, false);
+    if (viewport == null ? void 0 : viewport.serverViewportId) {
+      const [requestId, rpcRequest] = stripRequestId(message);
+      this.sendMessageToServer(
+        {
+          ...rpcRequest,
+          vpId: viewport.serverViewportId
+        },
+        requestId
+      );
+    }
+  }
+  viewportRpcCall(message) {
+    const viewport = this.getViewportForClient(message.vpId, false);
+    if (viewport == null ? void 0 : viewport.serverViewportId) {
+      const [requestId, { namedParams = {}, ...rpcRequest }] = stripRequestId(message);
+      this.sendMessageToServer(
+        {
+          ...rpcRequest,
+          namedParams,
+          vpId: viewport.serverViewportId
+        },
+        requestId
+      );
+    }
+  }
+  rpcCall(message) {
+    const [requestId, rpcRequest] = stripRequestId(message);
+    const module = getRpcServiceModule(rpcRequest.service);
+    this.sendMessageToServer(rpcRequest, requestId, { module });
+  }
+  handleMessageFromClient(message) {
+    var _a;
+    if (isViewportMessage(message) || isVisualLinkMessage(message)) {
+      if (message.type === "disable") {
+        const viewport = this.getViewportForClient(message.viewport, false);
+        if (viewport !== null) {
+          return this.disableViewport(viewport);
+        } else {
+          return;
+        }
+      } else {
+        const viewport = isVisualLinkMessage(message) ? this.getViewportForClient(message.childVpId) : this.getViewportForClient(message.viewport);
+        switch (message.type) {
+          case "setViewRange":
+            return this.setViewRange(viewport, message);
+          case "config":
+            return this.setConfig(viewport, message);
+          case "select":
+            return this.select(viewport, message);
+          case "suspend":
+            return this.suspendViewport(viewport);
+          case "resume":
+            return this.resumeViewport(viewport);
+          case "enable":
+            return this.enableViewport(viewport);
+          case "openTreeNode":
+            return this.openTreeNode(viewport, message);
+          case "closeTreeNode":
+            return this.closeTreeNode(viewport, message);
+          case "CREATE_VISUAL_LINK":
+            return this.createLink(viewport, message);
+          case "REMOVE_VISUAL_LINK":
+            return this.removeLink(viewport, message);
+          case "setTitle":
+            return this.setTitle(viewport, message);
+          default:
+        }
+      }
+    } else if (isVuuRpcRequest(message)) {
+      return this.viewportRpcCall(
+        message
+      );
+    } else if (isVuuMenuRpcRequest(message)) {
+      return this.menuRpcCall(message);
+    } else if (message.type === "disconnect") {
+      return this.disconnect();
+    } else {
+      const { type, requestId } = message;
+      switch (type) {
+        case "GET_TABLE_LIST": {
+          (_a = this.tableList) != null ? _a : this.tableList = this.awaitResponseToMessage(
+            { type },
+            requestId
+          );
+          this.tableList.then((response) => {
+            this.postMessageToClient({
+              type: "TABLE_LIST_RESP",
+              tables: response.tables,
+              requestId
+            });
+          });
+          return;
+        }
+        case "GET_TABLE_META": {
+          this.getTableMeta(message.table, requestId).then((tableSchema) => {
+            if (tableSchema) {
+              this.postMessageToClient({
+                type: "TABLE_META_RESP",
+                tableSchema,
+                requestId
+              });
+            }
+          });
+          return;
+        }
+        case "RPC_CALL":
+          return this.rpcCall(message);
+        default:
+      }
+    }
+    error2(
+      \`Vuu ServerProxy Unexpected message from client \${JSON.stringify(
+        message
+      )}\`
+    );
+  }
+  getTableMeta(table, requestId = nextRequestId()) {
+    if (isSessionTable(table)) {
+      return this.awaitResponseToMessage(
+        { type: "GET_TABLE_META", table },
+        requestId
+      ).then(createSchemaFromTableMetadata);
+    }
+    const key = \`\${table.module}:\${table.table}\`;
+    let tableMetaRequest = this.cachedTableMetaRequests.get(key);
+    if (!tableMetaRequest) {
+      tableMetaRequest = this.awaitResponseToMessage(
+        { type: "GET_TABLE_META", table },
+        requestId
+      );
+      this.cachedTableMetaRequests.set(key, tableMetaRequest);
+    }
+    return tableMetaRequest == null ? void 0 : tableMetaRequest.then((response) => this.cacheTableMeta(response));
+  }
+  awaitResponseToMessage(message, requestId = nextRequestId()) {
+    return new Promise((resolve, reject) => {
+      this.sendMessageToServer(message, requestId);
+      this.pendingRequests.set(requestId, { reject, resolve });
+    });
+  }
+  sendIfReady(message, requestId, isReady = true) {
+    if (isReady) {
+      this.sendMessageToServer(message, requestId);
+    }
+    return isReady;
+  }
+  sendMessageToServer(body, requestId = \`\${_requestId++}\`, options = DEFAULT_OPTIONS) {
+    const { module = "CORE" } = options;
+    if (this.authToken) {
+      this.connection.send({
+        requestId,
+        sessionId: this.sessionId,
+        token: this.authToken,
+        user: this.user,
+        module,
+        body
+      });
+    }
+  }
+  handleMessageFromServer(message) {
+    var _a, _b, _c;
+    const { body, requestId, sessionId } = message;
+    const pendingRequest = this.pendingRequests.get(requestId);
+    if (pendingRequest) {
+      const { resolve } = pendingRequest;
+      this.pendingRequests.delete(requestId);
+      resolve(body);
+      return;
+    }
+    const { viewports } = this;
+    switch (body.type) {
+      case HB:
+        this.sendMessageToServer(
+          { type: HB_RESP, ts: +/* @__PURE__ */ new Date() },
+          "NA"
+        );
+        break;
+      case "LOGIN_SUCCESS":
+        if (sessionId) {
+          this.sessionId = sessionId;
+          (_a = this.pendingLogin) == null ? void 0 : _a.resolve(sessionId);
+          this.pendingLogin = void 0;
+        } else {
+          throw Error("LOGIN_SUCCESS did not provide sessionId");
+        }
+        break;
+      // TODO login rejected
+      case "REMOVE_VP_SUCCESS":
+        {
+          const viewport = viewports.get(body.viewPortId);
+          if (viewport) {
+            this.mapClientToServerViewport.delete(viewport.clientViewportId);
+            viewports.delete(body.viewPortId);
+            this.removeViewportFromVisualLinks(body.viewPortId);
+          }
+        }
+        break;
+      case SET_SELECTION_SUCCESS:
+        {
+          const viewport = this.viewports.get(body.vpId);
+          if (viewport) {
+            viewport.completeOperation(requestId);
+          }
+        }
+        break;
+      case CHANGE_VP_SUCCESS:
+      case DISABLE_VP_SUCCESS:
+        if (viewports.has(body.viewPortId)) {
+          const viewport = this.viewports.get(body.viewPortId);
+          if (viewport) {
+            const response = viewport.completeOperation(requestId);
+            if (response !== void 0) {
+              this.postMessageToClient(response);
+              if (debugEnabled3) {
+                debug3(\`postMessageToClient \${JSON.stringify(response)}\`);
+              }
+            }
+          }
+        }
+        break;
+      case ENABLE_VP_SUCCESS:
+        {
+          const viewport = this.viewports.get(body.viewPortId);
+          if (viewport) {
+            const response = viewport.completeOperation(requestId);
+            if (response) {
+              this.postMessageToClient(response);
+              const [size, rows] = viewport.resume();
+              this.postMessageToClient({
+                clientViewportId: viewport.clientViewportId,
+                mode: "update",
+                rows,
+                size,
+                type: "viewport-update"
+              });
+            }
+          }
+        }
+        break;
+      case "TABLE_ROW":
+        {
+          const viewportRowMap = groupRowsByViewport(body.rows);
+          const [firstRow, secondRow] = body.rows;
+          if (body.rows.length === 0) {
+            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 && info2(
+                  \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE ONLY \${firstRow.vpSize}\`
+                );
+                infoEnabled2 && info2(
+                  \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE ONLY \${firstRow.vpSize}\`
+                );
+              } else {
+                infoEnabled2 && info2(
+                  \`handleMessageFromServer [\${firstRow.viewPortId}] TABLE_ROW SIZE \${firstRow.vpSize} rowIdx \${firstRow.rowIndex}\`
+                );
+              }
+            } else {
+              infoEnabled2 && info2(
+                \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows, SIZE \${firstRow.vpSize}, [\${secondRow == null ? void 0 : secondRow.rowIndex}] - [\${(_b = body.rows[body.rows.length - 1]) == null ? void 0 : _b.rowIndex}]\`
+              );
+            }
+          } else {
+            infoEnabled2 && info2(
+              \`handleMessageFromServer TABLE_ROW \${body.rows.length} rows [\${firstRow == null ? void 0 : firstRow.rowIndex}] - [\${(_c = body.rows[body.rows.length - 1]) == null ? void 0 : _c.rowIndex}]\`
+            );
+          }
+          for (const [viewportId, rows] of Object.entries(viewportRowMap)) {
+            const viewport = viewports.get(viewportId);
+            if (viewport) {
+              viewport.updateRows(rows);
+            } else {
+              warn2 == null ? void 0 : warn2(
+                \`TABLE_ROW message received for non registered viewport \${viewportId}\`
+              );
+            }
+          }
+          this.processUpdates();
+        }
+        break;
+      case "CHANGE_VP_RANGE_SUCCESS":
+        {
+          const viewport = this.viewports.get(body.viewPortId);
+          if (viewport) {
+            const { from, to } = body;
+            infoEnabled2 && info2(\`CHANGE_VP_RANGE_SUCCESS<#\${requestId}> \${from} - \${to}\`);
+            viewport.completeOperation(requestId, from, to);
+          }
+        }
+        break;
+      case OPEN_TREE_SUCCESS:
+      case CLOSE_TREE_SUCCESS:
+        break;
+      case "CREATE_VISUAL_LINK_SUCCESS":
+        {
+          const viewport = this.viewports.get(body.childVpId);
+          const parentViewport = this.viewports.get(body.parentVpId);
+          if (viewport && parentViewport) {
+            const { childColumnName, parentColumnName } = body;
+            const response = viewport.completeOperation(
+              requestId,
+              childColumnName,
+              parentViewport.clientViewportId,
+              parentColumnName
+            );
+            if (response) {
+              this.postMessageToClient(response);
+            }
+          }
+        }
+        break;
+      case "REMOVE_VISUAL_LINK_SUCCESS":
+        {
+          const viewport = this.viewports.get(body.childVpId);
+          if (viewport) {
+            const response = viewport.completeOperation(
+              requestId
+            );
+            if (response) {
+              this.postMessageToClient(response);
+            }
+          }
+        }
+        break;
+      case "VP_VISUAL_LINKS_RESP":
+        {
+          const activeLinkDescriptors = this.getActiveLinks(body.links);
+          const viewport = this.viewports.get(body.vpId);
+          if (activeLinkDescriptors.length && viewport) {
+            const linkDescriptorsWithLabels = addLabelsToLinks(
+              activeLinkDescriptors,
+              this.viewports
+            );
+            const [clientMessage, pendingLink] = viewport.setLinks(
+              linkDescriptorsWithLabels
+            );
+            this.postMessageToClient(clientMessage);
+            if (pendingLink) {
+              const { link, parentClientVpId } = pendingLink;
+              const requestId2 = nextRequestId();
+              const parentVpId = this.mapClientToServerViewport.get(parentClientVpId);
+              if (parentVpId) {
+                const message2 = viewport.createLink(requestId2, {
+                  childVpId: body.vpId,
+                  childColumnName: link.fromColumn,
+                  parentColumnName: link.toColumn,
+                  parentVpId,
+                  type: "CREATE_VISUAL_LINK"
+                });
+                this.sendMessageToServer(message2, requestId2);
+              }
+            }
+          }
+        }
+        break;
+      case "VIEW_PORT_MENUS_RESP":
+        if (body.menu.name) {
+          const viewport = this.viewports.get(body.vpId);
+          if (viewport) {
+            const clientMessage = viewport.setMenu(body.menu);
+            this.postMessageToClient(clientMessage);
+          }
+        }
+        break;
+      case "VP_EDIT_RPC_RESPONSE":
+        {
+          this.postMessageToClient({
+            action: body.action,
+            requestId,
+            rpcName: body.rpcName,
+            type: "VP_EDIT_RPC_RESPONSE"
+          });
+        }
+        break;
+      case "VP_EDIT_RPC_REJECT":
+        {
+          const viewport = this.viewports.get(body.vpId);
+          if (viewport) {
+            this.postMessageToClient({
+              requestId,
+              type: "VP_EDIT_RPC_REJECT",
+              error: body.error
+            });
+          }
+        }
+        break;
+      case "VIEW_PORT_MENU_REJ": {
+        const { error: error3, rpcName, vpId } = body;
+        const viewport = this.viewports.get(vpId);
+        if (viewport) {
+          this.postMessageToClient({
+            clientViewportId: viewport.clientViewportId,
+            error: error3,
+            rpcName,
+            type: "VIEW_PORT_MENU_REJ",
+            requestId
+          });
+        }
+        break;
+      }
+      case "VIEW_PORT_MENU_RESP":
+        {
+          if (isSessionTableActionMessage(body)) {
+            const { action, rpcName } = body;
+            this.awaitResponseToMessage({
+              type: "GET_TABLE_META",
+              table: action.table
+            }).then((response) => {
+              const tableSchema = createSchemaFromTableMetadata(
+                response
+              );
+              this.postMessageToClient({
+                /* MenuRpcResponse */
+                rpcName,
+                type: "VIEW_PORT_MENU_RESP",
+                action: {
+                  ...action,
+                  tableSchema
+                },
+                tableAlreadyOpen: this.isTableOpen(action.table),
+                requestId
+              });
+            });
+          } else {
+            const { action, rpcName } = body;
+            this.postMessageToClient({
+              /* MenuRpcResponse */
+              action,
+              rpcName,
+              requestId,
+              tableAlreadyOpen: isOpenDialogAction(action) && this.isTableOpen(action.table),
+              type: "VIEW_PORT_MENU_RESP"
+            });
+          }
+        }
+        break;
+      case "RPC_RESP":
+        {
+          const { method, result } = body;
+          this.postMessageToClient({
+            type: "RPC_RESP",
+            method,
+            result,
+            requestId
+          });
+        }
+        break;
+      case "VIEW_PORT_RPC_REPONSE":
+        {
+          const { method, action } = body;
+          this.postMessageToClient({
+            type: "VIEW_PORT_RPC_RESPONSE",
+            rpcName: method,
+            action,
+            requestId
+          });
+        }
+        break;
+      case "ERROR":
+        error2(body.msg);
+        break;
+      default:
+        infoEnabled2 && info2(\`handleMessageFromServer \${body["type"]}.\`);
+    }
+  }
+  cacheTableMeta(messageBody) {
+    const { module, table } = messageBody.table;
+    const key = \`\${module}:\${table}\`;
+    let tableSchema = this.cachedTableSchemas.get(key);
+    if (!tableSchema) {
+      tableSchema = createSchemaFromTableMetadata(messageBody);
+      this.cachedTableSchemas.set(key, tableSchema);
+    }
+    return tableSchema;
+  }
+  isTableOpen(table) {
+    if (table) {
+      const tableName = table.table;
+      for (const viewport of this.viewports.values()) {
+        if (!viewport.suspended && viewport.table.table === tableName) {
+          return true;
+        }
+      }
+    }
+  }
+  // Eliminate links to suspended viewports
+  getActiveLinks(linkDescriptors) {
+    return linkDescriptors.filter((linkDescriptor) => {
+      const viewport = this.viewports.get(linkDescriptor.parentVpId);
+      return viewport && !viewport.suspended;
+    });
+  }
+  processUpdates() {
+    this.viewports.forEach((viewport) => {
+      var _a;
+      if (viewport.hasUpdatesToProcess) {
+        const result = viewport.getClientRows();
+        if (result !== NO_DATA_UPDATE) {
+          const [rows, mode] = result;
+          const size = viewport.getNewRowCount();
+          if (size !== void 0 || rows && rows.length > 0) {
+            debugEnabled3 && debug3(
+              \`postMessageToClient #\${viewport.clientViewportId} viewport-update \${mode}, \${(_a = rows == null ? void 0 : rows.length) != null ? _a : "no"} rows, size \${size}\`
+            );
+            if (mode) {
+              this.postMessageToClient({
+                clientViewportId: viewport.clientViewportId,
+                mode,
+                rows,
+                size,
+                type: "viewport-update"
+              });
+            }
+          }
+        }
+      }
+    });
+  }
+};
+
+// 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 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) => {
+      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
+    });
+  }
+  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", 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: 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 (isWebSocketConnectionMessage(msg)) {
+        postMessage(msg);
+      } else {
+        server.handleMessageFromServer(msg);
+      }
+    },
+    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);
+  }
+}
+var handleMessageFromClient = async ({
+  data: message
+}) => {
+  switch (message.type) {
+    case "connect":
+      try {
+        await connectToServer(
+          message.url,
+          message.protocol,
+          message.token,
+          message.username,
+          message.retryLimitDisconnect,
+          message.retryLimitStartup
+        );
+        postMessage({ type: "connected" });
+      } catch (err) {
+        postMessage({ type: "connection-failed", reason: String(err) });
+      }
+      break;
+    // If any of the messages below are received BEFORE we have connected and created
+    // the server - handle accordingly
+    case "disconnect":
+      server.disconnect();
+      ws == null ? void 0 : ws.close();
+      break;
+    case "subscribe":
+      infoEnabled3 && info3(\`client subscribe: \${JSON.stringify(message)}\`);
+      server.subscribe(message);
+      break;
+    case "unsubscribe":
+      infoEnabled3 && info3(\`client unsubscribe: \${JSON.stringify(message)}\`);
+      server.unsubscribe(message.viewport);
+      break;
+    default:
+      infoEnabled3 && info3(\`client message: \${JSON.stringify(message)}\`);
+      server.handleMessageFromClient(message);
+  }
+};
+self.addEventListener("message", handleMessageFromClient);
+postMessage({ type: "ready" });
+
+`;
+
+exports.workerSourceCode = workerSourceCode;
+//# sourceMappingURL=inlined-worker.js.map