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

package/src/core/module/VuuModule.js

@@ -1,476 +0,0 @@
-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

@@ -1,97 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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 };