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

package/src/core/table/TableContainer.mjs

@@ -0,0 +1,102 @@
+import { Table, buildDataColumnMapFromSchema } from "../../Table.mjs";
+const DEFAULT_RANGE_LIMITS = {
+    maxRangeEnd: 1000000,
+    maxRangeWidth: 1000
+};
+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,
+            rangeLimits: DEFAULT_RANGE_LIMITS,
+            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.mjs

@@ -0,0 +1,57 @@
+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
+    ];
+};
+const withNanoMs = (ts, nanos = 0)=>{
+    if (nanos > 0) return 1000000n * BigInt(ts) + BigInt(nanos);
+    return 1000000n * BigInt(ts);
+};
+export { data_utils_nextRandomDouble as nextRandomDouble, generateNextBidAsk, initBidAsk, random, randomPercentage, withNanoMs };

package/src/default-column-definitions.mjs

@@ -0,0 +1,15 @@
+const VUU_DEFAULT_COLUMNS = [
+    {
+        name: "vuuCreatedTimestamp",
+        serverDataType: "epochtimestamp"
+    },
+    {
+        name: "vuuUpdatedTimestamp",
+        serverDataType: "epochtimestamp"
+    },
+    {
+        name: "vuuMsg",
+        serverDataType: "string"
+    }
+];
+export { VUU_DEFAULT_COLUMNS };

package/src/index.mjs

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

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

@@ -0,0 +1,44 @@
+import { jsx } from "react/jsx-runtime";
+import { DataProvider } from "@vuu-ui/vuu-utils";
+import ModuleContainer from "../core/module/ModuleContainer.mjs";
+import TableContainer from "../core/table/TableContainer.mjs";
+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 };

package/src/makeSuggestions.mjs

@@ -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.mjs

@@ -0,0 +1,19 @@
+import { schemas } from "./basket/basket-schemas.mjs";
+import { schemas as simul_schemas_mjs_schemas } from "./simul/simul-schemas.mjs";
+import { testModule } from "./test/TestModule.mjs";
+const schemas_schemas = {
+    ...schemas,
+    ...simul_schemas_mjs_schemas,
+    ...testModule.schemas
+};
+const allSchemas = {
+    ...schemas,
+    ...simul_schemas_mjs_schemas,
+    ...testModule.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.mjs

@@ -0,0 +1,31 @@
+import { Table, buildDataColumnMapFromSchema } from "./Table.mjs";
+import { metadataKeys } from "@vuu-ui/vuu-utils";
+const { KEY: KEY } = metadataKeys;
+const sessionTableRow = (row, schema)=>{
+    const sessionRow = row.slice();
+    if (!schema.columns.some(({ name })=>"vuuMsg" === name)) sessionRow.push("");
+    if (!schema.columns.some(({ name })=>"vuu_action" === name)) sessionRow.push("");
+    return sessionRow;
+};
+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(sessionTableRow(table.data[j], table.schema));
+    const schema = sessionTableSchema(table.schema);
+    return new Table(schema, sessionData, buildDataColumnMapFromSchema(schema));
+};
+const sessionTableSchema = (schema)=>{
+    const columns = schema.columns.slice();
+    if (!columns.some(({ name })=>"vuuMsg" === name)) columns.push({
+        name: "vuuMsg",
+        serverDataType: "string"
+    });
+    if (!columns.some(({ name })=>"vuu_action" === name)) columns.push({
+        name: "vuu_action",
+        serverDataType: "string"
+    });
+    return {
+        ...schema,
+        columns
+    };
+};
+export { createSessionTableFromSelectedRows, sessionTableRow, sessionTableSchema };

package/src/simul/SimulModule.mjs

@@ -0,0 +1,175 @@
+import { VuuModule } from "../core/module/VuuModule.mjs";
+import { instrumentsTable } from "./reference-data/instruments.mjs";
+import { instrumentsExtendedTable } from "./reference-data/instruments-extended.mjs";
+import { ordersTable } from "./reference-data/orders.mjs";
+import { childOrdersTable, parentOrdersTable, startGeneratingNewOrders, stopGeneratingNewOrders } from "./reference-data/parent-child-orders.mjs";
+import { pricesTable } from "./reference-data/prices.mjs";
+import { schemas } from "./simul-schemas.mjs";
+import TableContainer from "../core/table/TableContainer.mjs";
+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.mjs

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

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

@@ -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.mjs

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

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

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

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

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

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

@@ -0,0 +1,48 @@
+import { instrumentsData } from "./instruments.mjs";
+import { pricesData } from "./prices.mjs";
+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.mjs

@@ -0,0 +1,12 @@
+import { random } from "../../data-utils.mjs";
+import { buildDataColumnMap } from "../../Table.mjs";
+import { schemas } from "../simul-schemas.mjs";
+import { instrumentsData } from "./instruments.mjs";
+import TableContainer from "../../core/table/TableContainer.mjs";
+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.mjs

@@ -0,0 +1,69 @@
+import { isinGenerator } from "./isin-generator/index.mjs";
+import TableContainer from "../../core/table/TableContainer.mjs";
+import { currencies } from "./currencies.mjs";
+import { locations, suffixes } from "./locations.mjs";
+import { lotsizes } from "./lotsizes.mjs";
+import { random } from "../../data-utils.mjs";
+import { buildDataColumnMap } from "../../Table.mjs";
+import { schemas } from "../simul-schemas.mjs";
+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,
+    vuuMsg: 9
+};
+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.mjs

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