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

package/src/core/module/VuuModule.js

@@ -0,0 +1,476 @@
+import { isAddRowRpcRequest, isBeginEditSessionRpcRequest, isEditCellRpcRequest, isEndEditSessionRpcRequest, isRpcSuccess, uuid } from "@vuu-ui/vuu-utils";
+import { Table, buildDataColumnMapFromSchema } from "../../Table.js";
+import { SessionTable, isProxySessionTable } from "../../SessionTable.js";
+import { TickingArrayDataSource } from "../../TickingArrayDataSource.js";
+import { RuntimeVisualLink } from "../../RuntimeVisualLink.js";
+import ModuleContainer from "./ModuleContainer.js";
+import { sessionTableSchema } from "../../session-table-utils.js";
+const assertUpdateIsValid = (schema, column, data)=>{
+    const col = schema.columns.find((col)=>col.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 {
+    #name;
+    #runtimeVisualLinks = new Map();
+    #sessionTableMap = {};
+    #tableServices;
+    #subscriptionMap = new Map();
+    constructor(name){
+        this.#name = name;
+        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),
+            sessionTables: this.#sessionTableMap,
+            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
+        };
+        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 } = rpcRequest.params;
+            const sessionTable = this.getSessionTable(viewPortId, false);
+            if (sessionTable) {
+                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) {
+                        table.delete(key);
+                        return {
+                            type: "SUCCESS_RESULT",
+                            data: void 0
+                        };
+                    }
+                }
+            }
+        }
+        return {
+            type: "ERROR_RESULT",
+            errorMessage: "something went wrong"
+        };
+    };
+    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;
+            let targetTable = 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
+                };
+            }
+            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
+        };
+        {
+            console.log(`rpcName ${rpcName}`);
+            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
+                };
+            }
+        }
+    };
+    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;
+                        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 sessionTable = subscription.sessionTableName ? 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 (void 0 !== data[col]) row[idx] = data[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 sourceTable = this.tables[dataSource.table.table];
+                if (true !== rpcRequest.params.save) return {
+                    type: "SUCCESS_RESULT",
+                    data: void 0
+                };
+                {
+                    let rejectedCount = 0;
+                    if (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"
+                    };
+                    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 = "inline-all-rows", dataSource) {
+        if (editSessionMode.endsWith("all-rows")) return this.createSessionTableWithAllRows(sourceTable, sessionTableName);
+        if ("selected-rows" === editSessionMode) return this.createSessionTableFromSelectedRows(sourceTable, sessionTableName, dataSource);
+        if ("empty-session-table" === editSessionMode) return this.createEmptySessionTable(sourceTable, sessionTableName);
+        throw Error(`[VuuModule] createSessionTable, invalid editSessionMode ${editSessionMode}`);
+    }
+    createSessionTableWithAllRows(sourceTable, sessionTableName) {
+        return SessionTable(sourceTable, sessionTableName);
+    }
+    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(data[j]);
+        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: "beginEditSession",
+            service: this.beginEditSession
+        },
+        {
+            rpcName: "endEditSession",
+            service: this.endEditSession
+        },
+        {
+            rpcName: "editCell",
+            service: this.editCell
+        }
+    ];
+    #moduleMenuServices = [
+        {
+            rpcName: "beginEditSession",
+            service: this.beginEditSessionMenuHandler
+        }
+    ];
+}
+export { VuuModule };

package/src/core/table/TableContainer.js

@@ -0,0 +1,97 @@
+import { Table, buildDataColumnMapFromSchema } from "../../Table.js";
+class TableContainer {
+    static #instance;
+    static get instance() {
+        if (!TableContainer.#instance) TableContainer.#instance = new TableContainer();
+        return TableContainer.#instance;
+    }
+    #tables = new Map();
+    createTable = (schema, data, dataMap, updateGenerator)=>{
+        const table = new Table(schema, data, dataMap, updateGenerator);
+        this.addTable(table);
+        return table;
+    };
+    createJoinTable(joinTable, { table: t1 }, { table: t2 }, joinColumn) {
+        const table1 = this.getTable(t1);
+        const table2 = this.getTable(t2);
+        const { map: m1, schema: schema1 } = table1;
+        const { map: m2, schema: schema2 } = table2;
+        const k1 = m1[joinColumn];
+        const k2 = m2[joinColumn];
+        const combinedColumns = new Set([
+            ...schema1.columns,
+            ...schema2.columns
+        ].map((col)=>col.name).sort());
+        const combinedSchema = {
+            key: joinColumn,
+            table: joinTable,
+            columns: Array.from(combinedColumns).map((columnName)=>({
+                    name: columnName,
+                    serverDataType: getServerDataType(columnName, schema1, schema2)
+                }))
+        };
+        const data = [];
+        const combinedColumnMap = buildDataColumnMapFromSchema(combinedSchema);
+        for (const row of table1.data){
+            const row2 = table2.findByKey(String(row[k1]));
+            if (row2) {
+                const out = [];
+                for (const column of table1.schema.columns){
+                    const value = row[m1[column.name]];
+                    out[combinedColumnMap[column.name]] = value;
+                }
+                for (const column of table2.schema.columns){
+                    const value = row2[m2[column.name]];
+                    out[combinedColumnMap[column.name]] = value;
+                }
+                data.push(out);
+            }
+        }
+        const newTable = new Table(combinedSchema, data, combinedColumnMap);
+        table1.on("insert", (row)=>{
+            const row2 = table2.findByKey(String(row[k1]));
+            if (row2) {
+                const out = [];
+                for (const column of table1.schema.columns){
+                    const value = row[m1[column.name]];
+                    out[combinedColumnMap[column.name]] = value;
+                }
+                for (const column of table2.schema.columns){
+                    const value = row2[m2[column.name]];
+                    out[combinedColumnMap[column.name]] = value;
+                }
+                newTable.insert(out);
+            }
+        });
+        table2.on("update", (row)=>{
+            const keyValue = row[k2];
+            const targetRow = newTable.findByKey(keyValue);
+            if (targetRow) {
+                const updatedRow = targetRow.slice();
+                for (const { name } of table2.schema.columns)if (row[m2[name]] !== updatedRow[combinedColumnMap[name]]) updatedRow[combinedColumnMap[name]] = row[m2[name]];
+                newTable.updateRow(updatedRow);
+            }
+        });
+        this.addTable(newTable);
+        return newTable;
+    }
+    addTable(table) {
+        this.#tables.set(table.name, table);
+    }
+    getTable(tableName) {
+        const table = this.#tables.get(tableName);
+        if (table) return table;
+        throw Error(`[TableContainer] no table ${tableName}`);
+    }
+}
+var table_TableContainer = TableContainer.instance;
+const getServerDataType = (columnName, { columns: cols1, table: t1 }, { columns: cols2, table: t2 })=>{
+    const col1 = cols1.find((col)=>col.name === columnName);
+    const col2 = cols2.find((col)=>col.name === columnName);
+    if (col1 && col2) if (col1.serverDataType === col2.serverDataType) return col1.serverDataType;
+    else throw Error(`both tables ${t1.table} and ${t2.table} implement column ${columnName}, but with types differ`);
+    if (col1) return col1.serverDataType;
+    if (col2) return col2.serverDataType;
+    throw Error("how is this possible");
+};
+export default table_TableContainer;

package/src/data-utils.js

@@ -0,0 +1,53 @@
+function random(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function randomPercentage(value) {
+    const dec = random(2, 99);
+    const percentage = dec / 100;
+    return value * percentage;
+}
+const data_utils_nextRandomDouble = (min, max)=>min + (max - min) * Math.random();
+const initBidAsk = (priceMaxDelta, nextRandomDouble)=>{
+    const mid = nextRandomDouble(0, 1000);
+    const tempBid = nextRandomDouble(mid - priceMaxDelta, mid - 1);
+    const ask = nextRandomDouble(mid + 1, mid + priceMaxDelta);
+    const bid = tempBid < 0 ? mid : tempBid;
+    const newBid = Math.round(100 * bid) / 100.0;
+    const newAsk = Math.round(100 * ask) / 100.0;
+    return [
+        newBid,
+        newAsk
+    ];
+};
+const maxAsk = (bid, ask, spreadMultipler, priceMaxDelta)=>{
+    const spread = ask - bid;
+    return Math.min(ask + spreadMultipler * spread, spread / 2 + bid + priceMaxDelta);
+};
+const minAsk = (bid, ask)=>Math.max(bid + 1, (ask - bid) / 2 + bid);
+const maxBid = (bid, ask)=>{
+    const result = Math.min(ask - 1, (ask - bid) / 2 + bid);
+    return result < 1 ? bid + 1 : result;
+};
+const minBid = (bid, ask, spreadMultipler, priceMaxDelta)=>{
+    const spread = ask - bid;
+    const mid = spread / 2 + bid;
+    const result = Math.max(bid - Math.min(spreadMultipler * spread, 10), mid - priceMaxDelta);
+    return result < 0 ? bid : result;
+};
+const generateNextBidAsk = (bid, ask, spreadMultipler, priceMaxDelta, nextRandomDouble)=>{
+    let tempAsk = ask;
+    if (Math.abs(bid - ask) <= 1) tempAsk = ask + 1;
+    const minBidValue = minBid(bid, tempAsk, spreadMultipler, priceMaxDelta);
+    const maxBidValue = maxBid(bid, tempAsk);
+    const minAskValue = minAsk(bid, tempAsk);
+    const maxAskValue = maxAsk(bid, tempAsk, spreadMultipler, priceMaxDelta);
+    const newBid = Math.round(100 * nextRandomDouble(minBidValue, maxBidValue)) / 100.0;
+    const newAsk = Math.round(100 * nextRandomDouble(minAskValue, maxAskValue)) / 100.0;
+    return [
+        newBid,
+        newAsk
+    ];
+};
+export { data_utils_nextRandomDouble as nextRandomDouble, generateNextBidAsk, initBidAsk, random, randomPercentage };

package/src/index.js

@@ -0,0 +1,13 @@
+export * from "./ArrayProxy.js";
+export * from "./core/module/VuuModule.js";
+export * from "./local-datasource-provider/LocalDatasourceProvider.js";
+export * from "./makeSuggestions.js";
+export * from "./schemas.js";
+export * from "./simul/index.js";
+export * from "./basket/index.js";
+export * from "./test/index.js";
+export * from "./TickingArrayDataSource.js";
+export * from "./vuu-row-generator.js";
+export { default as tableContainer } from "./core/table/TableContainer.js";
+export { SessionTable } from "./SessionTable.js";
+export { Table, buildDataColumnMap, buildDataColumnMapFromSchema } from "./Table.js";

package/src/local-datasource-provider/LocalDatasourceProvider.js

@@ -0,0 +1,44 @@
+import { jsx } from "react/jsx-runtime";
+import { DataProvider } from "@vuu-ui/vuu-utils";
+import ModuleContainer from "../core/module/ModuleContainer.js";
+import TableContainer from "../core/table/TableContainer.js";
+const serverAPI = {
+    getTableList: async ()=>{
+        const tables = ModuleContainer.moduleNames.reduce((tableList, moduleName)=>{
+            const moduleTables = ModuleContainer.get(moduleName).getTableList();
+            moduleTables.forEach((tableName)=>{
+                const table = TableContainer.getTable(tableName);
+                tableList.push(table.schema.table);
+            });
+            return tableList;
+        }, []);
+        return {
+            tables
+        };
+    },
+    getTableSchema: async ({ module, table })=>ModuleContainer.get(module).getTableSchema(table),
+    rpcCall: async ()=>{
+        throw Error("RpcCall no longer supported on LocalDataSOurceProvider ServerAPI");
+    }
+};
+const getServerAPI = async ()=>serverAPI;
+class VuuDataSource {
+    constructor({ aggregations, columns, filterSpec, groupBy, sort, table, viewport, visualLink }){
+        const config = {
+            aggregations,
+            columns,
+            filterSpec,
+            groupBy,
+            sort,
+            visualLink
+        };
+        const module = ModuleContainer.get(table.module);
+        return module.createDataSource(table.table, viewport, config);
+    }
+}
+const LocalDataSourceProvider = ({ children })=>/*#__PURE__*/ jsx(DataProvider, {
+        VuuDataSource: VuuDataSource,
+        getServerAPI: getServerAPI,
+        children: children
+    });
+export { LocalDataSourceProvider };