@vuu-ui/vuu-data-test 2.1.18 → 2.1.19-beta.1

package/cjs/core/module/VuuModule.js

@@ -1,660 +0,0 @@
-'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, _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) {
-    __privateAdd(this, _name);
-    __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 } = rpcRequest.params;
-        const sessionTable = this.getSessionTable(viewPortId, false);
-        if (sessionTable) {
-          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) {
-              table.delete(key);
-              return {
-                type: "SUCCESS_RESULT",
-                data: void 0
-              };
-            }
-          }
-        }
-      }
-      return {
-        type: "ERROR_RESULT",
-        errorMessage: "something went wrong"
-      };
-    });
-    __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 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,
-                // 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.vuuMsg] = 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["vuuMsg"];
-              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: "endEditSession",
-        service: this.endEditSession
-      },
-      {
-        rpcName: "editCell",
-        service: this.editCell
-      }
-    ]);
-    /**
-     * 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);
-    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();
-_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