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

package/src/core/module/VuuModule.js

@@ -0,0 +1,635 @@
+import { isAddRowRpcRequest, isBeginEditSessionRpcRequest, isCreateSessionTableRpcRequest, isDeleteSelectedRowsRpcRequest, isEditCellRpcRequest, isEndEditSessionRpcRequest, isRpcSuccess, isUndoRowChangeRpcRequest, uuid } from "@vuu-ui/vuu-utils";
+import { Table, buildDataColumnMapFromSchema } from "../../Table.js";
+import { TickingArrayDataSource } from "../../TickingArrayDataSource.js";
+import { RuntimeVisualLink } from "../../RuntimeVisualLink.js";
+import ModuleContainer from "./ModuleContainer.js";
+import { sessionTableRow, sessionTableSchema } from "../../session-table-utils.js";
+const assertUpdateIsValid = (schema, column, _data)=>{
+    const col = schema.columns.find((col)=>col.name === column);
+    if (col) ;
+    else throw Error(`schema for table ${schema.table.table} does not include column ${column}`);
+};
+class VuuModule {
+    #name;
+    #sessionTableMessageColumn;
+    #runtimeVisualLinks = new Map();
+    #sessionSourceTableMap = {};
+    #sessionTableMap = {};
+    #tableServices;
+    #subscriptionMap = new Map();
+    constructor(name, { sessionTableMessageColumn = "vuuMsg" } = {}){
+        this.#name = name;
+        this.#sessionTableMessageColumn = sessionTableMessageColumn;
+        ModuleContainer.register(this);
+    }
+    getTableSchema(tableName) {
+        return this.schemas[tableName] ?? this.#sessionTableMap[tableName]?.schema;
+    }
+    getTableList() {
+        return Object.keys(this.tables);
+    }
+    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 this.#subscriptionMap.values())for (const { dataSource } of subscriptions)if (dataSource.tableSchema?.table.table === table) dataSource.links = this.getVisualLinks(table);
+                }
+            }
+        }
+    };
+    unregisterViewport = (viewportId)=>{
+        const { dataSource } = this.getSubscriptionByViewport(viewportId);
+        const tableName = dataSource.tableSchema?.table.table;
+        if (tableName) {
+            const subscriptionsForTable = this.#subscriptionMap.get(tableName);
+            if (subscriptionsForTable) {
+                for (const { viewportId: vp } of subscriptionsForTable)if (vp === viewportId) if (1 === subscriptionsForTable.length) this.#subscriptionMap.delete(tableName);
+                else this.#subscriptionMap.set(tableName, subscriptionsForTable.filter((s)=>s.viewportId !== viewportId));
+            }
+        }
+        for (const [tableName, subscriptions] of this.#subscriptionMap)if (subscriptions[0].viewportId.toString() === viewportId) this.#subscriptionMap.delete(tableName);
+        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 this.#subscriptionMap.values())for (const { dataSource } of subscriptions)if (dataSource.tableSchema?.table.table === table) dataSource.links = this.getVisualLinks(table);
+                }
+            }
+        }
+    };
+    get name() {
+        return this.#name;
+    }
+    getSubscriptionByViewport(viewportId) {
+        for (const subscriptions of 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 this.#subscriptionMap.values())for (const { viewportId, dataSource } of subscriptions)if (viewportId === vpId) return dataSource;
+        throw Error(`getSubscribedDataSource #${vpId} not in subscriptionMap`);
+    }
+    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 ("suspended" !== status) {
+                    const newLink = {
+                        parentClientVpId: viewportId,
+                        parentVpId: viewportId,
+                        link: vuuLinks[i]
+                    };
+                    visualLinks.push(newLink);
+                }
+            });
+        }
+        return visualLinks;
+    };
+    visualLinkService = (message)=>new Promise((resolve)=>{
+            if ("CREATE_VISUAL_LINK" === message.type) {
+                const { childColumnName, childVpId, parentColumnName, parentVpId } = message;
+                const childDataSource = this.getSubscribedDataSource(childVpId);
+                const parentDataSource = this.getSubscribedDataSource(parentVpId);
+                const runtimeVisualLink = new RuntimeVisualLink(childDataSource, parentDataSource, childColumnName, parentColumnName);
+                this.#runtimeVisualLinks.set(childVpId, runtimeVisualLink);
+                resolve({
+                    clientViewportId: childVpId,
+                    colName: childColumnName,
+                    parentColName: parentColumnName,
+                    parentViewportId: parentVpId,
+                    type: "vuu-link-created"
+                });
+            } else {
+                const runtimeVisualLink = this.#runtimeVisualLinks.get(message.childVpId);
+                if (runtimeVisualLink) {
+                    runtimeVisualLink.remove();
+                    this.#runtimeVisualLinks.delete(message.childVpId);
+                } else throw Error(`visualLinkService no visual link found for viewport #${message.childVpId}`);
+                resolve();
+            }
+        });
+    getVisualLinks = (tableName)=>{
+        const linksForTable = this.visualLinks?.[tableName];
+        return void 0 === linksForTable ? void 0 : this.getLinks(this.#subscriptionMap, linksForTable);
+    };
+    createDataSource = (tableName, viewport, config)=>{
+        const columnDescriptors = this.getColumnDescriptors(tableName);
+        const table = this.tables[tableName];
+        const sessionTable = this.#sessionTableMap[tableName];
+        const vuuModule = this;
+        const dataSource = new TickingArrayDataSource({
+            ...config,
+            columnDescriptors,
+            getVisualLinks: this.getVisualLinks,
+            keyColumn: void 0 === this.schemas[tableName] ? 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 = this.#subscriptionMap.get(tableName);
+        const subscription = {
+            viewportId: dataSource.viewport,
+            dataSource,
+            sessionTableName: sessionTable ? tableName : void 0,
+            sourceTableName: this.#sessionSourceTableMap[tableName]
+        };
+        if (existingSubscriptions) existingSubscriptions.push(subscription);
+        else this.#subscriptionMap.set(tableName, [
+            subscription
+        ]);
+        return dataSource;
+    };
+    getServices(tableName) {
+        const tableServices = this.services?.[tableName];
+        if (Array.isArray(tableServices)) return this.#moduleServices.concat(tableServices);
+        return this.#moduleServices;
+    }
+    getMenuServices(tableName) {
+        const tableServices = this.menuServices?.[tableName];
+        if (Array.isArray(tableServices)) return this.#moduleMenuServices.concat(tableServices);
+        return this.#moduleMenuServices;
+    }
+    get sessionTableMap() {
+        return this.#sessionTableMap;
+    }
+    getSessionTable(sessionTableName, throwIfNotFound = true) {
+        const sessionTable = this.#sessionTableMap[sessionTableName];
+        if (sessionTable) return sessionTable;
+        if (throwIfNotFound) throw Error(`getSessionTable: no session table with name ${sessionTableName}`);
+    }
+    deleteRow = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
+            const { viewPortId } = rpcRequest.context;
+            const { key, mode = "hard" } = rpcRequest.params;
+            const sessionTable = this.getSessionTable(viewPortId, false);
+            if (sessionTable) {
+                if ("soft" === mode) sessionTable.update(key, "vuu_action", "deleteRow");
+                else sessionTable.delete(key);
+                return {
+                    type: "SUCCESS_RESULT",
+                    data: void 0
+                };
+            }
+            {
+                const { dataSource } = this.getSubscriptionByViewport(viewPortId);
+                if (dataSource.table) {
+                    const table = this.tables[dataSource.table.table];
+                    if (table) {
+                        if ("soft" === mode) table.update(key, this.#sessionTableMessageColumn, "SOFT_DELETED");
+                        else table.delete(key);
+                        return {
+                            type: "SUCCESS_RESULT",
+                            data: void 0
+                        };
+                    }
+                }
+            }
+        }
+        return {
+            type: "ERROR_RESULT",
+            errorMessage: "something went wrong"
+        };
+    };
+    deleteSelectedRows = async (rpcRequest)=>{
+        if (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 ("soft" === mode) 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"
+        };
+    };
+    undoRowChange = async (rpcRequest)=>{
+        if (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 ("addRow" === action) {
+                    sessionTable.delete(key);
+                    return {
+                        type: "SUCCESS_RESULT",
+                        data: {
+                            wasInsertedRow: true
+                        }
+                    };
+                }
+                if ("deleteRow" === action || "editCell" === action) {
+                    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"
+        };
+    };
+    getColumnDescriptors(tableName) {
+        const schema = this.schemas[tableName] || this.getSessionTable(tableName)?.schema;
+        if (schema) return schema.columns;
+        throw Error(` no schema found for module ${this.#name} table ${tableName}`);
+    }
+    editCell = async (rpcRequest)=>{
+        if (isEditCellRpcRequest(rpcRequest)) {
+            const { viewPortId } = rpcRequest.context;
+            const { column, data, key } = rpcRequest.params;
+            const sessionTable = 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
+                };
+            }
+            throw Error("[VuuModule] editCell unable to find table for dataSource");
+        }
+        throw Error("[VuuModule] editCell invalid rpc type");
+    };
+    beginEditSessionMenuHandler = async ({ rpcName, type, vpId })=>{
+        if ("VIEW_PORT_MENUS_SELECT_RPC" !== type) return {
+            error: "no can do",
+            rpcName,
+            type: "VIEW_PORT_MENU_REJ",
+            vpId
+        };
+        {
+            const result = await this.beginEditSession({
+                context: {
+                    type: "VIEWPORT_CONTEXT",
+                    viewPortId: vpId
+                },
+                params: {
+                    editSessionMode: "selected-rows"
+                },
+                rpcName,
+                type: "RPC_REQUEST"
+            });
+            if (!isRpcSuccess(result)) return {
+                error: result.errorMessage,
+                rpcName,
+                type: "VIEW_PORT_MENU_REJ",
+                vpId
+            };
+            {
+                const { table } = result.data;
+                return {
+                    type: "VIEW_PORT_MENU_RESP",
+                    rpcName,
+                    action: {
+                        renderComponent: "grid",
+                        type: "OPEN_DIALOG_ACTION",
+                        table
+                    },
+                    vpId
+                };
+            }
+        }
+    };
+    createSessionTableService = async (rpcRequest)=>{
+        if (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-${uuid()}`;
+                    try {
+                        const sessionTable = this.createSessionTable(sourceTable, sessionTableName, copyOption, dataSource);
+                        this.#sessionTableMap[sessionTableName] = sessionTable;
+                        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"
+        };
+    };
+    beginEditSession = async (rpcRequest)=>{
+        if (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-${uuid()}`;
+                    try {
+                        const sessionTable = this.createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource);
+                        this.#sessionTableMap[sessionTableName] = sessionTable;
+                        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"
+        };
+    };
+    addRow = async (rpcRequest)=>{
+        if (isAddRowRpcRequest(rpcRequest)) {
+            const { viewPortId } = rpcRequest.context;
+            const subscription = this.getSubscriptionByViewport(viewPortId);
+            const sessionTableName = subscription.sessionTableName ?? viewPortId;
+            const sessionTable = 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] ?? 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 (void 0 !== rowData[col]) row[idx] = rowData[col];
+            sessionTable.insert(row);
+            return {
+                type: "SUCCESS_RESULT",
+                data: void 0
+            };
+        }
+        return {
+            type: "ERROR_RESULT",
+            errorMessage: "addRow: invalid rpc context"
+        };
+    };
+    endEditSession = async (rpcRequest)=>{
+        if (isEndEditSessionRpcRequest(rpcRequest)) {
+            const { viewPortId } = rpcRequest.context;
+            const subscription = this.getSubscriptionByViewport(viewPortId);
+            const sessionTableName = subscription.sessionTableName ?? viewPortId;
+            const sessionTable = this.#sessionTableMap[sessionTableName];
+            const { dataSource } = subscription;
+            if (dataSource.table) {
+                const sourceTableName = subscription.sourceTableName ?? dataSource.table.table;
+                const sourceTable = this.tables[sourceTableName];
+                if (true !== rpcRequest.params.save) return {
+                    type: "SUCCESS_RESULT",
+                    data: void 0
+                };
+                {
+                    let rejectedCount = 0;
+                    const vuuMsgIdx = sessionTable.map[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 ("deleteRow" === action) {
+                            if (currentRow) {
+                                const sessionTimestamp = sessionRow[sessionTimestampIdx];
+                                const sourceTimestamp = currentRow[sourceTimestampIdx];
+                                if ("number" == typeof sessionTimestamp && "number" == typeof sourceTimestamp && sourceTimestamp > sessionTimestamp) {
+                                    rejectedCount += 1;
+                                    sessionTable.update(key, this.#sessionTableMessageColumn, "stale delete");
+                                } else sourceTable.delete(key);
+                            }
+                            continue;
+                        }
+                        if (!sessionRow[vuuMsgIdx]) {
+                            if ("editCell" === action && 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 ("addRow" === action && !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
+                    };
+                }
+            }
+            throw Error("[VuuModule], exitEditMode");
+        }
+        throw Error("[VuuModule] endEditSession invalid rpc type");
+    };
+    applyBulkEdits = async (rpcRequest)=>{
+        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
+            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
+            };
+        }
+        throw Error("[VuuModule] applyBulkEdits invalid rpc type");
+    };
+    createSessionTable(sourceTable, sessionTableName, editSessionMode, dataSource) {
+        if ("All" === editSessionMode || editSessionMode.endsWith("all-rows")) return this.createSessionTableWithAllRows(sourceTable, sessionTableName);
+        if ("Selected" === editSessionMode || "selected-rows" === editSessionMode) return this.createSessionTableFromSelectedRows(sourceTable, sessionTableName, dataSource);
+        if ("Empty" === editSessionMode || "empty-session-table" === editSessionMode) return this.createEmptySessionTable(sourceTable, sessionTableName);
+        throw Error(`[VuuModule] createSessionTable, invalid editSessionMode ${editSessionMode}`);
+    }
+    createSessionTableWithAllRows({ data, schema }, _sessionTableName) {
+        const sessionSchema = sessionTableSchema(schema);
+        return new Table(sessionSchema, data.map((row)=>sessionTableRow(row, schema)), buildDataColumnMapFromSchema(sessionSchema));
+    }
+    createEmptySessionTable({ schema }, sessionTableName) {
+        const sessionSchema = sessionTableSchema({
+            ...schema,
+            table: {
+                ...schema.table,
+                table: sessionTableName
+            }
+        });
+        return new Table(sessionSchema, [], 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(sessionTableRow(data[j], schema));
+        const sessionSchema = sessionTableSchema(schema);
+        return new Table(sessionSchema, sessionData, buildDataColumnMapFromSchema(sessionSchema));
+    }
+    #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
+        }
+    ];
+    #moduleMenuServices = [
+        {
+            rpcName: "beginEditSession",
+            service: this.beginEditSessionMenuHandler
+        }
+    ];
+}
+export { VuuModule };