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

package/src/makeSuggestions.js

@@ -0,0 +1,20 @@
+const checkPattern = (value, pattern)=>new RegExp(`^${pattern}`, "i").test(value);
+const getUniqueValues = (data, columnIndex, pattern = "")=>{
+    const uniqueValues = [];
+    const set = new Set();
+    for (const row of data){
+        const value = row[columnIndex];
+        if (void 0 !== value && !set.has(value)) {
+            set.add(value);
+            uniqueValues.push(value);
+        }
+    }
+    uniqueValues.sort();
+    return pattern ? uniqueValues.filter((value)=>checkPattern(value.toString(), pattern)).slice(0, 10) : uniqueValues.slice(0, 10);
+};
+const makeSuggestions = (data, columnIndex, pattern)=>new Promise((resolve)=>{
+        const uniqueValues = getUniqueValues(data, columnIndex, pattern);
+        const result = uniqueValues.length > 20 ? uniqueValues?.slice(0, 20).map((v)=>v.toString()) : uniqueValues.map((v)=>v.toString());
+        setTimeout(()=>resolve(result), 100);
+    });
+export { makeSuggestions };

package/src/schemas.js

@@ -0,0 +1,19 @@
+import { schemas } from "./basket/basket-schemas.js";
+import { schemas as simul_schemas_js_schemas } from "./simul/simul-schemas.js";
+import { schemas as test_schemas_js_schemas } from "./test/test-schemas.js";
+const schemas_schemas = {
+    ...schemas,
+    ...simul_schemas_js_schemas,
+    ...test_schemas_js_schemas
+};
+const allSchemas = {
+    ...schemas,
+    ...simul_schemas_js_schemas,
+    ...test_schemas_js_schemas
+};
+const getAllSchemas = ()=>schemas_schemas;
+const getSchema = (tableName)=>{
+    if (allSchemas[tableName]) return allSchemas[tableName];
+    throw Error(`getSchema no schema for table ${tableName}`);
+};
+export { getAllSchemas, getSchema, schemas_schemas as schemas };

package/src/session-table-utils.js

@@ -0,0 +1,16 @@
+import { Table, buildDataColumnMapFromSchema } from "./Table.js";
+import { metadataKeys } from "@vuu-ui/vuu-utils";
+const { KEY: KEY } = metadataKeys;
+const createSessionTableFromSelectedRows = (table, selectedRowIds)=>{
+    const sessionData = [];
+    for(let i = 0; i < selectedRowIds.length; i++)for(let j = 0; j < table.data.length; j++)if (table.data[j][KEY] === selectedRowIds[i]) sessionData.push(table.data[j]);
+    return new Table(table.schema, sessionData, buildDataColumnMapFromSchema(table.schema));
+};
+const sessionTableSchema = (schema)=>({
+        ...schema,
+        columns: schema.columns.concat({
+            name: "vuuMsg",
+            serverDataType: "string"
+        })
+    });
+export { createSessionTableFromSelectedRows, sessionTableSchema };

package/src/simul/SimulModule.js

@@ -0,0 +1,175 @@
+import { VuuModule } from "../core/module/VuuModule.js";
+import { instrumentsTable } from "./reference-data/instruments.js";
+import { instrumentsExtendedTable } from "./reference-data/instruments-extended.js";
+import { ordersTable } from "./reference-data/orders.js";
+import { childOrdersTable, parentOrdersTable, startGeneratingNewOrders, stopGeneratingNewOrders } from "./reference-data/parent-child-orders.js";
+import { pricesTable } from "./reference-data/prices.js";
+import { schemas } from "./simul-schemas.js";
+import TableContainer from "../core/table/TableContainer.js";
+const undefinedTables = {
+    childOrders: void 0,
+    instruments: void 0,
+    instrumentsExtended: void 0,
+    instrumentPrices: void 0,
+    orders: void 0,
+    parentOrders: void 0,
+    prices: void 0
+};
+class SimulModule extends VuuModule {
+    constructor(){
+        super("SIMUL");
+    }
+    #schemas = schemas;
+    #tables = {
+        childOrders: childOrdersTable,
+        instruments: instrumentsTable,
+        instrumentsExtended: instrumentsExtendedTable,
+        instrumentPrices: TableContainer.createJoinTable({
+            module: "SIMUL",
+            table: "instrumentPrices"
+        }, {
+            module: "SIMUL",
+            table: "instruments"
+        }, {
+            module: "SIMUL",
+            table: "prices"
+        }, "ric"),
+        orders: ordersTable,
+        parentOrders: parentOrdersTable,
+        prices: pricesTable
+    };
+    get menus() {
+        return {
+            childOrders: void 0,
+            instruments: {
+                name: "ROOT",
+                menus: [
+                    {
+                        context: "selected-rows",
+                        filter: "",
+                        name: "Add Instruments To Order",
+                        rpcName: "ADD_INSTRUMENTS_TO_ORDER"
+                    },
+                    {
+                        context: "selected-rows",
+                        filter: "",
+                        name: "Edit Row (server)",
+                        rpcName: "EDIT_ROW"
+                    },
+                    {
+                        context: "selected-rows",
+                        filter: "",
+                        name: "Edit Rows (server)",
+                        rpcName: "beginEditSession"
+                    }
+                ]
+            },
+            instrumentsExtended: void 0,
+            instrumentPrices: void 0,
+            orders: {
+                name: "ROOT",
+                menus: [
+                    {
+                        context: "row",
+                        filter: 'status in ["New","Partial Exec"]',
+                        name: "Cancel Order",
+                        rpcName: "CANCEL_ORDER"
+                    }
+                ]
+            },
+            parentOrders: void 0,
+            prices: void 0
+        };
+    }
+    get schemas() {
+        return this.#schemas;
+    }
+    get editServices() {}
+    get menuServices() {
+        return {
+            ...undefinedTables,
+            orders: [
+                {
+                    rpcName: "CANCEL_ORDER",
+                    service: this.cancelOrder
+                }
+            ]
+        };
+    }
+    get services() {
+        return {
+            ...undefinedTables,
+            instruments: [
+                {
+                    rpcName: "DELETE_ROW",
+                    service: this.deleteRow
+                }
+            ],
+            parentOrders: [
+                {
+                    rpcName: "startGeneratingNewOrders",
+                    service: this.startOrders
+                },
+                {
+                    rpcName: "stopGeneratingNewOrders",
+                    service: this.stopOrders
+                }
+            ]
+        };
+    }
+    get tables() {
+        return this.#tables;
+    }
+    get visualLinks() {
+        return {
+            ...undefinedTables,
+            childOrders: [
+                {
+                    fromColumn: "parentOrderId",
+                    toColumn: "id",
+                    toTable: "parentOrders"
+                }
+            ],
+            parentOrders: [
+                {
+                    fromColumn: "ric",
+                    toColumn: "ric",
+                    toTable: "instruments"
+                }
+            ]
+        };
+    }
+    cancelOrder = async (rpcRequest)=>{
+        const { rowKey, vpId } = rpcRequest;
+        const table = this.tables.orders;
+        const row = table.findByKey(rowKey);
+        row[table.map.status] = "Cancelled";
+        table.updateRow(row);
+        return {
+            action: {
+                type: "SHOW_NOTIFICATION_ACTION",
+                message: `Order id: ${rowKey}`,
+                title: "Order cancelled"
+            },
+            rpcName: "CANCEL_ORDER",
+            type: "VIEW_PORT_MENU_RESP",
+            vpId
+        };
+    };
+    startOrders = async ()=>{
+        startGeneratingNewOrders();
+        return {
+            type: "SUCCESS_RESULT",
+            data: void 0
+        };
+    };
+    stopOrders = async ()=>{
+        stopGeneratingNewOrders();
+        return {
+            type: "SUCCESS_RESULT",
+            data: void 0
+        };
+    };
+}
+const simulModule = new SimulModule();
+export { SimulModule, simulModule };

package/src/simul/index.js

@@ -0,0 +1,2 @@
+export { isSimulTable, schemas as simulSchemas } from "./simul-schemas.js";
+export { simulModule } from "./SimulModule.js";

package/src/simul/reference-data/accounts.js

@@ -0,0 +1,23 @@
+const accounts = [
+    "Account 01",
+    "Account 02",
+    "Account 03",
+    "Account 04",
+    "Account 105",
+    "Account 06",
+    "Account 07",
+    "Account 08",
+    "Account 09",
+    "Account 10",
+    "Account 11",
+    "Account 12",
+    "Account 13",
+    "Account 14",
+    "Account 15",
+    "Account 16",
+    "Account 17",
+    "Account 18",
+    "Account 19",
+    "Account 20"
+];
+export { accounts };

package/src/simul/reference-data/algos.js

@@ -0,0 +1,9 @@
+const algos = [
+    "DARKLIQ",
+    "IS",
+    "SURESHOT",
+    "VWAP",
+    "LITLIQ",
+    "TWAP"
+];
+export { algos };

package/src/simul/reference-data/currencies.js

@@ -0,0 +1,8 @@
+const currencies = [
+    "CAD",
+    "GBX",
+    "USD",
+    "EUR",
+    "GBP"
+];
+export { currencies };

package/src/simul/reference-data/index.js

@@ -0,0 +1,5 @@
+export * from "./currencies.js";
+export * from "./instruments.js";
+export * from "./instrument-prices.js";
+export * from "./prices.js";
+export * from "./locations.js";

package/src/simul/reference-data/instrument-prices.js

@@ -0,0 +1,48 @@
+import { instrumentsData } from "./instruments.js";
+import { pricesData } from "./prices.js";
+const InstrumentPricesColumnMap = {
+    ask: 0,
+    askSize: 1,
+    bbg: 2,
+    bid: 3,
+    bidSize: 4,
+    close: 5,
+    currency: 6,
+    description: 7,
+    exchange: 8,
+    isin: 9,
+    last: 10,
+    lotSize: 11,
+    open: 12,
+    phase: 13,
+    ric: 14,
+    scenario: 15,
+    vuuCreatedTimestamp: 16,
+    vuuUpdatedTimestamp: 17
+};
+const instrumentPrices = [];
+for(let i = 0; i < instrumentsData.length; i++){
+    const [bbg, currency, description, exchange, isin, lotSize, ric] = instrumentsData[i];
+    const [ask, askSize, bid, bidSize, close, last, open, phase, , scenario] = pricesData[i];
+    instrumentPrices.push([
+        ask,
+        askSize,
+        bbg,
+        bid,
+        bidSize,
+        close,
+        currency,
+        description,
+        exchange,
+        isin,
+        last,
+        lotSize,
+        open,
+        phase,
+        ric,
+        scenario,
+        0,
+        0
+    ]);
+}
+export { InstrumentPricesColumnMap, instrumentPrices };

package/src/simul/reference-data/instruments-extended.js

@@ -0,0 +1,12 @@
+import { random } from "../../data-utils.js";
+import { buildDataColumnMap } from "../../Table.js";
+import { schemas } from "../simul-schemas.js";
+import { instrumentsData } from "./instruments.js";
+import TableContainer from "../../core/table/TableContainer.js";
+const instrumentsExtendedData = instrumentsData.map((row)=>row.slice(0, -1).concat([
+        1 === random(0, 1),
+        1 === random(0, 1),
+        new Date().getTime()
+    ]));
+const instrumentsExtendedTable = TableContainer.createTable(schemas.instrumentsExtended, instrumentsExtendedData, buildDataColumnMap(schemas, "instrumentsExtended"));
+export { instrumentsExtendedTable };

package/src/simul/reference-data/instruments.js

@@ -0,0 +1,67 @@
+import { isinGenerator } from "./isin-generator/index.js";
+import TableContainer from "../../core/table/TableContainer.js";
+import { currencies } from "./currencies.js";
+import { locations, suffixes } from "./locations.js";
+import { lotsizes } from "./lotsizes.js";
+import { random } from "../../data-utils.js";
+import { buildDataColumnMap } from "../../Table.js";
+import { schemas } from "../simul-schemas.js";
+import { Clock } from "@vuu-ui/vuu-utils";
+const { createTable: createTable } = TableContainer;
+const today = new Date();
+const clock = new Clock({
+    year: today.getFullYear(),
+    month: today.getMonth() + 1,
+    day: today.getDate(),
+    hours: 7,
+    minutes: 0,
+    seconds: 0,
+    milliseconds: 0
+});
+const InstrumentColumnMap = {
+    bbg: 0,
+    currency: 1,
+    description: 2,
+    exchange: 3,
+    string: 4,
+    number: 5,
+    ric: 6,
+    vuuCreatedTimestamp: 7,
+    vuuUpdatedTimestamp: 8
+};
+const instrumentsData = [];
+const chars1 = Array.from("ABCEFGHKMN");
+const chars2 = Array.from("ABCEFGHKMN");
+const chars3 = Array.from("OPQRTUVWYZ");
+const chars4 = Array.from("OPQRTUVWYZ");
+let count = 0;
+for (const char1 of chars1)for (const char2 of chars2)for (const char3 of chars3)for (const char4 of chars4){
+    const suffix = suffixes[count % 8];
+    const ric = char1 + char2 + char3 + char4 + "." + suffix;
+    const bbg = char1 + char2 + char3 + char4 + " " + suffix;
+    const description = `${ric} description`;
+    const currency = currencies[random(0, 4)];
+    const isin = isinGenerator();
+    const lotSize = lotsizes[random(0, lotsizes.length - 1)];
+    const exchange = locations[suffix][1];
+    const timestamp = clock.now;
+    instrumentsData.push([
+        bbg,
+        currency,
+        description,
+        exchange,
+        String(isin),
+        lotSize,
+        ric,
+        timestamp,
+        timestamp
+    ]);
+    count++;
+    clock.advance(random(0, 10000));
+}
+const getRic = (defaultRic)=>{
+    const row = instrumentsData.at(random(0, instrumentsData.length));
+    return row?.[InstrumentColumnMap.ric] ?? defaultRic;
+};
+const instrumentsTable = createTable(schemas.instruments, instrumentsData, buildDataColumnMap(schemas, "instruments"));
+export { InstrumentColumnMap, getRic, instrumentsData, instrumentsTable };

package/src/simul/reference-data/isin-generator/convert-string-to-base-ten-number.js

@@ -0,0 +1,2 @@
+const convertStringToBaseTenNumber = (value)=>parseInt(value, 10);
+export { convertStringToBaseTenNumber };

package/src/simul/reference-data/isin-generator/fixtures/alphabet.js

@@ -0,0 +1,27 @@
+const alphabet = [
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "G",
+    "H",
+    "J",
+    "K",
+    "L",
+    "M",
+    "N",
+    "P",
+    "Q",
+    "R",
+    "S",
+    "T",
+    "U",
+    "V",
+    "W",
+    "X",
+    "Y",
+    "Z"
+];
+export { alphabet };

package/src/simul/reference-data/isin-generator/fixtures/alphanumeric-values.js

@@ -0,0 +1,7 @@
+import { alphabet } from "./alphabet.js";
+import { baseTenNumbers } from "./base-ten-numbers.js";
+const alphanumeric = [
+    ...alphabet,
+    ...baseTenNumbers
+];
+export { alphanumeric };

package/src/simul/reference-data/isin-generator/fixtures/base-ten-numbers.js

@@ -0,0 +1,13 @@
+const baseTenNumbers = [
+    0,
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9
+];
+export { baseTenNumbers };

package/src/simul/reference-data/isin-generator/generate-cusip-check-code.js

@@ -0,0 +1,17 @@
+import { convertStringToBaseTenNumber } from "./convert-string-to-base-ten-number.js";
+import { isOdd } from "./is-odd.js";
+const generateCusipCheckCode = (cusip)=>{
+    const cusipLength = cusip.length;
+    let currentValue;
+    let total = 0;
+    for(let i = 0; i < cusipLength; i++){
+        currentValue = cusip[i];
+        const currentNumberToBaseTen = convertStringToBaseTenNumber(currentValue);
+        let currentNumberOrPosition = isNaN(currentNumberToBaseTen) ? currentValue.charCodeAt(0) - "A".charCodeAt(0) + 10 : parseInt(currentValue);
+        if (isOdd(i)) currentNumberOrPosition *= 2;
+        total = total + Math.floor(currentNumberOrPosition / 10) + currentNumberOrPosition % 10;
+    }
+    const check = (10 - total % 10) % 10;
+    return check;
+};
+export { generateCusipCheckCode };

package/src/simul/reference-data/isin-generator/generate-cusip-without-check-code.js

@@ -0,0 +1,8 @@
+import { generateRandomStringOfAlphanumericChars } from "./generate-random-string-of-alphanumeric-chars.js";
+import { generateRandomStringOfBaseTenChars } from "./generate-random-string-of-base-ten-chars.js";
+const generateCusipWithoutCheckCode = ()=>{
+    const randomBaseTenString = generateRandomStringOfBaseTenChars();
+    const randomAlphanumericString = generateRandomStringOfAlphanumericChars();
+    return randomBaseTenString + randomAlphanumericString;
+};
+export { generateCusipWithoutCheckCode };

package/src/simul/reference-data/isin-generator/generate-cusip.js

@@ -0,0 +1,8 @@
+import { generateCusipCheckCode } from "./generate-cusip-check-code.js";
+import { generateCusipWithoutCheckCode } from "./generate-cusip-without-check-code.js";
+const generateCusip = ()=>{
+    const cusip = generateCusipWithoutCheckCode();
+    const check = generateCusipCheckCode(cusip);
+    return cusip + check;
+};
+export { generateCusip };

package/src/simul/reference-data/isin-generator/generate-random-alphanumeric.js

@@ -0,0 +1,3 @@
+import { alphanumeric } from "./fixtures/alphanumeric-values.js";
+const generateRandomAlphanumeric = ()=>alphanumeric[Math.floor(Math.random() * alphanumeric.length)];
+export { generateRandomAlphanumeric };

package/src/simul/reference-data/isin-generator/generate-random-base-ten-number.js

@@ -0,0 +1,2 @@
+const generateRandomBaseTenNumber = ()=>Math.floor(10 * Math.random());
+export { generateRandomBaseTenNumber };

package/src/simul/reference-data/isin-generator/generate-random-string-of-alphanumeric-chars.js

@@ -0,0 +1,7 @@
+import { generateRandomAlphanumeric } from "./generate-random-alphanumeric.js";
+const generateRandomStringOfAlphanumericChars = ()=>{
+    let string = "";
+    for(let i = 0; i < 2; i++)string += generateRandomAlphanumeric();
+    return string;
+};
+export { generateRandomStringOfAlphanumericChars };

package/src/simul/reference-data/isin-generator/generate-random-string-of-base-ten-chars.js

@@ -0,0 +1,7 @@
+import { generateRandomBaseTenNumber } from "./generate-random-base-ten-number.js";
+const generateRandomStringOfBaseTenChars = ()=>{
+    let string = "";
+    for(let i = 0; i < 6; i++)string += generateRandomBaseTenNumber();
+    return string;
+};
+export { generateRandomStringOfBaseTenChars };