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

package/src/TickingArrayDataSource.js

@@ -1,208 +0,0 @@
-import { ArrayDataSource } from "@vuu-ui/vuu-data-local";
-import { isInlineEditingSession, isRpcSuccess, isTypeaheadRequest } from "@vuu-ui/vuu-utils";
-import { makeSuggestions } from "./makeSuggestions.js";
-class TickingArrayDataSource extends ArrayDataSource {
-    #menuRpcServices;
-    #pendingVisualLink;
-    #rpcMenuServices;
-    #rpcServices;
-    #sessionTables;
-    #sessionDataSource = void 0;
-    #table;
-    #selectionLinkSubscribers;
-    #visualLinkService;
-    #getVisualLinks;
-    #vuuModule;
-    constructor({ data, getVisualLinks, rpcServices, rpcMenuServices, sessionTables, table, menu, visualLink, visualLinkService, vuuModule, ...arrayDataSourceProps }){
-        if (void 0 === data && void 0 === table) throw Error("TickingArrayDataSource must be constructed with data");
-        super({
-            ...arrayDataSourceProps,
-            data: data ?? table?.data ?? [],
-            dataMap: table?.map
-        });
-        this._menu = menu;
-        this.#rpcMenuServices = rpcMenuServices;
-        this.#pendingVisualLink = visualLink;
-        this.#rpcServices = rpcServices;
-        this.#sessionTables = sessionTables;
-        this.#table = table;
-        this.#visualLinkService = visualLinkService;
-        this.#getVisualLinks = getVisualLinks;
-        this.#vuuModule = vuuModule;
-        if (table) {
-            this.tableSchema = table.schema;
-            table.on("insert", this.insert);
-            table.on("update", this.updateRowWithSessionCheck);
-            table.on("delete", this.deleteRow);
-        }
-    }
-    updateRowWithSessionCheck = (row, columnName, sessionId)=>{
-        if (sessionId && sessionId === this.viewport) this.updateRow(row, columnName);
-        else if (sessionId) console.warn("THIS IS NEVER EXPECTED TO HAPPEN");
-        else this.#sessionDataSource || this.updateRow(row, columnName);
-    };
-    async subscribe(subscribeProps, callback) {
-        const subscription = super.subscribe(subscribeProps, callback);
-        if (this.#pendingVisualLink) {
-            this.visualLink = this.#pendingVisualLink;
-            this.#pendingVisualLink = void 0;
-        }
-        return subscription;
-    }
-    unsubscribe() {
-        super.unsubscribe();
-        this.#table = void 0;
-    }
-    set range(range) {
-        super.range = range;
-    }
-    get range() {
-        return super.range;
-    }
-    set links(links) {
-        super.links = links;
-    }
-    get links() {
-        return this.#getVisualLinks?.(this.table.table);
-    }
-    getSelectedRowIds() {
-        return Array.from(this.selectedRows);
-    }
-    handleSessionMessage = (msg)=>{
-        if ("subscribed" === msg.type) ;
-        else if ("viewport-update" === msg.type) {
-            if (void 0 !== msg.size && msg.size !== this.size) this.emit("resize", msg.size);
-            this.clientCallback?.(msg);
-        }
-    };
-    createSessionDataSource(sessionTable) {
-        if (this.#vuuModule) return this.#vuuModule?.createDataSource(sessionTable.table, sessionTable.table);
-        throw Error("[TickingArrayDataSource] unable to createSessionDataSource, not constructed with VuuModule");
-    }
-    async beginEditSession(editSessionMode = "inline-all-rows") {
-        const rpcResponse = await this?.rpcRequest?.({
-            type: "RPC_REQUEST",
-            rpcName: "beginEditSession",
-            params: {
-                editSessionMode
-            }
-        });
-        if (isRpcSuccess(rpcResponse)) {
-            const { table: sessionTable } = rpcResponse.data;
-            if (!isInlineEditingSession(editSessionMode)) return this.#vuuModule?.createDataSource(sessionTable.table, sessionTable.table, this.config);
-            this.#sessionDataSource = this.#vuuModule?.createDataSource(sessionTable.table, sessionTable.table, this.config);
-            this.#sessionDataSource?.subscribe({
-                range: this.range
-            }, this.handleSessionMessage);
-        } else throw Error(`[VuuDataSource] beginEditSession ${rpcResponse.errorMessage}`);
-    }
-    async editCell(key, column, data) {
-        console.log(`[VuuDataSource] editCell ${this.#sessionDataSource?.viewport} rowKey ${key}, column ${column}, value ${data}`);
-        const rpcHost = this.#sessionDataSource ?? this;
-        return rpcHost.rpcRequest?.({
-            type: "RPC_REQUEST",
-            rpcName: "editCell",
-            params: {
-                column,
-                data,
-                key
-            }
-        });
-    }
-    async endEditSession(saveChanges = false) {
-        const type = "RPC_REQUEST";
-        const rpcName = "endEditSession";
-        const sessionDataSource = this.#sessionDataSource;
-        const rpcHost = sessionDataSource ?? this;
-        if (sessionDataSource) this.#sessionDataSource = void 0;
-        const rpcResponse = await rpcHost.rpcRequest?.(saveChanges ? {
-            type,
-            rpcName,
-            params: {
-                save: true
-            }
-        } : {
-            type,
-            rpcName,
-            params: {}
-        });
-        if (isRpcSuccess(rpcResponse)) {
-            sessionDataSource?.unsubscribe();
-            this.sendRowsToClient(true);
-        } else if (rpcResponse?.errorMessage === "stale update") {
-            sessionDataSource?.unsubscribe();
-            this.sendRowsToClient(true);
-        } else throw Error("unknown error");
-    }
-    async rpcRequest(rpcRequest) {
-        if (isTypeaheadRequest(rpcRequest)) {
-            const { params: { column, starts } } = rpcRequest;
-            const data = await this.getTypeaheadSuggestions(column, starts);
-            return {
-                type: "SUCCESS_RESULT",
-                data
-            };
-        }
-        {
-            const rpcService = this.#rpcServices?.find((service)=>service.rpcName === rpcRequest.rpcName);
-            if (rpcService) return rpcService.service({
-                ...rpcRequest,
-                context: {
-                    type: "VIEWPORT_CONTEXT",
-                    viewPortId: this.viewport
-                }
-            });
-            throw Error(`[TickingArrayDataSource] no service to handle RPC request ${rpcRequest.rpcName}`);
-        }
-    }
-    async menuRpcCall(rpcRequest) {
-        const rpcService = this.#rpcMenuServices?.find((service)=>service.rpcName === rpcRequest.rpcName);
-        if (rpcService) return rpcService.service({
-            ...rpcRequest,
-            vpId: this.viewport
-        });
-        throw Error(`[TickingArrayDataSource] menuRpcCall no service for ${rpcRequest.rpcName}`);
-    }
-    getTypeaheadSuggestions(column, pattern) {
-        if (this.#table) {
-            const columnIndex = this.columnMap[column];
-            if (void 0 !== columnIndex) return makeSuggestions(this.currentData, columnIndex, pattern);
-            console.warn(`[TickingArrayDataSource] getTypeaheadSuggestions. No column ${column}`);
-            return Promise.resolve([]);
-        }
-        throw Error("cannot call getTypeaheadSuggestions on TickingDataSource if table has not been provided");
-    }
-    get visualLink() {
-        return this._config.visualLink;
-    }
-    set visualLink(visualLink) {
-        this._config = {
-            ...this._config,
-            visualLink
-        };
-        if (visualLink) {
-            const { parentClientVpId, link: { fromColumn, toColumn } } = visualLink;
-            if (this.viewport) this.#visualLinkService?.({
-                childVpId: this.viewport,
-                childColumnName: fromColumn,
-                type: "CREATE_VISUAL_LINK",
-                parentVpId: parentClientVpId,
-                parentColumnName: toColumn
-            }).then((response)=>{
-                this.emit("visual-link-created", response);
-            });
-        } else this.#visualLinkService?.({
-            childVpId: this.viewport,
-            type: "REMOVE_VISUAL_LINK"
-        }).then(()=>{
-            this.emit("visual-link-removed");
-        });
-    }
-    freeze() {
-        super.freeze();
-    }
-    unfreeze() {
-        super.unfreeze();
-    }
-}
-export { TickingArrayDataSource };

package/src/UpdateGenerator.js

@@ -1,72 +0,0 @@
-import { generateNextBidAsk, nextRandomDouble, random } from "./data-utils.js";
-const getNewValue = (value)=>{
-    const multiplier = random(0, 100) / 1000;
-    const direction = random(0, 10) >= 5 ? 1 : -1;
-    return value + value * multiplier * direction;
-};
-class BaseUpdateGenerator {
-    table;
-    range;
-    updating = false;
-    timer;
-    tickingColumns;
-    constructor(tickingColumns){
-        this.tickingColumns = tickingColumns;
-    }
-    setRange(range) {
-        this.range = range;
-        if (!this.updating && this.table) this.startUpdating();
-    }
-    setTable(table) {
-        this.table = table;
-    }
-    startUpdating() {
-        this.updating = true;
-        this.update();
-    }
-    stopUpdating() {
-        this.updating = false;
-        if (this.timer) {
-            window.clearTimeout(this.timer);
-            this.timer = void 0;
-        }
-    }
-    update = ()=>{
-        if (this.range && this.table) {
-            const data = this.table?.data;
-            const { bid, ask, last, ...rest } = this.tickingColumns;
-            if (data && data?.length > 0) {
-                const maxRange = Math.min(this.range.to, data.length);
-                for(let rowIndex = this.range.from; rowIndex < maxRange; rowIndex++){
-                    let updateCount = 0;
-                    const shallUpdateRow = random(0, 10) < 2;
-                    if (shallUpdateRow) {
-                        const rowUpdates = this.table.data[rowIndex];
-                        const row = data[rowIndex];
-                        if (void 0 !== bid && void 0 !== ask) {
-                            const { [bid]: currentBid, [ask]: currentAsk } = row;
-                            const [newBid, newAsk] = generateNextBidAsk(currentBid, currentAsk, 10, 5, nextRandomDouble);
-                            rowUpdates[ask] = newAsk;
-                            rowUpdates[bid] = newBid;
-                            if (void 0 !== last) {
-                                const newLast = Math.round((currentAsk + (newAsk - currentAsk) / 2) * 100) / 100.0;
-                                rowUpdates[last] = newLast;
-                            }
-                        }
-                        for (const colIdx of Object.values(rest)){
-                            const shallUpdateColumn = random(0, 10) < 5;
-                            if (shallUpdateColumn) {
-                                updateCount += 1;
-                                const newValue = getNewValue(row[colIdx]);
-                                if (this.table) rowUpdates[colIdx] = newValue;
-                            }
-                        }
-                        if (this.table && updateCount > 0) this.table.updateRow(rowUpdates);
-                    }
-                }
-            }
-        }
-        if (this.updating) this.timer = window.setTimeout(this.update, 500);
-    };
-}
-export { BaseUpdateGenerator };

package/src/basket/BasketModule.js

@@ -1,272 +0,0 @@
-import { VuuModule } from "../core/module/VuuModule.js";
-import TableContainer from "../core/table/TableContainer.js";
-import { schemas } from "./basket-schemas.js";
-import reference_data_constituents from "./reference-data/constituents.js";
-const { createTable: createTable } = TableContainer;
-let basketIncrement = 1;
-const createBasketTradingRow = (basketId, basketName, side = "BUY", status = "OFF MARKET")=>[
-        basketId,
-        basketName,
-        0,
-        1.25,
-        `steve-${basketIncrement++}`,
-        side,
-        status,
-        1000000,
-        1250000,
-        100
-    ];
-const undefinedTables = {
-    algoType: void 0,
-    basket: void 0,
-    basketTrading: void 0,
-    basketTradingConstituent: void 0,
-    basketConstituent: void 0,
-    basketTradingConstituentJoin: void 0,
-    priceStrategyType: void 0
-};
-const buildDataColumnMap = (tableName)=>Object.values(schemas[tableName].columns).reduce((map, col, index)=>{
-        map[col.name] = index;
-        return map;
-    }, {});
-const tableMaps = {
-    algoType: buildDataColumnMap("algoType"),
-    basket: buildDataColumnMap("basket"),
-    basketTrading: buildDataColumnMap("basketTrading"),
-    basketTradingConstituent: buildDataColumnMap("basketTradingConstituent"),
-    basketConstituent: buildDataColumnMap("basketConstituent"),
-    basketTradingConstituentJoin: buildDataColumnMap("basketTradingConstituentJoin"),
-    priceStrategyType: buildDataColumnMap("priceStrategyType")
-};
-const basketTradingConstituent = TableContainer.createTable(schemas.basketTradingConstituent, [], tableMaps.basketTradingConstituent);
-class BasketModule extends VuuModule {
-    #tables = {
-        algoType: createTable(schemas.algoType, [
-            [
-                "Sniper",
-                0
-            ],
-            [
-                "Dark Liquidity",
-                1
-            ],
-            [
-                "VWAP",
-                2
-            ],
-            [
-                "POV",
-                3
-            ],
-            [
-                "Dynamic Close",
-                4
-            ]
-        ], tableMaps.algoType),
-        basket: createTable(schemas.basket, [
-            [
-                ".NASDAQ100",
-                ".NASDAQ100",
-                0,
-                0
-            ],
-            [
-                ".HSI",
-                ".HSI",
-                0,
-                0
-            ],
-            [
-                ".FTSE100",
-                ".FTSE100",
-                0,
-                0
-            ],
-            [
-                ".SP500",
-                ".SP500",
-                0,
-                0
-            ]
-        ], tableMaps.basket),
-        basketConstituent: createTable(schemas.basketConstituent, reference_data_constituents, tableMaps.basketConstituent),
-        basketTrading: createTable(schemas.basketTrading, [], tableMaps.basketTrading),
-        basketTradingConstituent: basketTradingConstituent,
-        basketTradingConstituentJoin: TableContainer.createJoinTable({
-            module: "BASKET",
-            table: "basketTradingConstituentJoin"
-        }, {
-            module: "BASKET",
-            table: "basketTradingConstituent"
-        }, {
-            module: "SIMUL",
-            table: "prices"
-        }, "ric"),
-        priceStrategyType: createTable(schemas.priceStrategyType, [
-            [
-                "Peg to Near Touch",
-                0
-            ],
-            [
-                "Far Touch",
-                1
-            ],
-            [
-                "Limit",
-                2
-            ],
-            [
-                "Algo",
-                3
-            ]
-        ], tableMaps.priceStrategyType)
-    };
-    constructor(){
-        super("BASKET");
-    }
-    get menus() {
-        return {
-            ...undefinedTables,
-            basket: {
-                name: "ROOT",
-                menus: [
-                    {
-                        context: "selected-rows",
-                        filter: "",
-                        name: "Add Basket",
-                        rpcName: "CREATE_NEW_BASKET"
-                    }
-                ]
-            }
-        };
-    }
-    get schemas() {
-        return schemas;
-    }
-    get services() {
-        return {
-            ...undefinedTables,
-            basket: [
-                {
-                    rpcName: "createBasket",
-                    service: this.createNewBasket
-                }
-            ],
-            basketTrading: [
-                {
-                    rpcName: "sendToMarket",
-                    service: this.sendToMarket
-                },
-                {
-                    rpcName: "takeOffMarket",
-                    service: this.takeOffMarket
-                }
-            ],
-            basketTradingConstituentJoin: [
-                {
-                    rpcName: "addConstituent",
-                    service: this.addConstituent
-                }
-            ]
-        };
-    }
-    get menuServices() {
-        return {
-            ...undefinedTables
-        };
-    }
-    get tables() {
-        return this.#tables;
-    }
-    get visualLinks() {
-        return {
-            ...undefinedTables,
-            basketConstituent: [
-                {
-                    fromColumn: "basketId",
-                    toColumn: "id",
-                    toTable: "basket"
-                }
-            ]
-        };
-    }
-    createTradingBasket(basketId, basketName) {
-        const basketTradingRow = createBasketTradingRow(basketId, basketName);
-        this.tables.basketTrading.insert(basketTradingRow);
-        const { basketId: key } = buildDataColumnMap("basketConstituent");
-        const constituents = this.tables.basketConstituent.data.filter((c)=>c[key] === basketId);
-        const { instanceId } = tableMaps.basketTrading;
-        constituents.forEach(([, , description, , ric, , , quantity, weighting])=>{
-            const algo = "";
-            const algoParams = "";
-            const limitPrice = 95;
-            const notionalLocal = 0;
-            const notionalUsd = 0;
-            const pctFilled = 0;
-            const priceSpread = 0;
-            const priceStrategyId = "";
-            const side = "BUY";
-            const venue = "venue";
-            const basketInstanceId = basketTradingRow[instanceId];
-            const basketTradingConstituentRow = [
-                algo,
-                algoParams,
-                basketId,
-                description,
-                basketInstanceId,
-                `${basketInstanceId}-${ric}`,
-                limitPrice,
-                notionalLocal,
-                notionalUsd,
-                pctFilled,
-                priceSpread,
-                priceStrategyId,
-                quantity,
-                ric,
-                side,
-                venue,
-                weighting
-            ];
-            basketTradingConstituent.insert(basketTradingConstituentRow);
-        });
-        return basketTradingRow[instanceId];
-    }
-    createNewBasket = async (rpcRequest)=>{
-        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
-            const { sourceBasketId, tradeBasketName } = rpcRequest.params;
-            const key = this.createTradingBasket(sourceBasketId, tradeBasketName);
-            return {
-                type: "SUCCESS_RESULT",
-                data: key
-            };
-        }
-        throw Error("[BasketModule] createNewBasket invalid request type");
-    };
-    sendToMarket = async (rpcRequest)=>{
-        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
-            const { basketInstanceId } = rpcRequest.params;
-            this.tables.basketTrading.update(basketInstanceId, "status", "ON_MARKET");
-            return {
-                type: "SUCCESS_RESULT",
-                data: void 0
-            };
-        }
-        throw Error("[BasketModule] createNewBasket invalid request type");
-    };
-    takeOffMarket = async (rpcRequest)=>{
-        if ("VIEWPORT_CONTEXT" === rpcRequest.context.type) {
-            const { basketInstanceId } = rpcRequest.params;
-            this.tables.basketTrading.update(basketInstanceId, "status", "OFF-MARKET");
-            return {
-                type: "SUCCESS_RESULT",
-                data: void 0
-            };
-        }
-        throw Error("[BasketModule] createNewBasket invalid request type");
-    };
-    addConstituent = async ()=>{
-        throw Error("addConstituent not implemented");
-    };
-}
-const basketModule = new BasketModule();
-export { BasketModule, basketModule, createBasketTradingRow };