@vuu-ui/vuu-data-test 3.0.0-beta.3 → 3.1.0-beta.1

package/cjs/core/module/VuuModule.js

@@ -1,846 +0,0 @@
-'use strict';
-
-var vuuUtils = require('@vuu-ui/vuu-utils');
-var Table = require('../../Table.js');
-var TickingArrayDataSource = require('../../TickingArrayDataSource.js');
-var RuntimeVisualLink = require('../../RuntimeVisualLink.js');
-var ModuleContainer = require('./ModuleContainer.js');
-var sessionTableUtils = require('../../session-table-utils.js');
-
-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"), member.set(obj, value), value);
-var _name, _sessionTableMessageColumn, _runtimeVisualLinks, _sessionSourceTableMap, _sessionTableMap, _tableServices, _subscriptionMap, _moduleServices, _moduleMenuServices;
-const assertUpdateIsValid = (schema, column, data) => {
-  const col = schema.columns.find((col2) => col2.name === column);
-  if (col) {
-    console.log(`data type ${col.serverDataType} data ${data}`);
-  } else {
-    throw Error(
-      `schema for table ${schema.table.table} does not include column ${column}`
-    );
-  }
-};
-class VuuModule {
-  constructor(name, { sessionTableMessageColumn = "vuuMsg" } = {}) {
-    __privateAdd(this, _name);
-    __privateAdd(this, _sessionTableMessageColumn);
-    __privateAdd(this, _runtimeVisualLinks, /* @__PURE__ */ new Map());
-    __privateAdd(this, _sessionSourceTableMap, {});
-    __privateAdd(this, _sessionTableMap, {});
-    __privateAdd(this, _tableServices);
-    __privateAdd(this, _subscriptionMap, /* @__PURE__ */ new Map());
-    __publicField(this, "handlePostSubscribeActivities", ({
-      clientViewportId,
-      tableSchema
-    }) => {
-      const visualLinks = this.getVisualLinks(tableSchema.table.table);
-      const { dataSource } = this.getSubscriptionByViewport(clientViewportId);
-      requestAnimationFrame(() => {
-        dataSource.links = visualLinks;
-      });
-      if (this.visualLinks && dataSource.tableSchema) {
-        const {
-          table: { table: sourceTable }
-        } = dataSource.tableSchema;
-        for (const [table, links] of Object.entries(
-          this.visualLinks
-        )) {
-          if (links) {
-            const potentialTargets = links.filter(
-              (l) => l.toTable === sourceTable
-            );
-            if (potentialTargets.length) {
-              for (const subscriptions of __privateGet(this, _subscriptionMap).values()) {
-                for (const { dataSource: dataSource2 } of subscriptions) {
-                  if (dataSource2.tableSchema?.table.table === table) {
-                    dataSource2.links = this.getVisualLinks(table);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    });
-    __publicField(this, "unregisterViewport", (viewportId) => {
-      const { dataSource } = this.getSubscriptionByViewport(viewportId);
-      const tableName = dataSource.tableSchema?.table.table;
-      if (tableName) {
-        const subscriptionsForTable = __privateGet(this, _subscriptionMap).get(tableName);
-        if (subscriptionsForTable) {
-          for (const { viewportId: vp } of subscriptionsForTable) {
-            if (vp === viewportId) {
-              if (subscriptionsForTable.length === 1) {
-                __privateGet(this, _subscriptionMap).delete(tableName);
-              } else {
-                __privateGet(this, _subscriptionMap).set(
-                  tableName,
-                  subscriptionsForTable.filter(
-                    (s) => s.viewportId !== viewportId
-                  )
-                );
-              }
-            }
-          }
-        }
-      }
-      for (const [tableName2, subscriptions] of __privateGet(this, _subscriptionMap)) {
-        if (subscriptions[0].viewportId.toString() === viewportId) {
-          __privateGet(this, _subscriptionMap).delete(tableName2);
-        }
-      }
-      if (this.visualLinks && dataSource.tableSchema) {
-        const {
-          table: { table: sourceTable }
-        } = dataSource.tableSchema;
-        for (const [table, links] of Object.entries(
-          this.visualLinks
-        )) {
-          if (links) {
-            const potentialTargets = links.filter(
-              (l) => l.toTable === sourceTable
-            );
-            if (potentialTargets.length) {
-              for (const subscriptions of __privateGet(this, _subscriptionMap).values()) {
-                for (const { dataSource: dataSource2 } of subscriptions) {
-                  if (dataSource2.tableSchema?.table.table === table) {
-                    dataSource2.links = this.getVisualLinks(table);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    });
-    __publicField(this, "getLinks", (subscriptionMap, vuuLinks) => {
-      const visualLinks = [];
-      for (let i = 0; i < vuuLinks.length; i++) {
-        const subscriptions = subscriptionMap.get(vuuLinks[i].toTable);
-        if (subscriptions) {
-          subscriptions.forEach(({ viewportId, dataSource: { status } }) => {
-            if (status !== "suspended") {
-              const newLink = {
-                parentClientVpId: viewportId,
-                parentVpId: viewportId,
-                link: vuuLinks[i]
-              };
-              visualLinks.push(newLink);
-            }
-          });
-        }
-      }
-      return visualLinks;
-    });
-    __publicField(this, "visualLinkService", (message) => new Promise((resolve) => {
-      if (message.type === "CREATE_VISUAL_LINK") {
-        const { childColumnName, childVpId, parentColumnName, parentVpId } = message;
-        const childDataSource = this.getSubscribedDataSource(childVpId);
-        const parentDataSource = this.getSubscribedDataSource(parentVpId);
-        const runtimeVisualLink = new RuntimeVisualLink.RuntimeVisualLink(
-          childDataSource,
-          parentDataSource,
-          childColumnName,
-          parentColumnName
-        );
-        __privateGet(this, _runtimeVisualLinks).set(childVpId, runtimeVisualLink);
-        resolve({
-          clientViewportId: childVpId,
-          colName: childColumnName,
-          parentColName: parentColumnName,
-          parentViewportId: parentVpId,
-          type: "vuu-link-created"
-        });
-      } else {
-        const runtimeVisualLink = __privateGet(this, _runtimeVisualLinks).get(
-          message.childVpId
-        );
-        if (runtimeVisualLink) {
-          runtimeVisualLink.remove();
-          __privateGet(this, _runtimeVisualLinks).delete(message.childVpId);
-        } else {
-          throw Error(
-            `visualLinkService no visual link found for viewport #${message.childVpId}`
-          );
-        }
-        resolve();
-      }
-    }));
-    __publicField(this, "getVisualLinks", (tableName) => {
-      const linksForTable = this.visualLinks?.[tableName];
-      return linksForTable === void 0 ? void 0 : this.getLinks(__privateGet(this, _subscriptionMap), linksForTable);
-    });
-    __publicField(this, "createDataSource", (tableName, viewport, config) => {
-      const columnDescriptors = this.getColumnDescriptors(tableName);
-      const table = this.tables[tableName];
-      const sessionTable = __privateGet(this, _sessionTableMap)[tableName];
-      const vuuModule = this;
-      const dataSource = new TickingArrayDataSource.TickingArrayDataSource({
-        ...config,
-        columnDescriptors,
-        getVisualLinks: this.getVisualLinks,
-        keyColumn: this.schemas[tableName] === void 0 ? __privateGet(this, _sessionTableMap)[tableName].schema.key : this.schemas[tableName].key,
-        table: table || sessionTable,
-        menu: this.menus?.[tableName],
-        rpcServices: this.getServices(tableName),
-        rpcMenuServices: this.getMenuServices(tableName),
-        viewport,
-        visualLinkService: this.visualLinkService,
-        vuuModule
-      });
-      dataSource.on("subscribed", this.handlePostSubscribeActivities);
-      dataSource.on("unsubscribed", this.unregisterViewport);
-      const existingSubscriptions = __privateGet(this, _subscriptionMap).get(tableName);
-      const subscription = {
-        viewportId: dataSource.viewport,
-        dataSource,
-        sessionTableName: sessionTable ? tableName : void 0,
-        sourceTableName: __privateGet(this, _sessionSourceTableMap)[tableName]
-      };
-      if (existingSubscriptions) {
-        existingSubscriptions.push(subscription);
-      } else {
-        __privateGet(this, _subscriptionMap).set(tableName, [subscription]);
-      }
-      return dataSource;
-    });
-    __publicField(this, "deleteRow", async (rpcRequest) => {
-      if (rpcRequest.context.type === "VIEWPORT_CONTEXT") {
-        const { viewPortId } = rpcRequest.context;
-        const { key, mode = "hard" } = rpcRequest.params;
-        const sessionTable = this.getSessionTable(viewPortId, false);
-        if (sessionTable) {
-          if (mode === "soft") {
-            sessionTable.update(key, "vuu_action", "deleteRow");
-          } else {
-            sessionTable.delete(key);
-          }
-          return { type: "SUCCESS_RESULT", data: void 0 };
-        } else {
-          const { dataSource } = this.getSubscriptionByViewport(viewPortId);
-          if (dataSource.table) {
-            const table = this.tables[dataSource.table.table];
-            if (table) {
-              if (mode === "soft") {
-                table.update(
-                  key,
-                  __privateGet(this, _sessionTableMessageColumn),
-                  "SOFT_DELETED"
-                );
-              } else {
-                table.delete(key);
-              }
-              return { type: "SUCCESS_RESULT", data: void 0 };
-            }
-          }
-        }
-      }
-      return { type: "ERROR_RESULT", errorMessage: "something went wrong" };
-    });
-    __publicField(this, "deleteSelectedRows", async (rpcRequest) => {
-      if (vuuUtils.isDeleteSelectedRowsRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const { mode = "soft" } = rpcRequest.params;
-        const sessionTable = this.getSessionTable(viewPortId, false);
-        if (sessionTable) {
-          const { dataSource } = this.getSubscriptionByViewport(viewPortId);
-          const selectedRowIds = dataSource.getSelectedRowIds();
-          const deletedKeys = [];
-          if (selectedRowIds.length > 0) {
-            for (const key of selectedRowIds) {
-              if (mode === "soft") {
-                sessionTable.update(key, "vuu_action", "deleteRow");
-              } else {
-                sessionTable.delete(key);
-              }
-              deletedKeys.push(key);
-            }
-            dataSource.select?.({ type: "DESELECT_ALL" });
-          }
-          return { type: "SUCCESS_RESULT", data: { deletedKeys } };
-        }
-        return {
-          type: "ERROR_RESULT",
-          errorMessage: `deleteSelectedRows: no active session table for viewport ${viewPortId}`
-        };
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "deleteSelectedRows: invalid rpc request"
-      };
-    });
-    __publicField(this, "undoRowChange", async (rpcRequest) => {
-      if (vuuUtils.isUndoRowChangeRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const { key } = rpcRequest.params;
-        const sessionTable = this.getSessionTable(viewPortId, false);
-        if (sessionTable) {
-          const subscription = this.getSubscriptionByViewport(viewPortId);
-          const { dataSource } = subscription;
-          const sourceTableName = subscription.sourceTableName ?? dataSource.table?.table;
-          const sourceTable = this.tables[sourceTableName];
-          if (!sourceTable) {
-            return {
-              type: "ERROR_RESULT",
-              errorMessage: `undoRowChange: source table not found for viewport ${viewPortId}`
-            };
-          }
-          const sessionRow = sessionTable.findByKey(key);
-          if (!sessionRow) {
-            return {
-              type: "ERROR_RESULT",
-              errorMessage: `undoRowChange: session row not found for key ${key}`
-            };
-          }
-          const action = sessionRow[sessionTable.map.vuu_action];
-          if (action === "addRow") {
-            sessionTable.delete(key);
-            return { type: "SUCCESS_RESULT", data: { wasInsertedRow: true } };
-          }
-          if (action === "deleteRow" || action === "editCell") {
-            const sourceRow = sourceTable.findByKey(key);
-            if (!sourceRow) {
-              return {
-                type: "ERROR_RESULT",
-                errorMessage: `undoRowChange: source row not found for key ${key}`
-              };
-            }
-            const restoredRow = sessionRow.slice();
-            for (const column of sourceTable.schema.columns) {
-              restoredRow[sessionTable.map[column.name]] = sourceRow[sourceTable.map[column.name]];
-            }
-            sessionTable.updateRow(restoredRow);
-            sessionTable.update(key, "vuu_action", "");
-          }
-          return { type: "SUCCESS_RESULT", data: void 0 };
-        }
-        return {
-          type: "ERROR_RESULT",
-          errorMessage: `undoRowChange: no active session table for viewport ${viewPortId}`
-        };
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "undoRowChange: invalid rpc request"
-      };
-    });
-    __publicField(this, "editCell", async (rpcRequest) => {
-      if (vuuUtils.isEditCellRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const { column, data, key } = rpcRequest.params;
-        const sessionTable = __privateGet(this, _sessionTableMap)[viewPortId];
-        let targetTable = sessionTable;
-        if (!targetTable) {
-          const { dataSource } = this.getSubscriptionByViewport(viewPortId);
-          if (dataSource.table) {
-            targetTable = this.tables[dataSource.table.table];
-          }
-        }
-        if (targetTable) {
-          try {
-            const sessionRow = sessionTable?.findByKey(key);
-            if (sessionRow?.[sessionTable.map.vuu_action] === "deleteRow") {
-              throw Error("editCell: cannot edit a deleted row");
-            }
-            assertUpdateIsValid(targetTable.schema, column, data);
-            targetTable.update(key, column, data);
-            if (sessionTable && sessionTable.findByKey(key)?.[sessionTable.map.vuu_action] !== "addRow") {
-              sessionTable.update(key, "vuu_action", "editCell");
-            }
-            return {
-              type: "SUCCESS_RESULT",
-              data: void 0
-            };
-          } catch (e) {
-            const { message } = e;
-            return {
-              type: "ERROR_RESULT",
-              errorMessage: message
-            };
-          }
-        } else {
-          throw Error("[VuuModule] editCell unable to find table for dataSource");
-        }
-      } else {
-        throw Error("[VuuModule] editCell invalid rpc type");
-      }
-    });
-    __publicField(this, "beginEditSessionMenuHandler", async ({
-      rpcName,
-      type,
-      vpId
-    }) => {
-      if (type === "VIEW_PORT_MENUS_SELECT_RPC") {
-        console.log(`rpcName ${rpcName}`);
-        const result = await this.beginEditSession({
-          context: {
-            type: "VIEWPORT_CONTEXT",
-            viewPortId: vpId
-          },
-          params: {
-            editSessionMode: "selected-rows"
-          },
-          rpcName,
-          type: "RPC_REQUEST"
-        });
-        if (vuuUtils.isRpcSuccess(result)) {
-          const { table } = result.data;
-          return {
-            type: "VIEW_PORT_MENU_RESP",
-            rpcName,
-            action: {
-              renderComponent: "grid",
-              type: "OPEN_DIALOG_ACTION",
-              table
-            },
-            vpId
-          };
-        } else {
-          return {
-            error: result.errorMessage,
-            rpcName,
-            type: "VIEW_PORT_MENU_REJ",
-            vpId
-          };
-        }
-      } else {
-        return {
-          error: "no can do",
-          rpcName,
-          type: "VIEW_PORT_MENU_REJ",
-          vpId
-        };
-      }
-    });
-    /**
-     * Creates a standalone session table.
-     * The `copyOption` determines which rows are copied into the session table.
-     * Returns the session table reference so the caller can subscribe to it.
-     */
-    __publicField(this, "createSessionTableService", async (rpcRequest) => {
-      if (vuuUtils.isCreateSessionTableRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const { copyOption } = rpcRequest.params;
-        const subscription = this.getSubscriptionByViewport(viewPortId);
-        const { dataSource } = subscription;
-        const { table: vuuTable } = dataSource;
-        if (vuuTable) {
-          const sourceTable = this.tables[vuuTable.table];
-          if (sourceTable) {
-            const sessionTableName = `session-${vuuUtils.uuid()}`;
-            try {
-              const sessionTable = this.createSessionTable(
-                sourceTable,
-                sessionTableName,
-                copyOption,
-                dataSource
-              );
-              __privateGet(this, _sessionTableMap)[sessionTableName] = sessionTable;
-              __privateGet(this, _sessionSourceTableMap)[sessionTableName] = vuuTable.table;
-              subscription.sessionTableName = sessionTableName;
-              return {
-                data: {
-                  table: { module: vuuTable.module, table: sessionTableName }
-                },
-                type: "SUCCESS_RESULT"
-              };
-            } catch (e) {
-              return {
-                type: "ERROR_RESULT",
-                errorMessage: e.message
-              };
-            }
-          }
-        }
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "createSessionTable: invalid rpc request"
-      };
-    });
-    __publicField(this, "beginEditSession", async (rpcRequest) => {
-      if (vuuUtils.isBeginEditSessionRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const { editSessionMode = "inline-all-rows" } = rpcRequest.params;
-        const subscription = this.getSubscriptionByViewport(viewPortId);
-        const { dataSource } = subscription;
-        const { table: vuuTable } = dataSource;
-        if (vuuTable) {
-          const sourceTable = this.tables[vuuTable.table];
-          if (sourceTable) {
-            const sessionTableName = `session-${vuuUtils.uuid()}`;
-            try {
-              const sessionTable = this.createSessionTable(
-                sourceTable,
-                sessionTableName,
-                editSessionMode,
-                dataSource
-              );
-              __privateGet(this, _sessionTableMap)[sessionTableName] = sessionTable;
-              __privateGet(this, _sessionSourceTableMap)[sessionTableName] = vuuTable.table;
-              subscription.sessionTableName = sessionTableName;
-              return {
-                data: {
-                  renderComponent: "inline-form",
-                  table: {
-                    module: vuuTable.module,
-                    table: sessionTableName
-                  }
-                },
-                type: "SUCCESS_RESULT"
-              };
-            } catch (e) {
-              return {
-                type: "ERROR_RESULT",
-                errorMessage: e.message
-              };
-            }
-          }
-        }
-      } else {
-        throw Error("[VuuModule] endEditSession invalid rpc type");
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "not implemented yet"
-      };
-    });
-    __publicField(this, "addRow", async (rpcRequest) => {
-      if (vuuUtils.isAddRowRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const subscription = this.getSubscriptionByViewport(viewPortId);
-        const sessionTableName = subscription.sessionTableName ?? viewPortId;
-        const sessionTable = __privateGet(this, _sessionTableMap)[sessionTableName];
-        if (!sessionTable) {
-          return {
-            type: "ERROR_RESULT",
-            errorMessage: `addRow: no active session table for viewport ${viewPortId}`
-          };
-        }
-        const { data } = rpcRequest.params;
-        const keyColumn = sessionTable.schema.key;
-        const rowKey = data[keyColumn] ?? vuuUtils.uuid();
-        const rowData = { ...data, [keyColumn]: rowKey };
-        const columnMap = sessionTable.map;
-        const columnCount = Object.keys(columnMap).length;
-        const row = new Array(columnCount).fill("");
-        row[columnMap.vuu_action] = "addRow";
-        for (const [col, idx] of Object.entries(columnMap)) {
-          if (rowData[col] !== void 0) {
-            row[idx] = rowData[col];
-          }
-        }
-        sessionTable.insert(row);
-        return { type: "SUCCESS_RESULT", data: void 0 };
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "addRow: invalid rpc context"
-      };
-    });
-    __publicField(this, "endEditSession", async (rpcRequest) => {
-      if (vuuUtils.isEndEditSessionRpcRequest(rpcRequest)) {
-        const { viewPortId } = rpcRequest.context;
-        const subscription = this.getSubscriptionByViewport(viewPortId);
-        const sessionTableName = subscription.sessionTableName ?? viewPortId;
-        const sessionTable = __privateGet(this, _sessionTableMap)[sessionTableName];
-        const { dataSource } = subscription;
-        if (dataSource.table) {
-          const sourceTableName = subscription.sourceTableName ?? dataSource.table.table;
-          const sourceTable = this.tables[sourceTableName];
-          if (rpcRequest.params.save === true) {
-            let rejectedCount = 0;
-            const vuuMsgIdx = sessionTable.map[__privateGet(this, _sessionTableMessageColumn)];
-            const actionIdx = sessionTable.map.vuu_action;
-            const sessionTimestampIdx = sessionTable.map.vuuUpdatedTimestamp;
-            const sourceTimestampIdx = sourceTable.map.vuuUpdatedTimestamp;
-            const sourceColumns = sourceTable.schema.columns;
-            for (let i = 0; i < sessionTable.data.length; i++) {
-              const sessionRow = sessionTable.data[i];
-              const key = String(
-                sessionRow[sessionTable.map[sourceTable.schema.key]]
-              );
-              const currentRow = sourceTable.findByKey(key);
-              const action = sessionRow[actionIdx];
-              if (action === "deleteRow") {
-                if (currentRow) {
-                  const sessionTimestamp = sessionRow[sessionTimestampIdx];
-                  const sourceTimestamp = currentRow[sourceTimestampIdx];
-                  if (typeof sessionTimestamp === "number" && typeof sourceTimestamp === "number" && sourceTimestamp > sessionTimestamp) {
-                    rejectedCount += 1;
-                    sessionTable.update(
-                      key,
-                      __privateGet(this, _sessionTableMessageColumn),
-                      "stale delete"
-                    );
-                  } else {
-                    sourceTable.delete(key);
-                  }
-                }
-                continue;
-              }
-              if (sessionRow[vuuMsgIdx]) continue;
-              if (action === "editCell" && currentRow) {
-                for (const column of sourceColumns) {
-                  const value = sessionRow[sessionTable.map[column.name]];
-                  if (currentRow[sourceTable.map[column.name]] !== value) {
-                    sourceTable.update(key, column.name, value);
-                  }
-                }
-              } else if (action === "addRow" && !currentRow) {
-                sourceTable.insert(
-                  sourceColumns.map(
-                    (column) => sessionRow[sessionTable.map[column.name]]
-                  )
-                );
-              }
-            }
-            if (rejectedCount > 0) {
-              return {
-                errorMessage: "stale update",
-                type: "ERROR_RESULT"
-              };
-            }
-            return {
-              type: "SUCCESS_RESULT",
-              data: void 0
-            };
-          } else {
-            return {
-              type: "SUCCESS_RESULT",
-              data: void 0
-            };
-          }
-        } else {
-          throw Error("[VuuModule], exitEditMode");
-        }
-      } else {
-        throw Error("[VuuModule] endEditSession invalid rpc type");
-      }
-    });
-    // Bulk-edit with input in session table
-    __publicField(this, "applyBulkEdits", async (rpcRequest) => {
-      if (rpcRequest.context.type === "VIEWPORT_CONTEXT") {
-        const { viewPortId } = rpcRequest.context;
-        const sessionTable = this.getSessionTable(viewPortId);
-        for (let i = 0; i < sessionTable.data.length; i++) {
-          const newRow = sessionTable.data[i];
-          const { column, value } = rpcRequest.params;
-          const keyIndex = sessionTable.map[sessionTable.schema.key];
-          sessionTable.update(
-            String(newRow[keyIndex]),
-            column,
-            value
-          );
-        }
-        return {
-          type: "SUCCESS_RESULT",
-          data: void 0
-        };
-      } else {
-        throw Error("[VuuModule] applyBulkEdits invalid rpc type");
-      }
-    });
-    /**
-     * These services are available on any table. The client must configure the appropriate
-     * menu item(s) on Table(s). The services to implement these RPC calls are built-in to
-     * VuuModule
-     */
-    __privateAdd(this, _moduleServices, [
-      {
-        rpcName: "addRow",
-        service: this.addRow
-      },
-      {
-        rpcName: "VP_BULK_EDIT_COLUMN_CELLS_RPC",
-        service: this.applyBulkEdits
-      },
-      {
-        rpcName: "createSessionTable",
-        service: this.createSessionTableService
-      },
-      {
-        rpcName: "beginEditSession",
-        service: this.beginEditSession
-      },
-      {
-        rpcName: "deleteRow",
-        service: this.deleteRow
-      },
-      {
-        rpcName: "deleteSelectedRows",
-        service: this.deleteSelectedRows
-      },
-      {
-        rpcName: "endEditSession",
-        service: this.endEditSession
-      },
-      {
-        rpcName: "editCell",
-        service: this.editCell
-      },
-      {
-        rpcName: "undoRowChange",
-        service: this.undoRowChange
-      }
-    ]);
-    /**
-     * These services are available on any table. The client must configure the appropriate
-     * menu item(s) on Table(s). The services to implement these RPC calls are built-in to
-     * VuuModule
-     */
-    __privateAdd(this, _moduleMenuServices, [
-      {
-        rpcName: "beginEditSession",
-        service: this.beginEditSessionMenuHandler
-      }
-    ]);
-    __privateSet(this, _name, name);
-    __privateSet(this, _sessionTableMessageColumn, sessionTableMessageColumn);
-    ModuleContainer.register(this);
-  }
-  getTableSchema(tableName) {
-    return this.schemas[tableName] ?? __privateGet(this, _sessionTableMap)[tableName]?.schema;
-  }
-  getTableList() {
-    return Object.keys(this.tables);
-  }
-  get name() {
-    return __privateGet(this, _name);
-  }
-  getSubscriptionByViewport(viewportId) {
-    for (const subscriptions of __privateGet(this, _subscriptionMap).values()) {
-      for (const subscription of subscriptions) {
-        if (subscription.viewportId === viewportId) {
-          return subscription;
-        }
-      }
-    }
-    throw Error(
-      `[VuuModule] getSubscriptionByViewport, no subscription found for ${viewportId}`
-    );
-  }
-  getSubscribedDataSource(vpId) {
-    for (const subscriptions of __privateGet(this, _subscriptionMap).values()) {
-      for (const { viewportId, dataSource } of subscriptions) {
-        if (viewportId === vpId) {
-          return dataSource;
-        }
-      }
-    }
-    throw Error(`getSubscribedDataSource #${vpId} not in subscriptionMap`);
-  }
-  getServices(tableName) {
-    const tableServices = this.services?.[tableName];
-    if (Array.isArray(tableServices)) {
-      return __privateGet(this, _moduleServices).concat(tableServices);
-    } else {
-      return __privateGet(this, _moduleServices);
-    }
-  }
-  getMenuServices(tableName) {
-    const tableServices = this.menuServices?.[tableName];
-    if (Array.isArray(tableServices)) {
-      return __privateGet(this, _moduleMenuServices).concat(tableServices);
-    } else {
-      return __privateGet(this, _moduleMenuServices);
-    }
-  }
-  get sessionTableMap() {
-    return __privateGet(this, _sessionTableMap);
-  }
-  getSessionTable(sessionTableName, throwIfNotFound = true) {
-    const sessionTable = __privateGet(this, _sessionTableMap)[sessionTableName];
-    if (sessionTable) {
-      return sessionTable;
-    } else if (throwIfNotFound) {
-      throw Error(
-        `getSessionTable: no session table with name ${sessionTableName}`
-      );
-    }
-  }
-  getColumnDescriptors(tableName) {
-    const schema = this.schemas[tableName] || this.getSessionTable(tableName)?.schema;
-    if (schema) {
-      return schema.columns;
-    } else {
-      throw Error(
-        ` no schema found for module ${__privateGet(this, _name)} table ${tableName}`
-      );
-    }
-  }
-  createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource) {
-    if (editSessionMode === "All" || editSessionMode.endsWith("all-rows")) {
-      return this.createSessionTableWithAllRows(sourceTable, sessionTableName);
-    } else if (editSessionMode === "Selected" || editSessionMode === "selected-rows") {
-      return this.createSessionTableFromSelectedRows(
-        sourceTable,
-        sessionTableName,
-        dataSource
-      );
-    } else if (editSessionMode === "Empty" || editSessionMode === "empty-session-table") {
-      return this.createEmptySessionTable(sourceTable, sessionTableName);
-    } else {
-      throw Error(
-        `[VuuModule] createSessionTable, invalid editSessionMode ${editSessionMode}`
-      );
-    }
-  }
-  createSessionTableWithAllRows({ data, schema }, _sessionTableName) {
-    const sessionSchema = sessionTableUtils.sessionTableSchema(schema);
-    return new Table.Table(
-      sessionSchema,
-      data.map((row) => sessionTableUtils.sessionTableRow(row, schema)),
-      Table.buildDataColumnMapFromSchema(sessionSchema)
-    );
-  }
-  createEmptySessionTable({ schema }, sessionTableName) {
-    const sessionSchema = sessionTableUtils.sessionTableSchema({
-      ...schema,
-      table: { ...schema.table, table: sessionTableName }
-    });
-    return new Table.Table(
-      sessionSchema,
-      [],
-      Table.buildDataColumnMapFromSchema(sessionSchema)
-    );
-  }
-  createSessionTableFromSelectedRows({ data, map, schema }, sessionTableName, dataSource) {
-    const selectedRowIds = dataSource.getSelectedRowIds();
-    const keyIndex = map[schema.key];
-    const sessionData = [];
-    for (let i = 0; i < selectedRowIds.length; i++) {
-      for (let j = 0; j < data.length; j++) {
-        if (data[j][keyIndex] === selectedRowIds[i]) {
-          sessionData.push(sessionTableUtils.sessionTableRow(data[j], schema));
-        }
-      }
-    }
-    const sessionSchema = sessionTableUtils.sessionTableSchema(schema);
-    return new Table.Table(
-      sessionSchema,
-      sessionData,
-      Table.buildDataColumnMapFromSchema(sessionSchema)
-    );
-  }
-}
-_name = new WeakMap();
-_sessionTableMessageColumn = new WeakMap();
-_runtimeVisualLinks = new WeakMap();
-_sessionSourceTableMap = new WeakMap();
-_sessionTableMap = new WeakMap();
-_tableServices = new WeakMap();
-_subscriptionMap = new WeakMap();
-_moduleServices = new WeakMap();
-_moduleMenuServices = new WeakMap();
-
-exports.VuuModule = VuuModule;
-//# sourceMappingURL=VuuModule.js.map