@vuu-ui/vuu-data-test 2.1.19-beta.2 → 2.1.19-beta.3

package/cjs/core/module/VuuModule.js

@@ -0,0 +1,764 @@
+'use strict';
+
+var vuuUtils = require('@vuu-ui/vuu-utils');
+var Table = require('../../Table.js');
+var SessionTable = require('../../SessionTable.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, _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, _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),
+        sessionTables: __privateGet(this, _sessionTableMap),
+        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
+      };
+      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,
+              __privateGet(this, _sessionTableMessageColumn),
+              "SOFT_DELETED"
+            );
+          } 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 && SessionTable.isProxySessionTable(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,
+                  __privateGet(this, _sessionTableMessageColumn),
+                  "SOFT_DELETED"
+                );
+              } else {
+                sessionTable.delete(key);
+              }
+              deletedKeys.push(key);
+            }
+          }
+          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 && SessionTable.isProxySessionTable(sessionTable)) {
+          const { dataSource } = this.getSubscriptionByViewport(viewPortId);
+          const sourceTable = this.tables[dataSource.table?.table];
+          if (!sourceTable) {
+            return {
+              type: "ERROR_RESULT",
+              errorMessage: `undoRowChange: source table not found for viewport ${viewPortId}`
+            };
+          }
+          const sourceRow = sourceTable.findByKey(key);
+          if (!sourceRow) {
+            sessionTable.delete(key);
+            return { type: "SUCCESS_RESULT", data: { wasInsertedRow: true } };
+          }
+          const updates = sessionTable.getSessionUpdates();
+          const rowUpdates = updates.get(key);
+          if (rowUpdates) {
+            for (const column of Object.keys(rowUpdates.cellUpdates)) {
+              const originalValue = sourceRow[sourceTable.map[column]];
+              sessionTable.update(key, column, originalValue);
+            }
+            updates.delete(key);
+          }
+          return { type: "SUCCESS_RESULT", data: void 0 };
+        }
+        return {
+          type: "ERROR_RESULT",
+          errorMessage: `undoRowChange: no active proxy 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;
+        let targetTable = __privateGet(this, _sessionTableMap)[viewPortId];
+        if (!targetTable) {
+          const { dataSource } = this.getSubscriptionByViewport(viewPortId);
+          if (dataSource.table) {
+            targetTable = this.tables[dataSource.table.table];
+          }
+        }
+        if (targetTable) {
+          try {
+            assertUpdateIsValid(targetTable.schema, column, data);
+            targetTable.update(key, column, data);
+            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
+        };
+      }
+    });
+    __publicField(this, "beginEditSession", async (rpcRequest) => {
+      if (vuuUtils.isBeginEditSessionRpcRequest(rpcRequest)) {
+        const { viewPortId } = rpcRequest.context;
+        const { editSessionMode = "inline-all-rows" } = rpcRequest.params;
+        const longFormMode = vuuUtils.fromRpcEditSessionMode(
+          editSessionMode
+        );
+        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,
+                longFormMode,
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                dataSource
+              );
+              __privateGet(this, _sessionTableMap)[sessionTableName] = sessionTable;
+              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 sessionTable = subscription.sessionTableName ? __privateGet(this, _sessionTableMap)[subscription.sessionTableName] : void 0;
+        if (!sessionTable) {
+          return {
+            type: "ERROR_RESULT",
+            errorMessage: `addRow: no active session table for viewport ${viewPortId}`
+          };
+        }
+        const { data } = rpcRequest.params;
+        const columnMap = sessionTable.map;
+        const columnCount = Object.keys(columnMap).length;
+        const row = new Array(columnCount).fill("");
+        for (const [col, idx] of Object.entries(columnMap)) {
+          if (data[col] !== void 0) {
+            row[idx] = data[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 sourceTable = this.tables[dataSource.table.table];
+          if (rpcRequest.params.save === true) {
+            let rejectedCount = 0;
+            if (SessionTable.isProxySessionTable(sessionTable)) {
+              const updates = sessionTable.getSessionUpdates();
+              updates.forEach((rowUpdates, key) => {
+                const { cellUpdates, lastUpdateTimestamp } = rowUpdates;
+                const currentRow = sourceTable.findByKey(key);
+                const lastUpdateTimestampOnTable = currentRow[sourceTable.map.vuuUpdatedTimestamp];
+                if (lastUpdateTimestamp !== lastUpdateTimestampOnTable) {
+                  rejectedCount += 1;
+                  const sessionTableRow = sessionTable.findByKey(key);
+                  const newRow = sessionTableRow.slice();
+                  const messages = [];
+                  Object.entries(cellUpdates).forEach(([column, value]) => {
+                    messages.push(`${column}:${value}`);
+                  });
+                  newRow[sessionTable.map[__privateGet(this, _sessionTableMessageColumn)]] = messages.join(",");
+                  sessionTable.updateRow(newRow);
+                } else {
+                  const newRow = currentRow.slice();
+                  Object.entries(cellUpdates).forEach(([column, value]) => {
+                    newRow[sourceTable.map[column]] = value;
+                  });
+                  sourceTable.updateRow(newRow);
+                }
+              });
+              updates.clear();
+            } else {
+              const vuuMsgIdx = sessionTable.map[__privateGet(this, _sessionTableMessageColumn)];
+              const sourceColumns = sourceTable.schema.columns;
+              for (let i = 0; i < sessionTable.data.length; i++) {
+                const sessionRow = sessionTable.data[i];
+                if (sessionRow[vuuMsgIdx]) continue;
+                const sourceRow = sourceColumns.map(
+                  (col) => sessionRow[sessionTable.map[col.name]]
+                );
+                sourceTable.insert(sourceRow);
+              }
+            }
+            if (rejectedCount > 0) {
+              return {
+                errorMessage: "stale update",
+                type: "ERROR_RESULT"
+              };
+            } else {
+              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: "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 = "inline-all-rows", dataSource) {
+    if (editSessionMode.endsWith("all-rows")) {
+      return this.createSessionTableWithAllRows(sourceTable, sessionTableName);
+    } else if (editSessionMode === "selected-rows") {
+      return this.createSessionTableFromSelectedRows(
+        sourceTable,
+        sessionTableName,
+        dataSource
+      );
+    } else if (editSessionMode === "empty-session-table") {
+      return this.createEmptySessionTable(sourceTable, sessionTableName);
+    } else {
+      throw Error(
+        `[VuuModule] createSessionTable, invalid editSessionMode ${editSessionMode}`
+      );
+    }
+  }
+  createSessionTableWithAllRows(sourceTable, sessionTableName) {
+    return SessionTable.SessionTable(sourceTable, sessionTableName);
+  }
+  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(data[j]);
+        }
+      }
+    }
+    const sessionSchema = sessionTableUtils.sessionTableSchema(schema);
+    return new Table.Table(
+      sessionSchema,
+      sessionData,
+      Table.buildDataColumnMapFromSchema(sessionSchema)
+    );
+  }
+}
+_name = new WeakMap();
+_sessionTableMessageColumn = new WeakMap();
+_runtimeVisualLinks = new WeakMap();
+_sessionTableMap = new WeakMap();
+_tableServices = new WeakMap();
+_subscriptionMap = new WeakMap();
+_moduleServices = new WeakMap();
+_moduleMenuServices = new WeakMap();
+
+exports.VuuModule = VuuModule;
+//# sourceMappingURL=VuuModule.js.map