@vuu-ui/vuu-data-test 0.13.7 → 0.13.8

package/cjs/index.js

@@ -1,49 +1,3050 @@
 'use strict';
 
-var ArrayProxy = require('./ArrayProxy.js');
-var schemas = require('./schemas.js');
-var TickingArrayDataSource = require('./TickingArrayDataSource.js');
-var vuuRowGenerator = require('./vuu-row-generator.js');
-var vuuModules = require('./vuu-modules.js');
-var basketSchemas = require('./basket/basket-schemas.js');
-var basketModule = require('./basket/basket-module.js');
-var makeSuggestions = require('./makeSuggestions.js');
-var simulSchemas = require('./simul/simul-schemas.js');
-var simulModule = require('./simul/simul-module.js');
-var testModule = require('./test/test-module.js');
-var Table = require('./Table.js');
-var VuuModule = require('./VuuModule.js');
-var LocalDatasourceProvider = require('./local-datasource-provider/LocalDatasourceProvider.js');
-
-
-
-exports.ArrayProxy = ArrayProxy.ArrayProxy;
-exports.getAllSchemas = schemas.getAllSchemas;
-exports.getSchema = schemas.getSchema;
-exports.schemas = schemas.schemas;
-exports.TickingArrayDataSource = TickingArrayDataSource.TickingArrayDataSource;
-exports.DefaultColumnGenerator = vuuRowGenerator.DefaultColumnGenerator;
-exports.DefaultRowGenerator = vuuRowGenerator.DefaultRowGenerator;
-exports.defaultGenerators = vuuRowGenerator.defaultGenerators;
-exports.getColumnAndRowGenerator = vuuRowGenerator.getColumnAndRowGenerator;
-exports.populateArray = vuuRowGenerator.populateArray;
-exports.vuuModule = vuuModules.vuuModule;
-exports.basketSchemas = basketSchemas.schemas;
-exports.isBasketTable = basketSchemas.isBasketTable;
-exports.basketModule = basketModule.basketModule;
-exports.createBasketTradingRow = basketModule.createBasketTradingRow;
-exports.tables = basketModule.tables;
-exports.makeSuggestions = makeSuggestions.makeSuggestions;
-exports.isSimulTable = simulSchemas.isSimulTable;
-exports.simulSchemas = simulSchemas.schemas;
-exports.simulModule = simulModule.simulModule;
-exports.testModule = testModule.testModule;
-exports.Table = Table.Table;
-exports.buildDataColumnMap = Table.buildDataColumnMap;
-exports.buildDataColumnMapFromSchema = Table.buildDataColumnMapFromSchema;
-exports.joinTables = Table.joinTables;
-exports.VuuModule = VuuModule.VuuModule;
-exports.withNamedParams = VuuModule.withNamedParams;
-exports.withParams = VuuModule.withParams;
-exports.LocalDataSourceProvider = LocalDatasourceProvider.LocalDataSourceProvider;
+var vuuDataLocal = require('@vuu-ui/vuu-data-local');
+var vuuUtils = require('@vuu-ui/vuu-utils');
+var jsxRuntime = require('react/jsx-runtime');
+
+var __defProp$3 = Object.defineProperty;
+var __typeError$5 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck$5 = (obj, member, msg) => member.has(obj) || __typeError$5("Cannot " + msg);
+var __privateGet$5 = (obj, member, getter) => (__accessCheck$5(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$5 = (obj, member, value) => member.has(obj) ? __typeError$5("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$4 = (obj, member, value, setter) => (__accessCheck$5(obj, member, "write to private field"), member.set(obj, value), value);
+var _getItem;
+const _ArrayProxy = class _ArrayProxy {
+  constructor(size, getRow) {
+    __privateAdd$5(this, _getItem);
+    __publicField$3(this, "length", 0);
+    __publicField$3(this, "map", (func) => {
+      return new _ArrayProxy(this.length, (i) => {
+        return func(__privateGet$5(this, _getItem).call(this, i), i);
+      });
+    });
+    __publicField$3(this, "slice", (from, to) => {
+      const out = [];
+      const end = Math.min(this.length, to);
+      for (let i = from; i < end; i++) {
+        out.push(__privateGet$5(this, _getItem).call(this, i));
+      }
+      return out;
+    });
+    __privateSet$4(this, _getItem, getRow);
+    this.length = size;
+    const handler = {
+      get: (target, prop) => {
+        var _a;
+        if (prop === "length") {
+          return target.length;
+        } else if (prop === "slice") {
+          return target.slice;
+        } else if (prop === "map") {
+          return target.map;
+        } else if (prop === "toString") {
+          return "[ArrayProxy]";
+        }
+        if (typeof prop === "string") {
+          const index = parseInt(prop, 10);
+          if (!isNaN(index)) {
+            if (index < this.length) {
+              return __privateGet$5(_a = target, _getItem).call(_a, index);
+            } else {
+              return void 0;
+            }
+          }
+        }
+        throw Error(`unsupported property ${String(prop)} on ArrayProxy`);
+      },
+      set: (target, prop, newVal) => {
+        if (prop === "length") {
+          target.length = newVal;
+          return true;
+        }
+        throw Error(`ArrayProxy is immutable except for length`);
+      }
+    };
+    return new Proxy(this, handler);
+  }
+};
+_getItem = new WeakMap();
+let ArrayProxy = _ArrayProxy;
+
+const schemas$3 = {
+  algoType: {
+    columns: [
+      { name: "algoType", serverDataType: "string" },
+      { name: "id", serverDataType: "int" }
+    ],
+    key: "id",
+    table: { module: "BASKET", table: "algoType" }
+  },
+  basket: {
+    columns: [
+      { name: "id", serverDataType: "string" },
+      { name: "name", serverDataType: "string" },
+      { name: "notionalValue", serverDataType: "double" },
+      { name: "notionalValueUsd", serverDataType: "double" }
+    ],
+    key: "id",
+    table: { module: "BASKET", table: "basket" }
+  },
+  basketConstituent: {
+    columns: [
+      { name: "basketId", serverDataType: "string" },
+      { name: "change", serverDataType: "string" },
+      { name: "description", serverDataType: "string" },
+      { name: "lastTrade", serverDataType: "string" },
+      { name: "ric", serverDataType: "string" },
+      { name: "ricBasketId", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "volume", serverDataType: "string" },
+      { name: "weighting", serverDataType: "double" }
+    ],
+    key: "ricBasketId",
+    table: { module: "BASKET", table: "basketConstituent" }
+  },
+  basketTrading: {
+    columns: [
+      { name: "basketId", serverDataType: "string" },
+      { name: "basketName", serverDataType: "string" },
+      { name: "filledPct", serverDataType: "double" },
+      { name: "fxRateToUsd", serverDataType: "double" },
+      { name: "instanceId", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "status", serverDataType: "string" },
+      { name: "totalNotional", serverDataType: "double" },
+      { name: "totalNotionalUsd", serverDataType: "double" },
+      { name: "units", serverDataType: "int" }
+    ],
+    key: "instanceId",
+    table: { module: "BASKET", table: "basketTrading" }
+  },
+  basketTradingConstituent: {
+    columns: [
+      { name: "algo", serverDataType: "string" },
+      { name: "algoParams", serverDataType: "string" },
+      { name: "basketId", serverDataType: "string" },
+      { name: "description", serverDataType: "string" },
+      { name: "instanceId", serverDataType: "string" },
+      { name: "instanceIdRic", serverDataType: "string" },
+      { name: "limitPrice", serverDataType: "double" },
+      { name: "notionalLocal", serverDataType: "double" },
+      { name: "notionalUsd", serverDataType: "double" },
+      { name: "pctFilled", serverDataType: "double" },
+      { name: "priceSpread", serverDataType: "int" },
+      { name: "priceStrategyId", serverDataType: "int" },
+      { name: "quantity", serverDataType: "long" },
+      { name: "ric", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "status", serverDataType: "string" },
+      { name: "venue", serverDataType: "string" },
+      { name: "weighting", serverDataType: "double" }
+    ],
+    key: "instanceIdRic",
+    table: { module: "BASKET", table: "basketTradingConstituent" }
+  },
+  basketTradingConstituentJoin: {
+    columns: [
+      { name: "algo", serverDataType: "string" },
+      { name: "algoParams", serverDataType: "string" },
+      { name: "ask", serverDataType: "double" },
+      { name: "askSize", serverDataType: "double" },
+      { name: "basketId", serverDataType: "string" },
+      { name: "bid", serverDataType: "double" },
+      { name: "bidSize", serverDataType: "double" },
+      { name: "close", serverDataType: "double" },
+      { name: "description", serverDataType: "string" },
+      { name: "instanceId", serverDataType: "string" },
+      { name: "instanceIdRic", serverDataType: "string" },
+      { name: "last", serverDataType: "double" },
+      { name: "limitPrice", serverDataType: "double" },
+      { name: "notionalLocal", serverDataType: "double" },
+      { name: "notionalUsd", serverDataType: "double" },
+      { name: "open", serverDataType: "double" },
+      { name: "pctFilled", serverDataType: "double" },
+      { name: "phase", serverDataType: "string" },
+      { name: "priceSpread", serverDataType: "int" },
+      { name: "priceStrategyId", serverDataType: "int" },
+      { name: "quantity", serverDataType: "long" },
+      { name: "ric", serverDataType: "string" },
+      { name: "scenario", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "status", serverDataType: "string" },
+      { name: "venue", serverDataType: "string" },
+      { name: "weighting", serverDataType: "double" }
+    ],
+    key: "instanceIdRic",
+    table: { module: "BASKET", table: "basketTradingConstituentJoin" }
+  },
+  priceStrategyType: {
+    columns: [
+      { name: "priceStrategy", serverDataType: "string" },
+      { name: "id", serverDataType: "int" }
+    ],
+    key: "",
+    table: { module: "BASKET", table: "priceStrategyType" }
+  }
+};
+const isBasketTable = (table) => table.module === "BASKET";
+
+const schemas$2 = {
+  instruments: {
+    columns: [
+      { name: "bbg", serverDataType: "string" },
+      { name: "currency", serverDataType: "string" },
+      { name: "description", serverDataType: "string" },
+      { name: "exchange", serverDataType: "string" },
+      { name: "isin", serverDataType: "string" },
+      { name: "lotSize", serverDataType: "int" },
+      { name: "ric", serverDataType: "string" }
+    ],
+    key: "ric",
+    table: { module: "SIMUL", table: "instruments" }
+  },
+  instrumentsExtended: {
+    columns: [
+      { name: "bbg", serverDataType: "string" },
+      { name: "currency", serverDataType: "string" },
+      { name: "description", serverDataType: "string" },
+      { name: "exchange", serverDataType: "string" },
+      { name: "isin", serverDataType: "string" },
+      { name: "lotSize", serverDataType: "int" },
+      { name: "ric", serverDataType: "string" },
+      { name: "supported", serverDataType: "boolean" },
+      { name: "wishlist", serverDataType: "boolean" },
+      { name: "lastUpdated", serverDataType: "long" },
+      { name: "price", serverDataType: "double" },
+      { name: "date", serverDataType: "long" }
+    ],
+    key: "ric",
+    table: { module: "SIMUL", table: "instrumentsExtended" }
+  },
+  instrumentPrices: {
+    columns: [
+      { name: "ask", serverDataType: "double" },
+      { name: "askSize", serverDataType: "double" },
+      // type: "int"
+      { name: "bbg", serverDataType: "string" },
+      { name: "bid", serverDataType: "double" },
+      { name: "bidSize", serverDataType: "double" },
+      { name: "close", serverDataType: "double" },
+      { name: "currency", serverDataType: "string" },
+      { name: "description", serverDataType: "string" },
+      { name: "exchange", serverDataType: "string" },
+      { name: "isin", serverDataType: "string" },
+      { name: "last", serverDataType: "double" },
+      { name: "lotSize", serverDataType: "int" },
+      { name: "open", serverDataType: "double" },
+      { name: "phase", serverDataType: "string" },
+      { name: "ric", serverDataType: "string" },
+      { name: "scenario", serverDataType: "string" }
+    ],
+    key: "ric",
+    table: { module: "SIMUL", table: "instrumentPrices" }
+  },
+  orders: {
+    columns: [
+      { name: "status", serverDataType: "string" },
+      { name: "ccy", serverDataType: "string" },
+      { name: "created", serverDataType: "long" },
+      { name: "filledQuantity", serverDataType: "double" },
+      { name: "lastUpdate", serverDataType: "long" },
+      { name: "orderId", serverDataType: "string" },
+      { name: "quantity", serverDataType: "double" },
+      { name: "ric", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "trader", serverDataType: "string" }
+    ],
+    key: "orderId",
+    table: { module: "SIMUL", table: "orders" }
+  },
+  childOrders: {
+    columns: [
+      { name: "account", serverDataType: "string" },
+      { name: "averagePrice", serverDataType: "double" },
+      { name: "ccy", serverDataType: "string" },
+      { name: "exchange", serverDataType: "string" },
+      { name: "filledQty", serverDataType: "double" },
+      { name: "id", serverDataType: "string" },
+      { name: "idAsInt", serverDataType: "int" },
+      { name: "lastUpdate", serverDataType: "long" },
+      { name: "openQty", serverDataType: "double" },
+      { name: "parentOrderId", serverDataType: "string" },
+      { name: "price", serverDataType: "double" },
+      { name: "quantity", serverDataType: "double" },
+      { name: "ric", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "status", serverDataType: "string" },
+      { name: "strategy", serverDataType: "string" },
+      { name: "volLimit", serverDataType: "int" }
+    ],
+    key: "id",
+    table: { module: "SIMUL", table: "childOrders" }
+  },
+  parentOrders: {
+    columns: [
+      { name: "account", serverDataType: "string" },
+      { name: "algo", serverDataType: "string" },
+      { name: "averagePrice", serverDataType: "double" },
+      { name: "ccy", serverDataType: "string" },
+      { name: "childCount", serverDataType: "int" },
+      { name: "exchange", serverDataType: "string" },
+      { name: "filledQty", serverDataType: "double" },
+      { name: "id", serverDataType: "string" },
+      { name: "idAsInt", serverDataType: "int" },
+      { name: "lastUpdate", serverDataType: "long" },
+      { name: "openQty", serverDataType: "double" },
+      { name: "price", serverDataType: "double" },
+      { name: "quantity", serverDataType: "double" },
+      { name: "ric", serverDataType: "string" },
+      { name: "side", serverDataType: "string" },
+      { name: "status", serverDataType: "string" },
+      { name: "volLimit", serverDataType: "int" }
+    ],
+    key: "id",
+    table: { module: "SIMUL", table: "parentOrders" }
+  },
+  prices: {
+    columns: [
+      { name: "ask", serverDataType: "double" },
+      { name: "askSize", serverDataType: "double" },
+      // type: "int"
+      { name: "bid", serverDataType: "double" },
+      { name: "bidSize", serverDataType: "double" },
+      { name: "close", serverDataType: "double" },
+      { name: "last", serverDataType: "double" },
+      { name: "open", serverDataType: "double" },
+      { name: "phase", serverDataType: "string" },
+      { name: "ric", serverDataType: "string" },
+      { name: "scenario", serverDataType: "string" }
+    ],
+    key: "ric",
+    table: { module: "SIMUL", table: "prices" }
+  }
+};
+const isSimulTable = (table) => table.module === "SIMUL";
+
+const DefaultRowGenerator = (columns) => (index) => {
+  return [`row ${index + 1}`].concat(
+    Array(columns.length).fill(true).map((v, j) => `value ${j + 1} @ ${index + 1}`)
+  );
+};
+const DefaultColumnGenerator = (columns, columnConfig = {}) => {
+  if (typeof columns === "number") {
+    return [{ label: "Row Number", name: "rownum", width: 150 }].concat(
+      Array(columns).fill(true).map((_, i) => {
+        const name = `column_${i + 1}`;
+        const label = `Column ${i + 1}`;
+        return { label, name, width: 100, ...columnConfig[name] };
+      })
+    );
+  } else {
+    throw Error("DefaultColumnGenerator must be passed columns (number)");
+  }
+};
+const defaultGenerators = {
+  ColumnGenerator: DefaultColumnGenerator,
+  RowGenerator: DefaultRowGenerator
+};
+const getColumnAndRowGenerator = (table) => {
+  const tableName = table?.table ?? "";
+  switch (table?.module) {
+    case "SIMUL": {
+      const { ColumnGenerator, RowGenerator, createUpdateGenerator } = (
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        simulDataGenerators[tableName] ?? defaultGenerators
+      );
+      return [ColumnGenerator, RowGenerator, createUpdateGenerator];
+    }
+    case "BASKET": {
+      const { ColumnGenerator, RowGenerator, createUpdateGenerator } = (
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        basketDataGenerators[tableName] ?? defaultGenerators
+      );
+      return [ColumnGenerator, RowGenerator, createUpdateGenerator];
+    }
+    case void 0: {
+      const { ColumnGenerator, RowGenerator } = defaultGenerators;
+      return [ColumnGenerator, RowGenerator];
+    }
+    default:
+      throw Error(
+        `vuu-row-gererator table ${table?.table} was requested but no generator is registered`
+      );
+  }
+};
+const populateArray = (count, colGen, rowGen, columns) => {
+  const columnDescriptors = colGen(columns);
+  const generateRow = rowGen(columnDescriptors.map((col) => col.name));
+  const data = [];
+  for (let i = 0; i < count; i++) {
+    const row = generateRow(i);
+    if (row) {
+      data[i] = row;
+    } else {
+      break;
+    }
+  }
+  return data;
+};
+
+const schemas$1 = {
+  TwoHundredColumns: {
+    columns: DefaultColumnGenerator(200).map((col) => ({
+      ...col,
+      serverDataType: "string"
+    })),
+    key: "column01",
+    table: { module: "TEST", table: "TwoHundredColumns" }
+  }
+};
+
+const schemas = {
+  ...schemas$3,
+  ...schemas$2,
+  ...schemas$1
+};
+const allSchemas = {
+  ...schemas$3,
+  ...schemas$2,
+  ...schemas$1
+};
+const getAllSchemas = () => schemas;
+const getSchema = (tableName) => {
+  if (allSchemas[tableName]) {
+    return allSchemas[tableName];
+  }
+  throw Error(`getSchema no schema for table ${tableName}`);
+};
+
+const cachedValues = /* @__PURE__ */ new Map();
+const checkPattern = (value, pattern) => {
+  return new RegExp(`^${pattern}`, "i").test(value);
+};
+const getUniqueValues = (table, column, pattern = "") => {
+  let uniqueValues;
+  const cachedEntry = cachedValues.get(table);
+  if (cachedEntry && cachedEntry.has(column)) {
+    uniqueValues = cachedEntry.get(column);
+  } else {
+    const { data, map } = table;
+    const key = map[column];
+    if (key === void 0) {
+      throw Error(`table ${table.schema.table.table} has no column ${column}`);
+    }
+    uniqueValues = [];
+    const set = /* @__PURE__ */ new Set();
+    for (const row of data) {
+      const value = row[key];
+      if (!set.has(value)) {
+        set.add(value);
+        uniqueValues.push(value);
+      }
+    }
+    uniqueValues.sort();
+    if (cachedEntry) {
+      cachedEntry.set(column, uniqueValues);
+    } else {
+      cachedValues.set(table, /* @__PURE__ */ new Map([[column, uniqueValues]]));
+    }
+  }
+  return pattern ? uniqueValues.filter((value) => checkPattern(value.toString(), pattern)).slice(0, 10) : uniqueValues.slice(0, 10);
+};
+const makeSuggestions = (table, column, pattern) => new Promise((resolve) => {
+  const uniqueValues = getUniqueValues(table, column, pattern);
+  const result = uniqueValues.length > 20 ? uniqueValues?.slice(0, 20).map((v) => v.toString()) : uniqueValues.map((v) => v.toString());
+  setTimeout(() => resolve(result), 100);
+});
+
+var __typeError$4 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$4 = (obj, member, msg) => member.has(obj) || __typeError$4("Cannot " + msg);
+var __privateGet$4 = (obj, member, getter) => (__accessCheck$4(obj, member, "read from private field"), member.get(obj));
+var __privateAdd$4 = (obj, member, value) => member.has(obj) ? __typeError$4("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$3 = (obj, member, value, setter) => (__accessCheck$4(obj, member, "write to private field"), member.set(obj, value), value);
+var _menuRpcServices, _pendingVisualLink, _rpcServices, _sessionTables, _table, _selectionLinkSubscribers, _visualLinkService, _getVisualLinks;
+const { KEY } = vuuUtils.metadataKeys;
+class TickingArrayDataSource extends vuuDataLocal.ArrayDataSource {
+  constructor({
+    data,
+    getVisualLinks,
+    menuRpcServices,
+    rpcServices,
+    sessionTables,
+    table,
+    menu,
+    visualLink,
+    visualLinkService,
+    ...arrayDataSourceProps
+  }) {
+    if (data === void 0 && table === void 0) {
+      throw Error("TickingArrayDataSource must be constructed with data");
+    }
+    super({
+      ...arrayDataSourceProps,
+      data: data ?? table?.data ?? []
+    });
+    __privateAdd$4(this, _menuRpcServices);
+    __privateAdd$4(this, _pendingVisualLink);
+    __privateAdd$4(this, _rpcServices);
+    // A reference to session tables hosted within client side module
+    __privateAdd$4(this, _sessionTables);
+    __privateAdd$4(this, _table);
+    __privateAdd$4(this, _selectionLinkSubscribers);
+    __privateAdd$4(this, _visualLinkService);
+    __privateAdd$4(this, _getVisualLinks);
+    this._menu = menu;
+    __privateSet$3(this, _menuRpcServices, menuRpcServices);
+    __privateSet$3(this, _pendingVisualLink, visualLink);
+    __privateSet$3(this, _rpcServices, rpcServices);
+    __privateSet$3(this, _sessionTables, sessionTables);
+    __privateSet$3(this, _table, table);
+    __privateSet$3(this, _visualLinkService, visualLinkService);
+    __privateSet$3(this, _getVisualLinks, getVisualLinks);
+    if (table) {
+      this.tableSchema = table.schema;
+      table.on("insert", this.insert);
+      table.on("update", this.updateRow);
+    }
+  }
+  async subscribe(subscribeProps, callback) {
+    const subscription = super.subscribe(subscribeProps, callback);
+    if (__privateGet$4(this, _pendingVisualLink)) {
+      this.visualLink = __privateGet$4(this, _pendingVisualLink);
+      __privateSet$3(this, _pendingVisualLink, void 0);
+    }
+    return subscription;
+  }
+  unsubscribe() {
+    super.unsubscribe();
+    __privateSet$3(this, _table, void 0);
+  }
+  set range(range) {
+    super.range = range;
+  }
+  get range() {
+    return super.range;
+  }
+  set links(links) {
+    super.links = links;
+  }
+  get links() {
+    var _a;
+    return (_a = __privateGet$4(this, _getVisualLinks)) == null ? void 0 : _a.call(this, this.table.table);
+  }
+  getSelectedRowIds() {
+    return this.selectedRows.reduce(
+      (rowIds, selection) => {
+        if (Array.isArray(selection)) {
+          for (let i = selection[0]; i <= selection[1]; i++) {
+            const row = this.data[i];
+            if (row) {
+              rowIds.push(row[KEY]);
+            }
+          }
+        } else {
+          const row = this.data[selection];
+          if (row) {
+            rowIds.push(row[KEY]);
+          }
+        }
+        return rowIds;
+      },
+      []
+    );
+  }
+  applyEdit(rowKey, columnName, value) {
+    __privateGet$4(this, _table)?.update(rowKey, columnName, value);
+    return Promise.resolve(true);
+  }
+  async rpcCall(rpcRequest) {
+    if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+      const rpcService = __privateGet$4(this, _rpcServices)?.find(
+        (service) => service.rpcName === rpcRequest.rpcName
+      );
+      if (rpcService && vuuUtils.isViewportRpcRequest(rpcRequest)) {
+        switch (rpcRequest.rpcName) {
+          case "VP_BULK_EDIT_COLUMN_CELLS_RPC": {
+            return rpcService.service({
+              ...rpcRequest,
+              vpId: this.viewport
+            });
+          }
+        }
+        return rpcService.service({
+          ...rpcRequest,
+          namedParams: {
+            selectedRowIds: this.getSelectedRowIds(),
+            table: this.tableSchema.table
+          },
+          vpId: this.viewport
+        });
+      }
+    }
+    throw Error(`no implementation for PRC service ${rpcRequest.type}`);
+  }
+  async menuRpcCall(rpcRequest) {
+    const rpcService = __privateGet$4(this, _rpcServices)?.find(
+      (service) => service.rpcName === rpcRequest.rpcName
+    );
+    if (vuuUtils.isVuuMenuRpcRequest(rpcRequest)) {
+      return rpcService?.service({
+        ...rpcRequest,
+        namedParams: {
+          selectedRowIds: this.getSelectedRowIds(),
+          table: this.tableSchema.table
+        },
+        vpId: this.viewport
+      });
+    }
+    return super.menuRpcCall(rpcRequest);
+  }
+  getTypeaheadSuggestions(column, pattern) {
+    if (__privateGet$4(this, _table)) {
+      return makeSuggestions(__privateGet$4(this, _table), column, pattern);
+    } else {
+      throw Error(
+        "cannot call getTypeaheadSuggestions on TickingDataSource if table has not been provided"
+      );
+    }
+  }
+  get visualLink() {
+    return this._config.visualLink;
+  }
+  set visualLink(visualLink) {
+    var _a, _b;
+    this._config = {
+      ...this._config,
+      visualLink
+    };
+    if (visualLink) {
+      const {
+        parentClientVpId,
+        link: { fromColumn, toColumn }
+      } = visualLink;
+      if (this.viewport) {
+        (_a = __privateGet$4(this, _visualLinkService)) == null ? void 0 : _a.call(this, {
+          childVpId: this.viewport,
+          childColumnName: fromColumn,
+          type: "CREATE_VISUAL_LINK",
+          parentVpId: parentClientVpId,
+          parentColumnName: toColumn
+        }).then((response) => {
+          this.emit(
+            "visual-link-created",
+            response
+          );
+        });
+      }
+    } else {
+      (_b = __privateGet$4(this, _visualLinkService)) == null ? void 0 : _b.call(this, {
+        childVpId: this.viewport,
+        type: "REMOVE_VISUAL_LINK"
+      }).then(() => {
+        this.emit("visual-link-removed");
+      });
+    }
+  }
+}
+_menuRpcServices = new WeakMap();
+_pendingVisualLink = new WeakMap();
+_rpcServices = new WeakMap();
+_sessionTables = new WeakMap();
+_table = new WeakMap();
+_selectionLinkSubscribers = new WeakMap();
+_visualLinkService = new WeakMap();
+_getVisualLinks = new WeakMap();
+
+var __typeError$3 = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck$3 = (obj, member, msg) => member.has(obj) || __typeError$3("Cannot " + msg);
+var __privateGet$3 = (obj, member, getter) => (__accessCheck$3(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$3 = (obj, member, value) => member.has(obj) ? __typeError$3("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$2 = (obj, member, value, setter) => (__accessCheck$3(obj, member, "write to private field"), member.set(obj, value), value);
+var _data, _dataMap, _indexOfKey, _index, _schema;
+class Table extends vuuUtils.EventEmitter {
+  constructor(schema, data, dataMap, updateGenerator) {
+    super();
+    __privateAdd$3(this, _data);
+    __privateAdd$3(this, _dataMap);
+    __privateAdd$3(this, _indexOfKey);
+    __privateAdd$3(this, _index, /* @__PURE__ */ new Map());
+    __privateAdd$3(this, _schema);
+    __privateSet$2(this, _data, data);
+    __privateSet$2(this, _dataMap, dataMap);
+    __privateSet$2(this, _schema, schema);
+    __privateSet$2(this, _indexOfKey, dataMap[schema.key]);
+    this.buildIndex();
+    updateGenerator?.setTable(this);
+    updateGenerator?.setRange({ from: 0, to: 100 });
+  }
+  buildIndex() {
+    for (let i = 0; i < __privateGet$3(this, _data).length; i++) {
+      const key = __privateGet$3(this, _data)[i][__privateGet$3(this, _indexOfKey)];
+      __privateGet$3(this, _index).set(key, i);
+    }
+  }
+  get data() {
+    return __privateGet$3(this, _data);
+  }
+  get map() {
+    return __privateGet$3(this, _dataMap);
+  }
+  get schema() {
+    return __privateGet$3(this, _schema);
+  }
+  insert(row) {
+    const index = __privateGet$3(this, _data).length;
+    __privateGet$3(this, _data).push(row);
+    const key = row[__privateGet$3(this, _indexOfKey)];
+    __privateGet$3(this, _index).set(key, index);
+    this.emit("insert", row);
+  }
+  findByKey(key) {
+    const index = __privateGet$3(this, _index).get(key) ?? -1;
+    return __privateGet$3(this, _data)[index];
+  }
+  update(key, columnName, value) {
+    const rowIndex = __privateGet$3(this, _data).findIndex(
+      (row) => row[__privateGet$3(this, _indexOfKey)] === key
+    );
+    const colIndex = __privateGet$3(this, _dataMap)[columnName];
+    if (rowIndex !== -1) {
+      const row = __privateGet$3(this, _data)[rowIndex];
+      const newRow = row.slice();
+      newRow[colIndex] = value;
+      __privateGet$3(this, _data)[rowIndex] = newRow;
+      this.emit("update", newRow, columnName);
+    }
+  }
+  updateRow(row) {
+    const key = row[__privateGet$3(this, _indexOfKey)];
+    const rowIndex = __privateGet$3(this, _data).findIndex(
+      (row2) => row2[__privateGet$3(this, _indexOfKey)] === key
+    );
+    if (rowIndex !== -1) {
+      __privateGet$3(this, _data)[rowIndex] = row;
+      this.emit("update", row);
+    }
+  }
+}
+_data = new WeakMap();
+_dataMap = new WeakMap();
+_indexOfKey = new WeakMap();
+_index = new WeakMap();
+_schema = new WeakMap();
+function buildDataColumnMapFromSchema(schema) {
+  return Object.values(schema.columns).reduce(
+    (map, col, index) => ({
+      ...map,
+      [col.name]: index
+    }),
+    {}
+  );
+}
+function buildDataColumnMap$1(schemas, tableName) {
+  return buildDataColumnMapFromSchema(schemas[tableName]);
+}
+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`
+      );
+    }
+  } else if (col1) {
+    return col1.serverDataType;
+  } else if (col2) {
+    return col2.serverDataType;
+  } else {
+    throw Error(`WTF how is this possible`);
+  }
+};
+const joinTables = (joinTable, table1, table2, joinColumn) => {
+  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);
+    }
+  });
+  return newTable;
+};
+
+function random(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+const nextRandomDouble = (min, max) => min + (max - min) * Math.random();
+const initBidAsk = (priceMaxDelta, nextRandomDouble2) => {
+  const mid = nextRandomDouble2(0, 1e3);
+  const tempBid = nextRandomDouble2(mid - priceMaxDelta, mid - 1);
+  const ask = nextRandomDouble2(mid + 1, mid + priceMaxDelta);
+  const bid = tempBid < 0 ? mid : tempBid;
+  const newBid = Math.round(bid * 100) / 100;
+  const newAsk = Math.round(ask * 100) / 100;
+  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) => {
+  return 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, nextRandomDouble2) => {
+  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(nextRandomDouble2(minBidValue, maxBidValue) * 100) / 100;
+  const newAsk = Math.round(nextRandomDouble2(minAskValue, maxAskValue) * 100) / 100;
+  return [newBid, newAsk];
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+const getNewValue = (value) => {
+  const multiplier = random(0, 100) / 1e3;
+  const direction = random(0, 10) >= 5 ? 1 : -1;
+  return value + value * multiplier * direction;
+};
+class BaseUpdateGenerator {
+  constructor(tickingColumns) {
+    __publicField$2(this, "table");
+    __publicField$2(this, "range");
+    __publicField$2(this, "updating", false);
+    __publicField$2(this, "timer");
+    __publicField$2(this, "tickingColumns");
+    __publicField$2(this, "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 (bid !== void 0 && ask !== void 0) {
+                const { [bid]: currentBid, [ask]: currentAsk } = row;
+                const [newBid, newAsk] = generateNextBidAsk(
+                  currentBid,
+                  currentAsk,
+                  10,
+                  5,
+                  nextRandomDouble
+                );
+                rowUpdates[ask] = newAsk;
+                rowUpdates[bid] = newBid;
+                if (last !== void 0) {
+                  const newLast = Math.round((currentAsk + (newAsk - currentAsk) / 2) * 100) / 100;
+                  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);
+      }
+    });
+    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;
+    }
+  }
+}
+
+var ftse = [
+  ["AAL.L", "Anglo American  PLC", "436.35 13:13", "5.35 (1.24%)", "5,799,089"],
+  ["ABF.L", "Associated British Foods  PLC", "3,435.60 13:12", "7.40 (0.21%)", "86,808"],
+  ["ADM.L", "Admiral Group  PLC", "1,627.00 13:13", ""],
+  ["ADN.L", "Aberdeen Asset Management  PLC", "334.00 13:13", "2.50 (0.75%)", "806,880"],
+  ["AHT.L", "Ashtead Group  PLC", "1,027.00 13:13", "6.00 (0.59%)", "331,255"],
+  ["ANTO.L", "Antofagasta  PLC", "484.10 13:13", "11.70 (2.48%)", "1,753,976"],
+  ["ARM.L", "ARM Holdings  PLC", "1,058.00 13:13", "3.00 (0.28%)", "475,927"],
+  ["AV.L", "Aviva  PLC", "493.97 13:13", "2.23 (0.45%)", "2,226,835"],
+  ["AZN.L", "AstraZeneca  PLC", "4,399.50 13:13", "2.50 (0.06%)", "815,133"],
+  ["BA.L", "BAE Systems  PLC", "478.10 13:13", "4.30 (0.91%)", "2,039,934"],
+  ["BAB.L", "Babcock International Group  PLC", "988.00 13:13", "9.50 (0.97%)", "209,614"],
+  ["BARC.L", "Barclays  PLC", "226.30 13:13", "1.15 (0.51%)", "6,575,664"],
+  ["BATS.L", "British American Tobacco  PLC", "3,803.50 13:13", "8.50 (0.22%)", "465,110"],
+  ["BDEV.L", "Barratt Developments  PLC", "576.00 13:13", "0.50 (0.09%)", "1,044,365"],
+  ["BG.L", "BG Group  PLC", "1,013.50 13:13", "5.50 (0.55%)", "1,507,332"],
+  ["BKG.L", "Berkeley Group Holdings (The)  PLC", "3,126.00 13:13", "15.00 (0.48%)", "95,071"],
+  ["BLND.L", "British Land Co  PLC", "828.06 13:12", "10.44 (1.25%)", "1,802,548"],
+  ["BLT.L", "BHP Billiton  PLC", "881.40 13:13", "4.30 (0.49%)", "4,947,287"],
+  ["BNZL.L", "Bunzl  PLC", "1,875.40 13:05", "4.60 (0.24%)", "104,541"],
+  ["BP.L", "BP  PLC", "381.50 13:13", "2.95 (0.78%)", "10,493,561"],
+  ["BRBY.L", "Burberry Group  PLC", "1,269.00 13:13", "7.00 (0.55%)", "295,647"],
+  ["BT-A", "L,BT Group  PLC", "489.20 13:13", "3.70 (0.75%)", "3,914,982"],
+  ["CCL.L", "Carnival  PLC", "3,426.00 13:12", "22.00 (0.64%)", "86,257"],
+  ["CNA.L", "Centrica  PLC", "212.80 13:13", "0.60 (0.28%)", "2,144,540"],
+  ["CPG.L", "Compass Group  PLC", "1,054.00 13:08", "5.00 (0.48%)", "1,001,167"],
+  ["CPI.L", "Capita  PLC", "1,235.00 13:11", "1.00 (0.08%)", "244,591"],
+  ["CRH.L", "CRH  PLC", "1,783.20 13:12", "17.80 (0.99%)", "897,325"],
+  ["DC.L", "DIXONS CARPHONE", "462.10 13:11", ""],
+  ["DGE.L", "Diageo  PLC", "1,881.50 13:13", "6.50 (0.34%)", "756,906"],
+  ["DLG.L", "Direct Line Insurance Group  PLC", "403.80 13:13", "0.40 (0.10%)", "1,095,340"],
+  ["EXPN.L", "Experian  PLC", "1,191.00 13:12", "2.00 (0.17%)", "467,283"],
+  ["EZJ.L", "easyJet  PLC", "1,682.00 13:12", "28.00 (1.64%)", "1,191,230"],
+  ["FRES.L", "Fresnillo  PLC", "678.50 13:12", "6.50 (0.97%)", "381,871"],
+  ["GFS.L", "G4S  PLC", "232.30 13:03", "2.00 (0.85%)", "1,096,551"],
+  ["GKN.L", "GKN  PLC", "294.80 13:12", "2.50 (0.86%)", "792,247"],
+  ["GLEN.L", "Glencore  PLC", "90.48 13:13", "1.65 (1.86%)", "41,631,528"],
+  ["GSK.L", "GlaxoSmithKline  PLC", "1,345.00 13:13", "0.50 (0.04%)", "1,767,356"],
+  ["HIK.L", "Hikma Pharmaceuticals  PLC", "2,010.00 13:04", "57.00 (2.92%)", "261,511"],
+  ["HL.L", "Hargreaves Lansdown  PLC", "1,488.03 13:12", "9.97 (0.67%)", "372,261"],
+  ["HMSO.L", "Hammerson  PLC", "597.50 13:11", "3.50 (0.58%)", "478,301"],
+  ["HSBA.L", "HSBC Holdings  PLC", "519.70 13:13", "0.50 (0.10%)", "7,415,629"],
+  ["IAG.L", "International Consolidated Airlines Group SA", "575.40 13:12", "16.10 (2.72%)", "4,311,514"],
+  ["IHG.L", "InterContinental Hotels Group  PLC", "2,481.00 13:12", "19.00 (0.76%)", "219,918"],
+  ["III.L", "3i Group  PLC", "487.30 13:11", "4.50 (0.92%)", "189,987"],
+  ["IMT.L", "Imperial Tobacco Group  PLC", "3,571.00 13:13", "29.00 (0.81%)", "926,816"],
+  ["INTU.L", "intu properties  PLC", "319.90 13:09", "4.60 (1.42%)", "514,821"],
+  ["ISAT.L", "Inmarsat  PLC", "1,054.44 13:13", "3.44 (0.33%)", "988,089"],
+  ["ITRK.L", "Intertek Group  PLC", "2,643.00 13:14", "3.00 (0.11%)", "45,868"],
+  ["ITV.L", "ITV  PLC", "267.30 13:14", "2.60 (0.96%)", "3,453,208"],
+  ["JMAT.L", "Johnson Matthey  PLC", "2,445.00 13:14", "29.00 (1.20%)", "276,397"],
+  ["KGF.L", "Kingfisher  PLC", "346.20 13:14", "4.30 (1.23%)", "1,021,408"],
+  ["LAND.L", "Land Securities Group  PLC", "1,239.00 13:13", "7.00 (0.56%)", "384,973"],
+  ["LGEN.L", "Legal & General Group  PLC", "266.00 13:14", "1.60 (0.60%)", "1,998,399"],
+  ["LLOY.L", "Lloyds Banking Group  PLC", "73.86 13:14", "0.02 (0.03%)", "18,907,878"],
+  ["LSE.L", "London Stock Exchange Group  PLC", "2,544.00 13:11", "6.00 (0.24%)", "129,657"],
+  ["MGGT.L", "Meggitt  PLC", "386.00 13:15", "3.20 (0.84%)", "611,044"],
+  ["MKS.L", "Marks & Spencer Group  PLC", "514.75 13:12", "3.25 (0.63%)", "920,128"],
+  ["MNDI.L", "Mondi  PLC", "1,463.00 13:14", "7.00 (0.48%)", "383,546"],
+  ["MRW.L", "Morrison (Wm) Supermarkets  PLC", "155.20 13:14", ""],
+  ["NG.L", "National Grid  PLC", "926.40 13:14", "1.10 (0.12%)", "1,659,592"],
+  ["NXT.L", "Next  PLC", "7,765.00 13:11", "95.00 (1.21%)", "114,062"],
+  ["OML.L", "Old Mutual  PLC", "198.50 13:14", "0.40 (0.20%)", "2,040,849"],
+  ["PRU.L", "Prudential  PLC", "1,499.50 13:15", "14.00 (0.93%)", "580,870"],
+  ["PSON.L", "Pearson  PLC", "794.00 13:09", "5.00 (0.63%)", "1,177,953"],
+  ["RB.L", "Reckitt Benckiser Group  PLC", "6,293.00 13:14", "34.00 (0.54%)", "281,172"],
+  ["RBS.L", "Royal Bank of Scotland Group  PLC", "313.40 13:14", "2.40 (0.77%)", "2,100,058"],
+  ["RDSA.L", "Royal Dutch Shell  PLC", "1,636.00 13:14", "18.00 (1.11%)", "2,467,461"],
+  ["RDSB.L", "Royal Dutch Shell  PLC", "1,652.00 13:15", "14.50 (0.89%)", "1,457,434"],
+  ["REL.L", "Reed Elsevier  PLC", "1,170.00 13:14", "0.00 (0.00%)", "908,802"],
+  ["RIO.L", "Rio Tinto  PLC", "2,235.00 13:15", "21.00 (0.95%)", "2,190,722"],
+  ["RMG.L", "Royal Mail  PLC", "453.50 13:14", "1.20 (0.26%)", "995,316"],
+  ["RR.L", "Rolls-Royce Group  PLC", "546.63 13:14", "8.38 (1.51%)", "2,792,915"],
+  ["RRS.L", "Randgold Resources Ltd", "3,929.00 13:14", "0.00 (0.00%)", "135,524"],
+  ["RSA.L", "RSA Insurance Group  PLC", "437.10 13:14", "0.10 (0.02%)", "395,477"],
+  ["SAB.L", "SABMiller  PLC", "4,011.00 13:15", "1.00 (0.02%)", "892,451"],
+  ["SBRY.L", "Sainsbury (J)  PLC", "255.80 13:14", "7.40 (2.98%)", "2,395,670"],
+  ["SDR.L", "Schroders  PLC", "2,930.00 13:09", "12.00 (0.41%)", "44,674"],
+  ["SGE.L", "Sage Group (The)  PLC", "545.50 13:13", "0.50 (0.09%)", "539,717"],
+  ["SHP.L", "Shire  PLC", "4,685.00 13:14", "22.00 (0.47%)", "221,318"],
+  ["SKY.L", "SKY", "1,095.00 13:12", "4.00 (0.37%)", "925,016"],
+  ["SL.L", "Standard Life  PLC", "399.90 13:14", "3.20 (0.79%)", "861,636"],
+  ["SMIN.L", "Smiths Group  PLC", "992.50 13:14", "27.50 (2.70%)", "640,309"],
+  ["SN.L", "Smith & Nephew  PLC", "1,110.00 13:14", "9.00 (0.82%)", "480,018"],
+  ["SPD.L", "Sports Direct International  PLC", "694.50 13:11", "1.50 (0.22%)", "157,981"],
+  ["SSE.L", "SSE  PLC", "1,463.00 13:13", "2.00 (0.14%)", "562,454"],
+  ["STAN.L", "Standard Chartered  PLC", "583.00 13:14", "0.60 (0.10%)", "2,018,697"],
+  ["STJ.L", "St James's Place  PLC", "964.00 13:14", "11.00 (1.13%)", "418,480"],
+  ["SVT.L", "Severn Trent  PLC", "2,199.00 13:12", "1.00 (0.05%)", "95,342"],
+  ["TPK.L", "Travis Perkins  PLC", "1,945.00 13:13", "4.00 (0.21%)", "92,916"],
+  ["TSCO.L", "Tesco  PLC", "171.54 13:14", "2.54 (1.50%)", "9,831,136"],
+  ["TUI.L", "TUI AG", "1,115.00 13:10", "5.00 (0.45%)", "458,970"],
+  ["TW.L", "Taylor Wimpey  PLC", "183.90 13:15", "1.10 (0.59%)", "3,180,729"],
+  ["ULVR.L", "Unilever  PLC", "2,791.00 13:14", "29.00 (1.03%)", "824,827"],
+  ["UU.L", "United Utilities Group  PLC", "959.00 13:10", "2.50 (0.26%)", "436,911"],
+  ["VOD.L", "Vodafone Group  PLC", "224.25 13:15", "1.30 (0.58%)", "17,572,036"],
+  ["WOS.L", "Wolseley  PLC", "3,657.00 13:14", "4.00 (0.11%)", "179,536"],
+  ["WPP.L", "WPP  PLC", "1,502.00 13:15", "12.00 (0.79%)", "857,887"],
+  ["WTB.L", "Whitbread  PLC", "4,484.00 13:16", "60.00 (1.32%)", "141,036"]
+];
+
+var nasdaq = [
+  ["Apple Inc", "AAPL", 11.007, 174.94, 0.15, "(0.09%)"],
+  ["Microsoft Corp", "MSFT", 9.61, 316.98, -0.03, "(-0.01%)"],
+  ["Amazon.com Inc", "AMZN", 5.401, 129.31, 0.19, "(0.14%)"],
+  ["NVIDIA Corp", "NVDA", 4.101, 415.74, -0.36, "(-0.09%)"],
+  ["Meta Platforms Inc", "META", 3.729, 299.42, 0.34, "(0.11%)"],
+  ["Tesla Inc", "TSLA", 3.285, 244.13, -0.75, "(-0.31%)"],
+  ["Alphabet Inc", "GOOGL", 3.133, 130.49, 0.24, "(0.18%)"],
+  ["Alphabet Inc", "GOOG", 3.085, 131.49, 0.24, "(0.18%)"],
+  ["Broadcom Inc", "AVGO", 2.896, 833.04, 3.96, "(0.48%)"],
+  ["Costco Wholesale Corp", "COST", 2.137, 557.85, -0.74, "(-0.13%)"],
+  ["PepsiCo Inc", "PEP", 2.096, 174.84, -0.43, "(-0.25%)"],
+  ["Adobe Inc", "ADBE", 2.033, 511.42, -1.48, "(-0.29%)"],
+  ["Cisco Systems Inc", "CSCO", 1.887, 53.68, 0.11, "(0.20%)"],
+  ["Comcast Corp", "CMCSA", 1.633, 45.3, -0.01, "(-0.01%)"],
+  ["Netflix Inc", "NFLX", 1.478, 379.89, 0.08, "(0.02%)"],
+  ["T-Mobile US Inc", "TMUS", 1.43, 140.18, 0.83, "(0.60%)"],
+  ["Advanced Micro Devices Inc", "AMD", 1.348, 96.09, -0.11, "(-0.12%)"],
+  ["Texas Instruments Inc", "TXN", 1.264, 161, 0.69, "(0.43%)"],
+  ["Intel Corp", "INTC", 1.26, 34.19, 0.01, "(0.01%)"],
+  ["Amgen Inc", "AMGN", 1.251, 271.18, 3.48, "(1.30%)"],
+  ["Intuit Inc", "INTU", 1.226, 509, 0.43, "(0.08%)"],
+  ["Honeywell International Inc", "HON", 1.103, 188.67, -1.12, "(-0.59%)"],
+  ["QUALCOMM Inc", "QCOM", 1.046, 107.53, -0.16, "(-0.14%)"],
+  ["Applied Materials Inc", "AMAT", 0.982, 136.32, 0.15, "(0.11%)"],
+  ["Booking Holdings Inc", "BKNG", 0.941, 3, 19.2, -43.3, "(-1.42%)"],
+  ["Starbucks Corp", "SBUX", 0.926, 93.8, 0.12, "(0.12%)"],
+  ["Intuitive Surgical Inc", "ISRG", 0.867, 288.5, 0.3, "(0.10%)"],
+  ["Automatic Data Processing Inc", "ADP", 0.854, 239.45, 0.1, "(0.04%)"],
+  ["Mondelez International Inc", "MDLZ", 0.835, 71.25, 0.82, "(1.16%)"],
+  ["Gilead Sciences Inc", "GILD", 0.814, 75.47, 0.46, "(0.61%)"],
+  ["Vertex Pharmaceuticals Inc", "VRTX", 0.794, 353.67, 4.14, "(1.18%)"],
+  ["Regeneron Pharmaceuticals Inc", "REGN", 0.763, 828.09, 3.25, "(0.39%)"],
+  ["Analog Devices Inc", "ADI", 0.752, 176.82, 1.34, "(0.76%)"],
+  ["Lam Research Corp", "LRCX", 0.702, 620, 0.89, "(0.14%)"],
+  ["Micron Technology Inc", "MU", 0.646, 68.9, 0.02, "(0.03%)"],
+  ["Palo Alto Networks Inc", "PANW", 0.604, 228.7, 0.19, "(0.08%)"],
+  ["Synopsys Inc", "SNPS", 0.587, 447.12, 0.27, "(0.06%)"],
+  ["Charter Communications Inc", "CHTR", 0.581, 441.88, -3.33, "(-0.75%)"],
+  ["MercadoLibre Inc", "MELI", 0.562, 1, 275.5, -1.47, "(-0.11%)"],
+  ["PayPal Holdings Inc", "PYPL", 0.559, 57.9, 0.02, "(0.03%)"],
+  ["CSX Corp", "CSX", 0.54, 31.23, 0.03, "(0.09%)"],
+  ["Cadence Design Systems Inc", "CDNS", 0.539, 230.83, 0.17, "(0.07%)"],
+  ["KLA Corp", "KLAC", 0.53, 456.11, 4.29, "(0.95%)"],
+  ["PDD Holdings Inc ADR", "PDD", 0.521, 95.93, -0.01, "(-0.01%)"],
+  ["Marriott International Inc/MD", "MAR", 0.505, 193.9, -0.46, "(-0.23%)"],
+  ["Monster Beverage Corp", "MNST", 0.498, 54.48, -0.04, "(-0.08%)"],
+  ["Airbnb Inc", "ABNB", 0.491, 132.09, -0.11, "(-0.08%)"],
+  ["O'Reilly Automotive Inc", "ORLY", 0.485, 936.67, 0.65, "(0.07%)"],
+  ["Cintas Corp", "CTAS", 0.446, 505.27, 0.52, "(0.10%)"],
+  ["ASML Holding NV", "ASML", 0.438, 585, -2.1, "(-0.36%)"],
+  ["NXP Semiconductors NV", "NXPI", 0.434, 196.76, -0.04, "(-0.02%)"],
+  ["Workday Inc", "WDAY", 0.414, 235.55, 4.73, "(2.05%)"],
+  ["Lululemon Athletica Inc", "LULU", 0.405, 386.36, -1.69, "(-0.44%)"],
+  ["Keurig Dr Pepper Inc,KDP", 0.404, 33.25, 0.13, "(0.39%)"],
+  ["Fortinet Inc", "FTNT", 0.401, 58.29, 0.05, "(0.09%)"],
+  ["Marvell Technology Inc", "MRVL", 0.388, 52.38, 0.08, "(0.14%)"],
+  ["PACCAR Inc", "PCAR", 0.38, 84.97, 0.04, "(0.04%)"],
+  ["Old Dominion Freight Line Inc", "ODFL", 0.38, 401.01, 0.35, "(0.09%)"],
+  ["Autodesk Inc", "ADSK", 0.379, 204.07, 0.03, "(0.01%)"],
+  ["Kraft Heinz Co/The", "KHC", 0.368, 34.27, 0.11, "(0.31%)"],
+  ["Microchip Technology Inc", "MCHP", 0.36, 77, -0.08, "(-0.10%)"],
+  ["Copart Inc", "CPRT", 0.358, 43.26, 0.1, "(0.22%)"],
+  ["American Electric Power Co Inc", "AEP", 0.357, 79.23, 0.06, "(0.08%)"],
+  ["Paychex Inc", "PAYX", 0.355, 113.01, 0.06, "(0.06%)"],
+  ["Exelon Corp", "EXC", 0.35, 40.28, 0.07, "(0.16%)"],
+  ["ON Semiconductor Corp", "ON", 0.341, 93.87, 0.06, "(0.06%)"],
+  ["AstraZeneca PLC ADR", "AZN", 0.339, 67.35, -0.49, "(-0.72%)"],
+  ["Seagen Inc", "SGEN", 0.336, 212.18, -1.52, "(-0.71%)"],
+  ["Ross Stores Inc", "ROST", 0.335, 111.71, 0.05, "(0.04%)"],
+  ["Moderna Inc", "MRNA", 0.331, 100.32, 0.33, "(0.33%)"],
+  ["Biogen Inc", "BIIB", 0.326, 257.93, 0.25, "(0.10%)"],
+  ["Crowdstrike Holdings Inc", "CRWD", 0.319, 162.85, 0.28, "(0.17%)"],
+  ["IDEXX Laboratories Inc", "IDXX", 0.316, 439.41, 3.72, "(0.85%)"],
+  ["Baker Hughes Co", "BKR", 0.307, 35.44, 0.04, "(0.10%)"],
+  ["Constellation Energy Corp", "CEG", 0.307, 110.41, 0.05, "(0.04%)"],
+  ["Cognizant Technology Solutions Corp", "CTSH", 0.303, 70.19, 0.58, "(0.83%)"],
+  ["Verisk Analytics Inc", "VRSK", 0.303, 242.05, 0.1, "(0.04%)"],
+  ["Dexcom Inc", "DXCM", 0.3, 88.3, 0.8, "(0.92%)"],
+  ["Trade Desk Inc/The", "TTD", 0.293, 76.38, 0.03, "(0.03%)"],
+  ["Xcel Energy Inc", "XEL", 0.284, 59.76, 0.03, "(0.04%)"],
+  ["Electronic Arts Inc", "EA", 0.279, 118.38, -0.63, "(-0.53%)"],
+  ["CoStar Group Inc", "CSGP", 0.277, 78.18, 0.12, "(0.15%)"],
+  ["GLOBALFOUNDRIES Inc", "GFS", 0.273, 57.21, 0.38, "(0.67%)"],
+  ["Fastenal Co", "FAST", 0.268, 54.32, 0.11, "(0.20%)"],
+  ["Atlassian Corp", "TEAM", 0.253, 196.01, 0.55, "(0.28%)"],
+  ["GE HealthCare Technologies Inc", "GEHC", 0.252, 63.78, -0.56, "(-0.86%)"],
+  ["Warner Bros Discovery Inc", "WBD", 0.244, 11.09, -0.02, "(-0.14%)"],
+  ["Diamondback Energy Inc", "FANG", 0.235, 150.7, 0.13, "(0.09%)"],
+  ["Datadog Inc", "DDOG", 0.23, 88.81, 0.05, "(0.06%)"],
+  ["ANSYS Inc", "ANSS", 0.227, 300.6, -2.31, "(-0.76%)"],
+  ["eBay Inc", "EBAY", 0.203, 43.22, 0.09, "(0.20%)"],
+  ["Dollar Tree Inc", "DLTR", 0.201, 104.77, 0.27, "(0.25%)"],
+  ["Align Technology Inc", "ALGN", 0.2, 297.25, -1.31, "(-0.44%)"],
+  ["Zscaler Inc", "ZS", 0.188, 151.8, 0.09, "(0.06%)"],
+  ["Illumina Inc", "ILMN", 0.183, 132.31, -0.13, "(-0.10%)"],
+  ["Walgreens Boots Alliance Inc", "WBA", 0.161, 21.18, 0.06, "(0.28%)"],
+  ["Zoom Video Communications Inc", "ZM", 0.151, 68.57, -0.29, "(-0.41%)"],
+  ["Enphase Energy Inc", "ENPH", 0.148, 120.41, 0.49, "(0.41%)"],
+  ["Sirius XM Holdings Inc", "SIRI", 0.137, 4.05, 0.02, "(0.50%)"],
+  ["JD.com Inc ADR", "JD", 0.117, 30.43, 0.02, "(0.05%)"],
+  ["Lucid Group Inc", "LCID", 0.102, 5.14, 0.03, "(0.49%)"]
+];
+
+var sp500 = [
+  ["Apple Inc", "AAPL", 6.992488, 171.9, 1.47, "(0.86%)"],
+  ["Microsoft Corp", "MSFT", 6.487978, 314.55, 1.76, "(0.56%)"],
+  ["Amazon.com Inc", "AMZN", 3.193379, 126.25, 0.27, "(0.22%)"],
+  ["Nvidia Corp", "NVDA", 2.928461, 433.11, 8.43, "(1.99%)"],
+  ["Alphabet Inc Cl A", "GOOGL", 2.162218, 132.93, 2.39, "(1.83%)"],
+  ["Tesla Inc", "TSLA", 1.854311, 246.56, 6.06, "(2.52%)"],
+  ["Alphabet Inc Cl C", "GOOG", 1.85251, 133.81, 2.35, "(1.78%)"],
+  ["Meta Platforms Inc Class A", "META", 1.847731, 305.93, 8.19, "(2.75%)"],
+  ["Berkshire Hathaway Inc Cl B", "BRK.B", 1.82184, 358.67, 0.89, "(0.25%)"],
+  ["Exxon Mobil Corp", "XOM", 1.343563, 118.97, -1.23, "(-1.03%)"],
+  ["Unitedhealth Group Inc", "UNH", 1.302884, 510.04, 6.31, "(1.25%)"],
+  ["Eli Lilly & Co", "LLY", 1.224046, 546.65, -3.11, "(-0.57%)"],
+  ["Jpmorgan Chase & Co", "JPM", 1.182918, 148.23, 2.45, "(1.68%)"],
+  ["Johnson & Johnson W/d", "JNJ", 1.056344, 156.83, -0.28, "(-0.18%)"],
+  ["Visa Inc Class a Shares", "V", 1.029636, 231.97, 2.47, "(1.08%)"],
+  ["Procter & Gamble Co", "PG", 0.969793, 145.75, -1.59, "(-1.08%)"],
+  ["Broadcom Inc", "AVGO", 0.941177, 835.33, 18.52, "(2.27%)"],
+  ["Mastercard Inc A", "MA", 0.918779, 400.65, 5.17, "(1.31%)"],
+  ["Chevron Corp", "CVX", 0.847353, 170.55, -0.49, "(-0.28%)"],
+  ["Home Depot Inc", "HD", 0.847289, 304.35, 2.53, "(0.84%)"],
+  ["Abbvie Inc", "BBV", 0.754672, 152.14, -0.99, "(-0.65%)"],
+  ["Merck & Co. Inc.", "MRK", 0.736434, 104.2, 0.26, "(0.25%)"],
+  ["Costco Wholesale Corp", "COST", 0.697258, 569.05, 5.52, "(0.98%)"],
+  ["Pepsico Inc", "PEP", 0.651768, 168.92, -0.65, "(-0.38%)"],
+  ["Walmart Inc", "WMT", 0.644449, 161.87, 0.15, "(0.09%)"],
+  ["Adobe Inc", "ADBE", 0.639652, 507.17, 4.57, "(0.91%)"],
+  ["Coca Cola Co", "KO", 0.60801, 55.82, -0.13, "(-0.23%)"],
+  ["Cisco Systems Inc", "CSCO", 0.605326, 53.97, 0.77, "(1.44%)"],
+  ["Accenture Plc Cl A", "ACN", 0.55372, 298.5, -15.9, "(-5.05%)"],
+  ["Salesforce Inc", "CRM", 0.551342, 204.46, 1.73, "(0.85%)"],
+  ["Thermo Fisher Scientific Inc", "TMO", 0.536951, 503.47, 5.18, "(1.04%)"],
+  ["Mcdonald S Corp", "MCD", 0.536457, 265.83, 2.19, "(0.83%)"],
+  ["Bank of America Corp", "BAC", 0.526405, 27.51, 0.24, "(0.86%)"],
+  ["Comcast Corp Class A", "CMCSA", 0.512537, 45.17, 0.57, "(1.27%)"],
+  ["Linde Plc", "LIN", 0.506835, 375.48, 3.47, "(0.93%)"],
+  ["Pfizer Inc", "PFE", 0.506043, 32.09, -0.02, "(-0.05%)"],
+  ["Netflix Inc", "NFLX", 0.467192, 377.77, 0.18, "(0.05%)"],
+  ["Abbott Laboratories", "ABT", 0.462893, 97.52, 1.99, "(2.08%)"],
+  ["Oracle Corp", "ORCL", 0.459877, 106.29, 1.67, "(1.60%)"]
+];
+
+var hsi = [
+  ["CKH HOLDINGS", "00001.HK", 41.9, 1.15, "+2.822%", "5.15M", "215.13M", 4.38, 0.31, "6.98%", "160.48B"],
+  ["CLP HOLDINGS", "00002.HK", 57.95, -0.1, "-0.172%", "3.32M", "193.19M", 156.62, 1.39, "5.35%", "146.41B"],
+  ["HK & CHINA GAS", "00003.HK", 5.46, 0.13, "+2.439%", "16.16M", "88.00M", 19.43, 1.66, "6.41%", "101.88B"],
+  ["HSBC HOLDINGS,00005.HK", 61.7, 1.1, "+1.815%", "22.19M", "1.37B", 10.54, 0.86, "4.05%", 1, "227.60B"],
+  ["POWER ASSETS", "00006.HK", 37.9, -0.25, "-0.655%", "4.23M", "160.75M", 14.3, 0.93, "7.44%", "80.77B"],
+  ["HANG SENG BANK", "00011.HK", 97.45, 2.95, "+3.122%", "2.54M", "247.44M", 19.69, 1.01, "4.21%", "186.31B"],
+  ["HENDERSON LAND", "00012.HK", 20.65, 0.85, "+4.293%", "5.07M", "103.70M", 10.81, 0.31, "8.72%", "99.97B"],
+  ["SHK PPT", "00016.HK", 83.8, 3.25, "+4.035%", "8.25M", "685.41M", 10.16, 0.4, "5.91%", "242.83B"],
+  ["NEW WORLD DEV", "00017.HK", 15.24, 0.8, "+5.540%", "12.95M", "196.19M", 30.48, 0.18, "13.52%", "38.35B"],
+  ["GALAXY ENT", "00027.HK", 47.15, 1.9, "+4.199%", "11.97M", "560.21M", "No Profit", 3.22, "0.00%", "206.21B"],
+  ["MTR CORPORATION", "00066.HK", 31, 0.8, "+2.649%", "4.68M", "144.86M", 19.5, 1.07, "4.23%", "192.64B"],
+  ["HANG LUNG PPT", "00101.HK", 10.72, 0.56, "+5.512%", "7.68M", "81.99M", 12.61, 0.36, "7.28%", "48.23B"],
+  ["GEELY AUTO", "00175.HK", 9.24, 0.17, "+1.874%", "18.77M", "173.30M", 16.06, 1.15, "2.27%", "92.99B"],
+  ["ALI HEALTH", "00241.HK", 4.88, 0.47, "+10.658%", "53.62M", "257.82M", 108.09, 3.81, "0.00%", "66.04B"],
+  ["CITIC", "00267.HK", 7.2, 0.2, "+2.857%", "11.54M", "82.96M", 2.78, 0.28, "9.04%", "209.45B"],
+  ["WH GROUP", "00288.HK", 4.11, 0.08, "+1.985%", "18.94M", "77.65M", 4.93, 0.7, "7.30%", "52.73B"],
+  ["CHINA RES BEER", "00291.HK", 42.95, 1.2, "+2.874%", "4.83M", "207.98M", 28.41, 4.57, "1.41%", "139.34B"],
+  ["OOIL", "00316.HK", 104.5, -0.4, "-0.381%", "296.54K", "30.98M", 0.89, 0.66, "78.90%", "69.01B"],
+  ["TINGYI", "00322.HK", 10.94, 0.18, "+1.673%", "2.91M", "31.81M", 20.75, 4.09, "9.39%", "61.64B"],
+  ["SINOPEC CORP", "00386.HK", 4.28, -0.01, "-0.233%", "92.43M", "396.61M", 6.94, 0.58, "9.36%", "105.92B"],
+  ["HKEX", "00388.HK", 292.6, 9, "+3.173%", "4.61M", "1.34B", 36.76, 7.46, "2.44%", "370.97B"],
+  ["TECHTRONIC IND", "00669.HK", 76, 1.35, "+1.808%", "5.47M", "414.78M", 16.54, 3.43, "2.43%", "139.45B"],
+  ["CHINA OVERSEAS", "00688.HK", 16.24, 0.52, "+3.308%", "13.15M", "212.60M", 6.76, 0.44, "4.93%", "177.74B"],
+  ["TENCENT", "00700.HK", 306.2, 8.8, "+2.959%", "11.25M", "3.43B", 13.74, 3.6, "0.78%", 2, "926.16B"],
+  ["CHINA UNICOM", "00762.HK", 5.68, -0.05, "-0.873%", "9.23M", "52.77M", 9.16, 0.45, "5.44%", "173.80B"],
+  ["LINK REIT", "00823.HK", 38.4, 1.45, "+3.924%", "12.04M", "460.96M", 5.42, 0.52, "7.03%", "98.38B"],
+  ["CHINA RES POWER", "00836.HK", 14.94, 0.32, "+2.189%", "9.91M", "147.81M", 10.23, 0.87, "3.92%", "71.87B"],
+  ["PETROCHINA", "00857.HK", 5.9, 0, "0.000%", "64.23M", "380.44M", 6.38, 0.7, "8.08%", "124.48B"],
+  ["XINYI GLASS", "00868.HK", 10.14, 0.17, "+1.705%", "3.75M", "38.02M", 8.01, 1.3, "6.11%", "42.22B"],
+  ["ZHONGSHENG HLDG", "00881.HK", 22.05, 1.45, "+7.039%", "6.76M", "147.71M", 7.08, 1.07, "4.94%", "52.72B"],
+  ["CNOOC", "00883.HK", 13.78, -0.02, "-0.145%", "26.37M", "365.08M", 4.03, 0.97, "19.09%", "655.47B"],
+  ["CCB", "00939.HK", 4.42, 0.06, "+1.376%", "233.61M", "1.03B", 3.06, 0.35, "9.93%", 1, "062.64B"],
+  ["CHINA MOBILE", "00941.HK", 65.7, 0.25, "+0.382%", "7.82M", "516.10M", 9.91, 0.96, "6.71%", 1, "404.46B"],
+  ["LONGFOR GROUP", "00960.HK", 14.08, 0.9, "+6.829%", "10.88M", "150.68M", 3.06, 0.55, "9.05%", "92.81B"],
+  ["XINYI SOLAR", "00968.HK", 5.86, 0.28, "+5.018%", "15.99M", "92.88M", 13.64, 1.75, "3.41%", "52.17B"],
+  ["SMIC", "00981.HK", 20.05, 0.25, "+1.263%", "13.10M", "264.32M", 11.17, 1.06, "0.00%", "159.31B"],
+  ["LENOVO GROUP", "00992.HK", 8.07, 0.25, "+3.197%", "33.60M", "270.50M", 7.61, 2.23, "4.71%", "97.87B"],
+  ["CKI HOLDINGS", "01038.HK", 37.05, -0.2, "-0.537%", "1.44M", "53.73M", 12.03, 0.78, "6.83%", "93.35B"],
+  ["HENGAN INT'L", "01044.HK", 24.95, 0.2, "+0.808%", "2.62M", "64.97M", 13.35, 1.32, "6.33%", "28.99B"],
+  ["CHINA SHENHUA", "01088.HK", 25.4, 0.35, "+1.397%", "7.98M", "203.11M", 6.14, 1.13, "11.33%", "85.79B"],
+  ["CSPC PHARMA", "01093.HK", 5.74, 0.05, "+0.879%", "29.29M", "167.41M", 9.96, 2.01, "3.66%", "68.32B"],
+  ["SINOPHARM", "01099.HK", 22.7, 0.2, "+0.889%", "2.07M", "46.80M", 7.37, 0.92, "4.08%", "30.46B"],
+  ["CHINA RES LAND", "01109.HK", 31.2, 1, "+3.311%", "9.88M", "305.88M", 7.02, 0.81, "5.07%", "222.49B"],
+  ["CK ASSET", "01113.HK", 41.25, 1.25, "+3.125%", "8.57M", "352.44M", 6.9, 0.39, "5.53%", "146.47B"],
+  ["SINO BIOPHARM", "01177.HK", 2.83, 0.02, "+0.712%", "26.30M", "74.09M", 18.37, 1.59, "4.24%", "53.21B"],
+  ["CHINA RES MIXC", "01209.HK", 31.6, 1.6, "+5.333%", "3.07M", "96.42M", 28.97, 4.48, "2.87%", "72.13B"],
+  ["BYD COMPANY", "01211.HK", 242, 7, "+2.979%", "3.90M", "938.50M", 37.57, 5.63, "0.53%", "265.72B"],
+  ["AIA", "01299.HK", 63.85, 0.95, "+1.510%", "38.75M", "2.48B", 408.88, 2.53, "2.41%", "735.40B"],
+  ["CHINAHONGQIAO", "01378.HK", 7.67, 0.28, "+3.789%", "13.05M", "99.58M", 7.27, 0.76, "6.65%", "72.68B"],
+  ["ICBC", "01398.HK", 3.77, 0.07, "+1.892%", "233.48M", "881.67M", 3.45, 0.36, "9.08%", "327.21B"],
+  ["XIAOMI-W", "01810.HK", 12.34, 0.62, "+5.290%", "78.53M", "960.98M", 109.39, 1.9, "0.00%", "308.83B"],
+  ["BUD APAC", "01876.HK", 15.46, 0.16, "+1.046%", "16.17M", "250.45M", 28.65, 2.44, "1.91%", "204.74B"],
+  ["SANDS CHINA LTD", "01928.HK", 24, 0.95, "+4.121%", "19.98M", "475.93M", "No Profit", "N/A", "0.00%", "194.24B"],
+  ["CHOW TAI FOOK", "01929.HK", 11.8, 0.28, "+2.431%", "4.88M", "57.68M", 21.93, 3.64, "10.34%", "118.00B"],
+  ["WHARF REIC", "01997.HK", 30.25, 1.4, "+4.853%", "4.23M", "127.31M", "No Profit", 0.48, "4.33%", "91.85B"],
+  ["ANTA SPORTS", "02020.HK", 88.15, 4.4, "+5.254%", "4.82M", "422.51M", 27.71, 6.16, "1.52%", "249.70B"],
+  ["WUXI BIO", "02269.HK", 45.65, 1.55, "+3.515%", "17.91M", "811.49M", 38.18, 4.88, "0.00%", "194.01B"],
+  ["SHENZHOU INTL", "02313.HK", 75, 4.6, "+6.534%", "5.52M", "410.68M", 21.87, 3.25, "2.55%", "112.74B"],
+  ["PING AN", "02318.HK", 44.85, 0.85, "+1.932%", "23.05M", "1.03B", 8.28, 0.85, "6.09%", "334.02B"],
+  ["MENGNIU DAIRY", "02319.HK", 26.25, 1.5, "+6.061%", "8.58M", "223.15M", 17.34, 2.3, "1.73%", "103.42B"],
+  ["LI NING", "02331.HK", 32.95, 1.5, "+4.769%", "22.54M", "738.37M", 18.8, 3.16, "1.58%", "86.86B"],
+  ["SUNNY OPTICAL", "02382.HK", 54.7, 1.05, "+1.957%", "5.62M", "308.60M", 22.01, 2.44, "0.91%", "60.00B"],
+  ["BOC HONG KONG", "02388.HK", 21.45, 0.3, "+1.418%", "6.53M", "140.32M", 8.38, 0.75, "6.33%", "226.79B"],
+  ["CHINA LIFE", "02628.HK", 12.2, 0.24, "+2.007%", "13.53M", "165.07M", 9.49, 0.7, "4.53%", "90.78B"],
+  ["ENN ENERGY", "02688.HK", 65, 1.15, "+1.801%", "3.06M", "198.69M", 11.08, 1.67, "4.48%", "73.53B"],
+  ["ZIJIN MINING", "02899.HK", 11.98, 0.16, "+1.354%", "16.20M", "194.50M", 13.97, 3.14, "1.88%", "68.73B"],
+  ["MEITUAN-W", "03690.HK", 114.6, 3.8, "+3.430%", "19.17M", "2.19B", "No Profit", 4.89, "0.00%", "715.43B"],
+  ["HANSOH PHARMA", "03692.HK", 10.66, 0.16, "+1.524%", "17.56M", "187.72M", 21.48, 2.47, "0.94%", "63.25B"],
+  ["CM BANK", "03968.HK", 32.7, 0.1, "+0.307%", "11.13M", "363.99M", 5.51, 0.86, "6.00%", "150.12B"],
+  ["BANK OF CHINA", "03988.HK", 2.74, 0.05, "+1.859%", "275.47M", "754.54M", 3.33, 0.33, "9.55%", "229.13B"],
+  ["CG SERVICES", "06098.HK", 8.08, 0.25, "+3.193%", "16.08M", "128.87M", 12.42, 0.65, "5.20%", "27.01B"],
+  ["JD HEALTH", "06618.HK", 40.6, 2.95, "+7.835%", "7.75M", "312.36M", 299.91, 2.56, "0.00%", "129.12B"],
+  ["HAIER SMARTHOME", "06690.HK", 24.65, 1.15, "+4.894%", "7.24M", "178.37M", 13.83, 2.21, "2.59%", "70.46B"],
+  ["HAIDILAO", "06862.HK", 21, 0.6, "+2.941%", "6.86M", "143.79M", 74.46, 13.94, "0.55%", "117.05B"],
+  ["JD-SW", "09618.HK", 115.1, 4, "+3.600%", "7.43M", "852.28M", 30.73, 1.5, "6.38%", "360.24B"],
+  ["NONGFU SPRING", "09633.HK", 45, 1.5, "+3.448%", "3.69M", "165.62M", 52.49, 18.63, "1.71%", "226.56B"],
+  ["BIDU-SW", "09888.HK", 133.4, 4.6, "+3.571%", "5.82M", "772.73M", 47.3, 1.5, "0.00%", "377.37B"],
+  ["TRIP.COM-S", "09961.HK", 279.2, 7, "+2.572%", "1.25M", "349.59M", 114.05, 1.4, "0.00%", "176.65B"],
+  ["BABA-SW", "09988.HK", 85.6, 2.6, "+3.133%", "34.61M", "2.96B", 21.65, 1.62, "0.00%", 1, "837.13B"],
+  ["NTES-S", "09999.HK", 159.5, 8.3, "+5.489%", "5.02M", "797.10M", 22.7, 4.63, "1.36%", "546.99B"]
+];
+
+const basketConstituentData = [];
+for (const row of ftse) {
+  const [ric, name, lastTrade, change, volume] = row;
+  const basketId = ".FTSE100";
+  const side = "BUY";
+  const weighting = 1;
+  basketConstituentData.push([basketId, change, name, lastTrade, ric, `${ric}-${basketId}`, side, volume, weighting]);
+}
+for (const row of hsi) {
+  const [name, ric, lastTrade, change, , volume] = row;
+  const basketId = ".HSI";
+  const side = "BUY";
+  const weighting = 1;
+  basketConstituentData.push([basketId, change, name, lastTrade, ric, `${ric}-${basketId}`, side, volume, weighting]);
+}
+for (const row of nasdaq) {
+  const [name, ric, weighting, lastTrade, change] = row;
+  const basketId = ".NASDAQ100";
+  const side = "BUY";
+  const volume = 1e3;
+  basketConstituentData.push([basketId, change, name, lastTrade, ric, `${ric}-${basketId}`, side, volume, weighting]);
+}
+for (const row of sp500) {
+  const [name, ric, weighting, , change] = row;
+  const basketId = ".SP500";
+  const side = "BUY";
+  const volume = 1e3;
+  const lastTrade = 0;
+  basketConstituentData.push([basketId, change, name, lastTrade, ric, `${ric}-${basketId}`, side, volume, weighting]);
+}
+
+const { bid: bid$1, bidSize: bidSize$1, ask: ask$1, askSize: askSize$1, last } = buildDataColumnMap$1(
+  schemas$2,
+  "prices"
+);
+const pricesUpdateGenerator$1 = new BaseUpdateGenerator({
+  bid: bid$1,
+  bidSize: bidSize$1,
+  ask: ask$1,
+  askSize: askSize$1,
+  last
+});
+const prices = [];
+for (const [, , , lastTrade, ric] of basketConstituentData) {
+  const priceSeed = parseFloat(String(lastTrade));
+  if (!isNaN(priceSeed)) {
+    const [bid2, ask2] = initBidAsk(5, nextRandomDouble);
+    const askSize2 = random(1e3, 3e3);
+    const bidSize2 = random(1e3, 3e3);
+    const close = priceSeed + random(0, 1) / 10;
+    const last2 = priceSeed + random(0, 1) / 10;
+    const open = priceSeed + random(0, 1) / 10;
+    const phase = "C";
+    const scenario = "close";
+    prices.push([
+      ask2,
+      askSize2,
+      bid2,
+      bidSize2,
+      close,
+      last2,
+      open,
+      phase,
+      ric,
+      scenario
+    ]);
+  }
+}
+const pricesTable$1 = new Table(
+  schemas$2.prices,
+  prices,
+  buildDataColumnMap$1(schemas$2, "prices"),
+  pricesUpdateGenerator$1
+);
+
+var __defProp$1 = Object.defineProperty;
+var __typeError$2 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+var __accessCheck$2 = (obj, member, msg) => member.has(obj) || __typeError$2("Cannot " + msg);
+var __privateGet$2 = (obj, member, getter) => (__accessCheck$2(obj, member, "read from private field"), member.get(obj));
+var __privateAdd$2 = (obj, member, value) => member.has(obj) ? __typeError$2("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet$1 = (obj, member, value, setter) => (__accessCheck$2(obj, member, "write to private field"), member.set(obj, value), value);
+var _childColumnName, _childDataSource, _parentColumnName, _parentDataSource;
+class RuntimeVisualLink {
+  constructor(childDataSource, parentDataSource, childColumnName, parentColumnName) {
+    __privateAdd$2(this, _childColumnName);
+    __privateAdd$2(this, _childDataSource);
+    __privateAdd$2(this, _parentColumnName);
+    __privateAdd$2(this, _parentDataSource);
+    __publicField$1(this, "handleParentSelectEvent", (selection) => {
+      if (__privateGet$2(this, _childDataSource)) {
+        const selectedValues = this.pickUniqueSelectedValues(selection);
+        if (selectedValues.length === 0) {
+          __privateGet$2(this, _childDataSource).baseFilter = void 0;
+        } else if (selectedValues.length === 1) {
+          __privateGet$2(this, _childDataSource).baseFilter = {
+            filter: `${__privateGet$2(this, _childColumnName)} = "${selectedValues[0]}"`
+          };
+        } else {
+          __privateGet$2(this, _childDataSource).baseFilter = {
+            filter: `${__privateGet$2(this, _childColumnName)} in ["${selectedValues.join('","')}"]`
+          };
+        }
+      }
+    });
+    __privateSet$1(this, _childColumnName, childColumnName);
+    __privateSet$1(this, _childDataSource, childDataSource);
+    __privateSet$1(this, _parentColumnName, parentColumnName);
+    __privateSet$1(this, _parentDataSource, parentDataSource);
+    parentDataSource.on("row-selection", this.handleParentSelectEvent);
+  }
+  destroy() {
+  }
+  remove() {
+    __privateGet$2(this, _parentDataSource)?.removeListener(
+      "row-selection",
+      this.handleParentSelectEvent
+    );
+    __privateGet$2(this, _childDataSource).baseFilter = { filter: "" };
+  }
+  pickUniqueSelectedValues(selection) {
+    const data = __privateGet$2(this, _parentDataSource).currentData;
+    const selectedRows = selection.reduce(
+      (rows, selected) => {
+        if (Array.isArray(selected)) {
+          for (let i = selected[0]; i <= selected[1]; i++) {
+            const row = data[i];
+            if (row) {
+              rows.push(row);
+            }
+          }
+        } else {
+          const row = data[selected];
+          if (row) {
+            rows.push(row);
+          }
+        }
+        return rows;
+      },
+      []
+    );
+    const map = vuuUtils.buildColumnMap(__privateGet$2(this, _parentDataSource).columns);
+    const set = /* @__PURE__ */ new Set();
+    const colIndex = map[__privateGet$2(this, _parentColumnName)];
+    for (const row of selectedRows) {
+      set.add(row[colIndex]);
+    }
+    return Array.from(set);
+  }
+}
+_childColumnName = new WeakMap();
+_childDataSource = new WeakMap();
+_parentColumnName = new WeakMap();
+_parentDataSource = new WeakMap();
+
+var __defProp = Object.defineProperty;
+var __typeError$1 = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck$1 = (obj, member, msg) => member.has(obj) || __typeError$1("Cannot " + msg);
+var __privateGet$1 = (obj, member, getter) => (__accessCheck$1(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd$1 = (obj, member, value) => member.has(obj) ? __typeError$1("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck$1(obj, member, "write to private field"), member.set(obj, value), value);
+var _menus, _name, _runtimeVisualLinks, _schemas, _sessionTableMap, _tables, _tableServices, _visualLinks, _subscriptionMap, _moduleServices;
+const withParams = (rpcRequest) => "namedParams" in rpcRequest;
+const withNamedParams = (rpcRequest) => "namedParams" in rpcRequest;
+class VuuModule {
+  constructor({
+    menus,
+    name,
+    schemas,
+    services,
+    tables,
+    vuuLinks: visualLinks
+  }) {
+    __privateAdd$1(this, _menus);
+    __privateAdd$1(this, _name);
+    __privateAdd$1(this, _runtimeVisualLinks, /* @__PURE__ */ new Map());
+    __privateAdd$1(this, _schemas);
+    __privateAdd$1(this, _sessionTableMap, {});
+    __privateAdd$1(this, _tables);
+    __privateAdd$1(this, _tableServices);
+    __privateAdd$1(this, _visualLinks);
+    __privateAdd$1(this, _subscriptionMap, /* @__PURE__ */ new Map());
+    __publicField(this, "unregisterViewport", (viewportId) => {
+      for (const [tableName, subscriptions] of __privateGet$1(this, _subscriptionMap)) {
+        if (subscriptions[0].viewportId.toString() === viewportId) {
+          __privateGet$1(this, _subscriptionMap).delete(tableName);
+        } else {
+          const links = subscriptions[0].dataSource.links;
+          if (links) {
+            for (let i = 0; i < links?.length; i++) {
+              if (links[i].parentClientVpId === viewportId) {
+                links.splice(i);
+              }
+            }
+          }
+          subscriptions[0].dataSource.links = links;
+        }
+      }
+    });
+    __publicField(this, "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 (status !== "suspended") {
+              const newLink = {
+                parentClientVpId: viewportId,
+                parentVpId: viewportId,
+                link: vuuLinks[i]
+              };
+              visualLinks.push(newLink);
+            }
+          });
+        }
+      }
+      return visualLinks;
+    });
+    __publicField(this, "visualLinkService", (message) => new Promise((resolve) => {
+      if (message.type === "CREATE_VISUAL_LINK") {
+        const { childColumnName, childVpId, parentColumnName, parentVpId } = message;
+        const childDataSource = this.getSubscribedDataSource(childVpId);
+        const parentDataSource = this.getSubscribedDataSource(parentVpId);
+        const runtimeVisualLink = new RuntimeVisualLink(
+          childDataSource,
+          parentDataSource,
+          childColumnName,
+          parentColumnName
+        );
+        __privateGet$1(this, _runtimeVisualLinks).set(childVpId, runtimeVisualLink);
+        resolve({
+          clientViewportId: childVpId,
+          colName: childColumnName,
+          parentColName: parentColumnName,
+          parentViewportId: parentVpId,
+          type: "vuu-link-created"
+        });
+      } else {
+        const runtimeVisualLink = __privateGet$1(this, _runtimeVisualLinks).get(
+          message.childVpId
+        );
+        if (runtimeVisualLink) {
+          runtimeVisualLink.remove();
+          __privateGet$1(this, _runtimeVisualLinks).delete(message.childVpId);
+        } else {
+          throw Error(
+            `visualLinkService no visual link found for viewport #${message.childVpId}`
+          );
+        }
+        resolve();
+      }
+    }));
+    __publicField(this, "createDataSource", (tableName, viewport, config) => {
+      const getVisualLinks = (tableName2) => {
+        const linksForTable = __privateGet$1(this, _visualLinks)?.[tableName2];
+        return linksForTable === void 0 ? void 0 : this.getLinks(__privateGet$1(this, _subscriptionMap), linksForTable);
+      };
+      const columnDescriptors = this.getColumnDescriptors(tableName);
+      const table = __privateGet$1(this, _tables)[tableName];
+      const sessionTable = __privateGet$1(this, _sessionTableMap)[tableName];
+      const dataSource = new TickingArrayDataSource({
+        ...config,
+        columnDescriptors,
+        getVisualLinks,
+        keyColumn: __privateGet$1(this, _schemas)[tableName] === void 0 ? __privateGet$1(this, _sessionTableMap)[tableName].schema.key : __privateGet$1(this, _schemas)[tableName].key,
+        table: table || sessionTable,
+        menu: __privateGet$1(this, _menus)?.[tableName],
+        rpcServices: this.getServices(tableName),
+        sessionTables: __privateGet$1(this, _sessionTableMap),
+        viewport,
+        visualLinkService: this.visualLinkService
+      });
+      dataSource.on("unsubscribed", this.unregisterViewport);
+      const existingSubscriptions = __privateGet$1(this, _subscriptionMap).get(tableName);
+      const subscription = {
+        viewportId: dataSource.viewport,
+        dataSource
+      };
+      if (existingSubscriptions) {
+        existingSubscriptions.push(subscription);
+      } else {
+        __privateGet$1(this, _subscriptionMap).set(tableName, [subscription]);
+      }
+      return dataSource;
+    });
+    __publicField(this, "suggestionFetcher", ([
+      vuuTable,
+      column,
+      pattern
+    ]) => {
+      const table = __privateGet$1(this, _tables)[vuuTable.table];
+      if (table) {
+        return makeSuggestions(table, column, pattern);
+      } else {
+        throw Error(
+          `${__privateGet$1(this, _name)} suggestionFetcher, unknown table ${vuuTable.module} ${vuuTable.table}`
+        );
+      }
+    });
+    __publicField(this, "openBulkEdits", async (rpcRequest) => {
+      if (withParams(rpcRequest)) {
+        const { namedParams, vpId } = rpcRequest;
+        const selectedRowIds = namedParams.selectedRowIds;
+        const table = namedParams.table;
+        if (selectedRowIds && table) {
+          const dataTable = __privateGet$1(this, _tables)[table.table];
+          if (dataTable) {
+            const sessionTable = this.createSessionTableFromSelectedRows(
+              dataTable,
+              selectedRowIds
+            );
+            const sessionTableName = `session-${vuuUtils.uuid()}`;
+            __privateGet$1(this, _sessionTableMap)[sessionTableName] = sessionTable;
+            return {
+              action: {
+                renderComponent: "grid",
+                table: {
+                  module: table.module,
+                  table: sessionTableName
+                },
+                tableSchema: dataTable.schema,
+                type: "OPEN_DIALOG_ACTION"
+              },
+              rpcName: "VP_BULK_EDIT_BEGIN_RPC",
+              type: "VIEW_PORT_MENU_RESP",
+              vpId
+            };
+          } else {
+            return {
+              action: { type: "NO_ACTION" },
+              clientViewportId: "na",
+              error: "No Table found",
+              rpcName: "VP_BULK_EDIT_REJECT",
+              type: "VIEW_PORT_MENU_REJ",
+              vpId
+            };
+          }
+        }
+      }
+      throw Error("openBulkEdits expects Table and selectedRowIds");
+    });
+    __publicField(this, "endEditSession", async (rpcRequest) => {
+      if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+        const { vpId } = rpcRequest;
+        delete __privateGet$1(this, _sessionTableMap)[vpId];
+        return {
+          action: { type: "VP_RPC_SUCCESS" },
+          method: "???",
+          namedParams: {},
+          params: [],
+          type: "VIEW_PORT_RPC_REPONSE",
+          vpId
+        };
+      } else {
+        throw Error("endEditSession invalid request");
+      }
+    });
+    // Bulk-edit with input in session table
+    __publicField(this, "applyBulkEdits", async (rpcRequest) => {
+      if (withParams(rpcRequest)) {
+        const { vpId } = rpcRequest;
+        const sessionTable = this.getSessionTable(vpId);
+        for (let i = 0; i < sessionTable.data.length; i++) {
+          const newRow = sessionTable.data[i];
+          const { column, value } = rpcRequest.namedParams;
+          const keyIndex = sessionTable.map[sessionTable.schema.key];
+          sessionTable.update(
+            String(newRow[keyIndex]),
+            column,
+            value
+          );
+        }
+        return {
+          action: {
+            type: "NO_ACTION"
+          },
+          rpcName: "VP_BULK_EDIT_COLUMN_CELLS_RPC",
+          type: "VIEW_PORT_MENU_RESP",
+          vpId
+        };
+      }
+      throw Error("applyBulkEdits expects column and value as namedParams");
+    });
+    // Save session table data to main table
+    __publicField(this, "saveBulkEdits", async (rpcRequest) => {
+      if (withParams(rpcRequest)) {
+        const { vpId } = rpcRequest;
+        const sessionTable = this.getSessionTable(vpId);
+        const { table } = sessionTable.schema.table;
+        const baseTable = __privateGet$1(this, _tables)[table];
+        if (baseTable) {
+          for (let i = 0; i < sessionTable.data.length; i++) {
+            const newRow = sessionTable.data[i];
+            baseTable.updateRow(newRow);
+          }
+          return {
+            action: {
+              type: "VP_RPC_SUCCESS"
+            },
+            requestId: "request_id",
+            rpcName: "VP_BULK_EDIT_SUBMIT_RPC",
+            type: "VIEW_PORT_MENU_RESP",
+            vpId
+          };
+        }
+      }
+      throw Error("saveBulkEdits base table not found");
+    });
+    /**
+     * These services are available on any table. The client must configure the appropriate
+     * menu item(s) on Table(s). The services to implement these RPC calls are built-in to
+     * VuuModule
+     */
+    __privateAdd$1(this, _moduleServices, [
+      {
+        rpcName: "VP_BULK_EDIT_BEGIN_RPC",
+        service: this.openBulkEdits
+      },
+      {
+        rpcName: "VP_BULK_EDIT_COLUMN_CELLS_RPC",
+        service: this.applyBulkEdits
+      },
+      {
+        rpcName: "VP_BULK_EDIT_SUBMIT_RPC",
+        service: this.saveBulkEdits
+      },
+      {
+        rpcName: "VP_BULK_EDIT_END_RPC",
+        service: this.endEditSession
+      }
+    ]);
+    __privateSet(this, _menus, menus);
+    __privateSet(this, _name, name);
+    __privateSet(this, _schemas, schemas);
+    __privateSet(this, _tableServices, services);
+    __privateSet(this, _tables, tables);
+    __privateSet(this, _visualLinks, visualLinks);
+  }
+  getSubscribedDataSource(vpId) {
+    for (const subscriptions of __privateGet$1(this, _subscriptionMap).values()) {
+      for (const { viewportId, dataSource } of subscriptions) {
+        if (viewportId === vpId) {
+          return dataSource;
+        }
+      }
+    }
+    throw Error(`getSubscribedDataSource #${vpId} not in subscriptionMap`);
+  }
+  getServices(tableName) {
+    const tableServices = __privateGet$1(this, _tableServices)?.[tableName];
+    if (Array.isArray(tableServices)) {
+      return __privateGet$1(this, _moduleServices).concat(tableServices);
+    } else {
+      return __privateGet$1(this, _moduleServices);
+    }
+  }
+  get typeaheadHook() {
+    return () => this.suggestionFetcher;
+  }
+  get sessionTableMap() {
+    return __privateGet$1(this, _sessionTableMap);
+  }
+  get tables() {
+    return __privateGet$1(this, _tables);
+  }
+  getSessionTable(sessionTableName) {
+    const sessionTable = __privateGet$1(this, _sessionTableMap)[sessionTableName];
+    if (sessionTable) {
+      return sessionTable;
+    } else {
+      throw Error(
+        `getSessionTable: no session table with name ${sessionTableName}`
+      );
+    }
+  }
+  getColumnDescriptors(tableName) {
+    const schema = __privateGet$1(this, _schemas)[tableName] || this.getSessionTable(tableName)?.schema;
+    if (schema) {
+      return schema.columns;
+    } else {
+      throw Error(
+        ` no schema found for module ${__privateGet$1(this, _name)} table ${tableName}`
+      );
+    }
+  }
+  createSessionTableFromSelectedRows({ data, map, schema }, selectedRowIds) {
+    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]);
+        }
+      }
+    }
+    return new Table(schema, sessionData, buildDataColumnMapFromSchema(schema));
+  }
+}
+_menus = new WeakMap();
+_name = new WeakMap();
+_runtimeVisualLinks = new WeakMap();
+_schemas = new WeakMap();
+_sessionTableMap = new WeakMap();
+_tables = new WeakMap();
+_tableServices = new WeakMap();
+_visualLinks = new WeakMap();
+_subscriptionMap = new WeakMap();
+_moduleServices = new WeakMap();
+
+const undefinedTables$1 = {
+  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$3[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 basketConstituent = new Table(
+  schemas$3.basketConstituent,
+  basketConstituentData,
+  tableMaps.basketConstituent
+);
+const basketTrading = new Table(
+  schemas$3.basketTrading,
+  [],
+  tableMaps.basketTrading
+);
+let basketIncrement = 1;
+const basketTradingConstituent = new Table(
+  schemas$3.basketTradingConstituent,
+  [],
+  tableMaps.basketTradingConstituent
+);
+const createBasketTradingRow = (basketId, basketName, side = "BUY", status = "OFF MARKET") => [
+  basketId,
+  basketName,
+  0,
+  1.25,
+  `steve-${basketIncrement++}`,
+  side,
+  status,
+  1e6,
+  125e4,
+  100
+];
+function createTradingBasket(basketId, basketName) {
+  const basketTradingRow = createBasketTradingRow(basketId, basketName);
+  basketTrading.insert(basketTradingRow);
+  const { basketId: key } = buildDataColumnMap("basketConstituent");
+  const constituents = 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];
+}
+const addConstituent = async (rpcRequest) => {
+  if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+    throw Error(`addConstituent not implemented`);
+  } else {
+    throw Error(`addConstituent invalid rpcRequest`);
+  }
+};
+const viewportRpcResponse = (params, vpId, action) => ({
+  type: "VIEW_PORT_RPC_REPONSE",
+  action: {
+    type: "VP_RPC_SUCCESS",
+    ...action
+  },
+  method: "???",
+  namedParams: {},
+  params,
+  vpId
+});
+const sendToMarket = async (rpcRequest) => {
+  if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+    const { params, vpId } = rpcRequest;
+    const [basketInstanceId] = params;
+    basketTrading.update(basketInstanceId, "status", "ON_MARKET");
+    return viewportRpcResponse(params, vpId);
+  } else {
+    throw Error(`sendToMarket invalid rpcRequest`);
+  }
+};
+const takeOffMarket = async (rpcRequest) => {
+  if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+    const { params, vpId } = rpcRequest;
+    const [basketInstanceId] = params;
+    basketTrading.update(basketInstanceId, "status", "OFF-MARKET");
+    return viewportRpcResponse(params, vpId);
+  } else {
+    throw Error(`takeOffMarket invalid rpcRequest`);
+  }
+};
+const createNewBasket = async (rpcRequest) => {
+  if (vuuUtils.isViewportRpcRequest(rpcRequest)) {
+    const { params, vpId } = rpcRequest;
+    const [basketId, basketName] = params;
+    const key = createTradingBasket(basketId, basketName);
+    return viewportRpcResponse(params, vpId, { key });
+  } else {
+    throw Error(`createNewBasket invalid rpcRequest`);
+  }
+};
+const tables$2 = {
+  algoType: new Table(
+    schemas$3.algoType,
+    [
+      ["Sniper", 0],
+      ["Dark Liquidity", 1],
+      ["VWAP", 2],
+      ["POV", 3],
+      ["Dynamic Close", 4]
+    ],
+    tableMaps.algoType
+  ),
+  basket: new Table(
+    schemas$3.basket,
+    [
+      [".NASDAQ100", ".NASDAQ100", 0, 0],
+      [".HSI", ".HSI", 0, 0],
+      [".FTSE100", ".FTSE100", 0, 0],
+      [".SP500", ".SP500", 0, 0]
+    ],
+    tableMaps.basket
+  ),
+  basketConstituent,
+  basketTrading,
+  basketTradingConstituent,
+  basketTradingConstituentJoin: joinTables(
+    { module: "BASKET", table: "basketTradingConstituentJoin" },
+    basketTradingConstituent,
+    pricesTable$1,
+    "ric"
+  ),
+  priceStrategyType: new Table(
+    schemas$3.priceStrategyType,
+    [
+      ["Peg to Near Touch", 0],
+      ["Far Touch", 1],
+      ["Limit", 2],
+      ["Algo", 3]
+    ],
+    tableMaps.priceStrategyType
+  )
+};
+const vuuLinks$1 = {
+  ...undefinedTables$1,
+  basketConstituent: [
+    { fromColumn: "basketId", toColumn: "id", toTable: "basket" }
+  ]
+};
+const menus$1 = {
+  ...undefinedTables$1,
+  basket: {
+    name: "ROOT",
+    menus: [
+      {
+        context: "selected-rows",
+        filter: "",
+        name: "Add Basket",
+        rpcName: "CREATE_NEW_BASKET"
+      }
+    ]
+  }
+};
+const services$1 = {
+  ...undefinedTables$1,
+  basket: [
+    {
+      rpcName: "createBasket",
+      service: createNewBasket
+    }
+  ],
+  basketTrading: [
+    {
+      rpcName: "sendToMarket",
+      service: sendToMarket
+    },
+    {
+      rpcName: "takeOffMarket",
+      service: takeOffMarket
+    }
+  ],
+  basketTradingConstituentJoin: [
+    {
+      rpcName: "addConstituent",
+      service: addConstituent
+    }
+  ]
+};
+const basketModule = new VuuModule({
+  menus: menus$1,
+  name: "BASKET",
+  schemas: schemas$3,
+  services: services$1,
+  tables: tables$2,
+  vuuLinks: vuuLinks$1
+});
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var _services;
+class SimulModule extends VuuModule {
+  constructor(props) {
+    super(props);
+    __privateAdd(this, _services, []);
+  }
+  getServices(tableName) {
+    return __privateGet(this, _services).concat(super.getServices(tableName));
+  }
+}
+_services = new WeakMap();
+
+const convertStringToBaseTenNumber = (value) => parseInt(value, 10);
+
+const isOdd = (value) => value % 2 === 1;
+
+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 = currentNumberOrPosition * 2;
+    }
+    total = total + Math.floor(currentNumberOrPosition / 10) + currentNumberOrPosition % 10;
+  }
+  const check = (10 - total % 10) % 10;
+  return check;
+};
+
+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"
+];
+
+const baseTenNumbers = [
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9
+];
+
+const alphanumeric = [...alphabet, ...baseTenNumbers];
+
+const generateRandomAlphanumeric = () => alphanumeric[Math.floor(Math.random() * alphanumeric.length)];
+
+const generateRandomStringOfAlphanumericChars = () => {
+  let string = "";
+  for (let i = 0; i < 2; i++) {
+    string = string + generateRandomAlphanumeric();
+  }
+  return string;
+};
+
+const generateRandomBaseTenNumber = () => Math.floor(Math.random() * 10);
+
+const generateRandomStringOfBaseTenChars = () => {
+  let string = "";
+  for (let i = 0; i < 6; i++) {
+    string = string + generateRandomBaseTenNumber();
+  }
+  return string;
+};
+
+const generateCusipWithoutCheckCode = () => {
+  const randomBaseTenString = generateRandomStringOfBaseTenChars();
+  const randomAlphanumericString = generateRandomStringOfAlphanumericChars();
+  return randomBaseTenString + randomAlphanumericString;
+};
+
+const generateCusip = () => {
+  const cusip = generateCusipWithoutCheckCode();
+  const check = generateCusipCheckCode(cusip);
+  return cusip + check;
+};
+
+const countryCodes = [
+  "AD",
+  "AE",
+  "AF",
+  "AG",
+  "AI",
+  "AL",
+  "AM",
+  "AO",
+  "AQ",
+  "AR",
+  "AS",
+  "AT",
+  "AU",
+  "AW",
+  "AX",
+  "AZ",
+  "BA",
+  "BB",
+  "BD",
+  "BE",
+  "BF",
+  "BG",
+  "BH",
+  "BI",
+  "BJ",
+  "BL",
+  "BM",
+  "BN",
+  "BO",
+  "BQ",
+  "BR",
+  "BS",
+  "BT",
+  "BV",
+  "BW",
+  "BY",
+  "BZ",
+  "CA",
+  "CC",
+  "CD",
+  "CF",
+  "CG",
+  "CH",
+  "CI",
+  "CK",
+  "CL",
+  "CM",
+  "CN",
+  "CO",
+  "CR",
+  "CU",
+  "CV",
+  "CW",
+  "CX",
+  "CY",
+  "CZ",
+  "DE",
+  "DJ",
+  "DK",
+  "DM",
+  "DO",
+  "DZ",
+  "EC",
+  "EE",
+  "EG",
+  "EH",
+  "ER",
+  "ES",
+  "ET",
+  "FI",
+  "FJ",
+  "FK",
+  "FM",
+  "FO",
+  "FR",
+  "GA",
+  "GB",
+  "GD",
+  "GE",
+  "GF",
+  "GG",
+  "GH",
+  "GI",
+  "GL",
+  "GM",
+  "GN",
+  "GP",
+  "GQ",
+  "GR",
+  "GS",
+  "GT",
+  "GU",
+  "GW",
+  "GY",
+  "HK",
+  "HM",
+  "HN",
+  "HR",
+  "HT",
+  "HU",
+  "ID",
+  "IE",
+  "IL",
+  "IM",
+  "IN",
+  "IO",
+  "IQ",
+  "IR",
+  "IS",
+  "IT",
+  "JE",
+  "JM",
+  "JO",
+  "JP",
+  "KE",
+  "KG",
+  "KH",
+  "KI",
+  "KM",
+  "KN",
+  "KP",
+  "KR",
+  "KW",
+  "KY",
+  "KZ",
+  "LA",
+  "LB",
+  "LC",
+  "LI",
+  "LK",
+  "LR",
+  "LS",
+  "LT",
+  "LU",
+  "LV",
+  "LY",
+  "MA",
+  "MC",
+  "MD",
+  "ME",
+  "MF",
+  "MG",
+  "MH",
+  "MK",
+  "ML",
+  "MM",
+  "MN",
+  "MO",
+  "MP",
+  "MQ",
+  "MR",
+  "MS",
+  "MT",
+  "MU",
+  "MV",
+  "MW",
+  "MX",
+  "MY",
+  "MZ",
+  "NA",
+  "NC",
+  "NE",
+  "NF",
+  "NG",
+  "NI",
+  "NL",
+  "NO",
+  "NP",
+  "NR",
+  "NU",
+  "NZ",
+  "OM",
+  "PA",
+  "PE",
+  "PF",
+  "PG",
+  "PH",
+  "PK",
+  "PL",
+  "PM",
+  "PN",
+  "PR",
+  "PS",
+  "PT",
+  "PW",
+  "PY",
+  "QA",
+  "RE",
+  "RO",
+  "RS",
+  "RU",
+  "RW",
+  "SA",
+  "SB",
+  "SC",
+  "SD",
+  "SE",
+  "SG",
+  "SH",
+  "SI",
+  "SJ",
+  "SK",
+  "SL",
+  "SM",
+  "SN",
+  "SO",
+  "SR",
+  "SS",
+  "ST",
+  "SV",
+  "SX",
+  "SY",
+  "SZ",
+  "TC",
+  "TD",
+  "TF",
+  "TG",
+  "TH",
+  "TJ",
+  "TK",
+  "TL",
+  "TM",
+  "TN",
+  "TO",
+  "TR",
+  "TT",
+  "TV",
+  "TW",
+  "TZ",
+  "UA",
+  "UG",
+  "UM",
+  "US",
+  "UY",
+  "UZ",
+  "VA",
+  "VC",
+  "VE",
+  "VG",
+  "VI",
+  "VN",
+  "VU",
+  "WF",
+  "WS",
+  "YE",
+  "YT",
+  "ZA",
+  "ZM",
+  "ZW"
+];
+const cusip = generateCusip();
+const generateIsin = (cusip2) => {
+  const code = countryCodes[Math.floor(Math.random() * countryCodes.length)];
+  const isin = code + cusip2 + generateIsinCheckDigit(code + cusip2 + "0");
+  return isin;
+};
+const generateIsinCheckDigit = (isin) => {
+  if (isin.length != 12) return false;
+  const v = [];
+  for (let i = isin.length - 2; i >= 0; i--) {
+    const c = isin.charAt(i);
+    if (isNaN(parseInt(c))) {
+      const letterCode = isin.charCodeAt(i) - 55;
+      v.push(letterCode % 10);
+      if (letterCode > 9) {
+        v.push(Math.floor(letterCode / 10));
+      }
+    } else {
+      v.push(Number(c));
+    }
+  }
+  let sum = 0;
+  const l = v.length;
+  for (let i = 0; i < l; i++) {
+    if (i % 2 == 0) {
+      const d = v[i] * 2;
+      sum += Math.floor(d / 10);
+      sum += d % 10;
+    } else {
+      sum += v[i];
+    }
+  }
+  return (10 - sum % 10) % 10;
+};
+const isinGenerator = () => {
+  return generateIsin(cusip);
+};
+
+const currencies = ["CAD", "GBX", "USD", "EUR", "GBP"];
+
+const locations = {
+  L: ["London PLC", "XLON/LSE-SETS"],
+  N: ["Corporation", "XNGS/NAS-GSM"],
+  AS: ["B.V.", "XAMS/ENA-MAIN"],
+  OQ: ["Co.", "XNYS/NYS-MAIN"],
+  PA: ["Paris", "PAR/EUR_FR"],
+  MI: ["Milan", "MIL/EUR_IT"],
+  FR: ["Frankfurt", "FR/EUR_DE"],
+  AT: ["Athens", "AT/EUR_GR"]
+};
+const suffixes = ["L", "N", "OQ", "AS", "PA", "MI", "FR", "AT"];
+
+const lotsizes = [
+  1,
+  2,
+  5,
+  10,
+  50,
+  50,
+  70,
+  100,
+  100,
+  100,
+  120,
+  150,
+  150,
+  200,
+  500,
+  700,
+  1e3,
+  2e3,
+  2500,
+  5e3,
+  1e4
+];
+
+const InstrumentColumnMap = {
+  bbg: 0,
+  currency: 1,
+  description: 2,
+  exchange: 3,
+  string: 4,
+  number: 5,
+  ric: 6,
+  price: 7,
+  date: 8
+};
+const instrumentsData = [];
+const chars1 = Array.from("ABCEFGHKMN");
+const chars2 = Array.from("ABCEFGHKMN");
+const chars3 = Array.from("OPQRTUVWYZ");
+const chars4 = Array.from("OPQRTUVWYZ");
+const randomPrice = () => {
+  const price = random(0, 1e4);
+  const multiplier = random(1, 10);
+  return price / multiplier;
+};
+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 price = randomPrice();
+        const date = (/* @__PURE__ */ new Date()).getTime();
+        instrumentsData.push([
+          bbg,
+          currency,
+          description,
+          exchange,
+          String(isin),
+          lotSize,
+          ric,
+          price,
+          date
+        ]);
+        count++;
+      }
+    }
+  }
+}
+const getRic = (defaultRic) => {
+  const row = instrumentsData.at(random(0, instrumentsData.length));
+  return row?.[InstrumentColumnMap.ric] ?? defaultRic;
+};
+const instrumentsTable = new Table(
+  schemas$2.instruments,
+  instrumentsData,
+  buildDataColumnMap$1(schemas$2, "instruments")
+);
+
+const instrumentsExtendedData = instrumentsData.map(
+  (row) => row.slice(0, -1).concat([random(0, 1) === 1, random(0, 1) === 1, (/* @__PURE__ */ new Date()).getTime()])
+);
+const instrumentsExtendedTable = new Table(
+  schemas$2.instrumentsExtended,
+  instrumentsExtendedData,
+  buildDataColumnMap$1(schemas$2, "instrumentsExtended")
+);
+
+const sides = ["BUY", "SELL"];
+
+const traders = ["Trader A", "Trader B", "Trader C"];
+const orderStatus$1 = [
+  "Filled",
+  "Cancelled",
+  "New",
+  "Partial Exec",
+  "Booked",
+  "All Done"
+];
+const isComplete = (status) => ["Filled", "All Done", "Booked"].includes(status);
+const ordersData = [];
+const now = +/* @__PURE__ */ new Date();
+for (let i = 0; i < 100; i++) {
+  const status = orderStatus$1[random(0, orderStatus$1.length - 1)];
+  const ccy = currencies[random(0, currencies.length - 1)];
+  const created = now;
+  const lastUpdate = now;
+  const orderId = `ORD${("0000" + i).slice(-4)}`;
+  const quantity = random(1e3, 1e4);
+  const filledQuantity = isComplete(status) ? quantity : status === "New" ? 0 : random(0, quantity);
+  const ric = getRic("AAP.L");
+  const side = sides[random(0, sides.length - 1)];
+  const trader = traders[random(0, traders.length - 1)];
+  ordersData.push([
+    status,
+    ccy,
+    created,
+    filledQuantity,
+    lastUpdate,
+    orderId,
+    quantity,
+    ric,
+    side,
+    trader
+  ]);
+}
+const ordersTable = new Table(
+  schemas$2.orders,
+  ordersData,
+  buildDataColumnMap$1(schemas$2, "orders")
+);
+
+const { bid, bidSize, ask, askSize } = buildDataColumnMap$1(schemas$2, "prices");
+const pricesUpdateGenerator = new BaseUpdateGenerator({
+  bid,
+  bidSize,
+  ask,
+  askSize
+});
+const requiredInstrumentFields = ["ric", "price"];
+const pricesData = instrumentsData.map((instrument) => {
+  const { ric, price: priceSeed } = requiredInstrumentFields.reduce(
+    (obj, f) => ({ ...obj, [f]: instrument[InstrumentColumnMap[f]] }),
+    {}
+  );
+  const spread = random(0, 10);
+  const ask2 = priceSeed + spread / 2;
+  const askSize2 = random(1e3, 3e3);
+  const bid2 = priceSeed - spread / 2;
+  const bidSize2 = random(1e3, 3e3);
+  const close = priceSeed + random(0, 1) / 10;
+  const last = priceSeed + random(0, 1) / 10;
+  const open = priceSeed + random(0, 1) / 10;
+  const phase = "C";
+  const scenario = "close";
+  return [ask2, askSize2, bid2, bidSize2, close, last, open, phase, ric, scenario];
+});
+for (const [, , , lastTrade, ric] of basketConstituentData) {
+  const priceSeed = parseFloat(String(lastTrade));
+  if (!isNaN(priceSeed)) {
+    const spread = random(0, 10);
+    const ask2 = priceSeed + spread / 2;
+    const askSize2 = random(1e3, 3e3);
+    const bid2 = priceSeed - spread / 2;
+    const bidSize2 = random(1e3, 3e3);
+    const close = priceSeed + random(0, 1) / 10;
+    const last = priceSeed + random(0, 1) / 10;
+    const open = priceSeed + random(0, 1) / 10;
+    const phase = "C";
+    const scenario = "close";
+    pricesData.push([
+      ask2,
+      askSize2,
+      bid2,
+      bidSize2,
+      close,
+      last,
+      open,
+      phase,
+      ric,
+      scenario
+    ]);
+  }
+}
+const pricesTable = new Table(
+  schemas$2.prices,
+  pricesData,
+  buildDataColumnMap$1(schemas$2, "prices"),
+  pricesUpdateGenerator
+);
+
+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"
+];
+
+const orderStatus = ["NEW", "CANCELLED", "FILLED"];
+
+const algos = ["DARKLIQ", "IS", "SURESHOT", "VWAP", "LITLIQ", "TWAP"];
+
+const childOrderData = [];
+const parentOrderData = [];
+const instrumentMap = buildDataColumnMap$1(schemas$2, "instruments");
+const PARENT_ORDER_COUNT = 75e3;
+const CHILD_ORDER_COUNT = 2e5;
+const avgChildOrderPerOrder = Math.round(
+  CHILD_ORDER_COUNT / PARENT_ORDER_COUNT
+);
+const childMaxMultiple = 10;
+const start = performance.now();
+let childOrderId = 0;
+for (let i = 0; i < PARENT_ORDER_COUNT; i++) {
+  const now = +/* @__PURE__ */ new Date();
+  const instrument = instrumentsData[random(0, instrumentsData.length - 1)];
+  const orderQuantity = 1e3 * random(1, 100);
+  const orderStatus$1 = orderStatus[random(0, orderStatus.length - 1)];
+  const filledQty = orderStatus$1 === "FILLED" ? orderQuantity : orderStatus$1 === "NEW" ? 0 : orderQuantity - random(100, orderQuantity);
+  const openQty = orderQuantity - filledQty;
+  const account = accounts[random(0, accounts.length - 1)];
+  const algo = algos[random(0, algos.length - 1)];
+  const averagePrice = 0;
+  const ccy = "GBP";
+  const exchange = instrument[instrumentMap.exchange];
+  const parentOrderIdAsInt = i;
+  const parentOrderId = `${parentOrderIdAsInt}`;
+  const lastUpdate = now;
+  const price = 100;
+  const quantity = orderQuantity;
+  const ric = instrument[instrumentMap.ric];
+  const side = sides[random(0, sides.length - 1)];
+  const status = orderStatus$1;
+  const volLimit = 100;
+  const childOrderCount = random(
+    0,
+    avgChildOrderPerOrder * random(1, childMaxMultiple)
+  );
+  let remainingQty = orderQuantity;
+  for (let j = 0; j < childOrderCount; j++) {
+    const childOrderQuantity = Math.round(remainingQty / (childOrderCount - j));
+    remainingQty -= childOrderQuantity;
+    const childOrderStatus = orderStatus[random(0, orderStatus.length - 1)];
+    const childFilledQty = orderStatus$1 === "FILLED" ? childOrderQuantity : childOrderStatus === "NEW" ? 0 : childOrderQuantity - random(100, childOrderQuantity);
+    const childOpenQty = childOrderQuantity - childFilledQty;
+    const averagePrice2 = 0;
+    const childIdAsInt = childOrderId++;
+    const childId = `${childIdAsInt}`;
+    const lastUpdate2 = 0;
+    const price2 = 100;
+    const strategy = 0;
+    const row2 = [
+      account,
+      averagePrice2,
+      ccy,
+      exchange,
+      childFilledQty,
+      childId,
+      childIdAsInt,
+      lastUpdate2,
+      childOpenQty,
+      parentOrderId,
+      price2,
+      childOrderQuantity,
+      ric,
+      side,
+      childOrderStatus,
+      strategy,
+      volLimit
+    ];
+    childOrderData.push(row2);
+  }
+  const row = [
+    account,
+    algo,
+    averagePrice,
+    ccy,
+    childOrderCount,
+    exchange,
+    filledQty,
+    parentOrderId,
+    parentOrderIdAsInt,
+    lastUpdate,
+    openQty,
+    price,
+    quantity,
+    ric,
+    side,
+    status,
+    volLimit
+  ];
+  parentOrderData.push(row);
+}
+const end = performance.now();
+console.log(
+  `took ${end - start} to create ${parentOrderData.length} orders and ${childOrderData.length} child orders`
+);
+const parentOrdersTable = new Table(
+  schemas$2.parentOrders,
+  parentOrderData,
+  buildDataColumnMap$1(schemas$2, "parentOrders")
+);
+const childOrdersTable = new Table(
+  schemas$2.childOrders,
+  childOrderData,
+  buildDataColumnMap$1(schemas$2, "childOrders")
+);
+
+const undefinedTables = {
+  childOrders: void 0,
+  instruments: void 0,
+  instrumentsExtended: void 0,
+  instrumentPrices: void 0,
+  orders: void 0,
+  parentOrders: void 0,
+  prices: void 0
+};
+const tables$1 = {
+  childOrders: childOrdersTable,
+  instruments: instrumentsTable,
+  instrumentsExtended: instrumentsExtendedTable,
+  instrumentPrices: joinTables(
+    { module: "SIMUL", table: "instrumentPrices" },
+    instrumentsTable,
+    pricesTable,
+    "ric"
+  ),
+  orders: ordersTable,
+  parentOrders: parentOrdersTable,
+  prices: pricesTable
+};
+const vuuLinks = {
+  ...undefinedTables,
+  childOrders: [
+    { fromColumn: "parentOrderId", toColumn: "id", toTable: "parentOrders" }
+  ],
+  parentOrders: [
+    { fromColumn: "ric", toColumn: "ric", toTable: "instruments" }
+  ]
+};
+const menus = {
+  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",
+        rpcName: "EDIT_ROW"
+      },
+      {
+        context: "selected-rows",
+        filter: "",
+        name: "Edit Rows",
+        rpcName: "VP_BULK_EDIT_BEGIN_RPC"
+      }
+    ]
+  },
+  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
+};
+const cancelOrder = async (rpcRequest) => {
+  if (vuuUtils.isVuuMenuRpcRequest(rpcRequest)) {
+    const { rowKey, vpId } = rpcRequest;
+    const table = tables$1.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
+    };
+  } else {
+    throw Error("cancelOrder invalid rpcRequest");
+  }
+};
+const services = {
+  ...undefinedTables,
+  orders: [
+    {
+      rpcName: "CANCEL_ORDER",
+      service: cancelOrder
+    }
+  ]
+};
+const simulModule = new SimulModule({
+  menus,
+  name: "SIMUL",
+  schemas: schemas$2,
+  services,
+  tables: tables$1,
+  vuuLinks
+});
+
+const { RowGenerator } = defaultGenerators;
+const manyColumnGenerator = RowGenerator(
+  schemas$1.TwoHundredColumns.columns.map((c) => c.name)
+);
+const tables = {
+  TwoHundredColumns: new Table(
+    schemas$1.TwoHundredColumns,
+    new Array(100).fill(1).map((_, i) => manyColumnGenerator(i)),
+    buildDataColumnMap$1(schemas$1, "TwoHundredColumns")
+  )
+};
+const testModule = new VuuModule({
+  name: "TEST",
+  schemas: schemas$1,
+  tables
+});
+
+const vuuModules = {
+  BASKET: basketModule,
+  SIMUL: simulModule,
+  TEST: testModule
+};
+const vuuModule = (moduleName) => vuuModules[moduleName];
+
+const serverAPI = {
+  getTableList: async () => {
+    return {
+      tables: Object.values(schemas$2).concat(Object.values(schemas$3)).map((schema) => schema.table)
+    };
+  },
+  getTableSchema: async (vuuTable) => {
+    if (isSimulTable(vuuTable)) {
+      return schemas$2[vuuTable.table];
+    } else if (isBasketTable(vuuTable)) {
+      return schemas$3[vuuTable.table];
+    } else {
+      throw Error(
+        `unsupported module/table ${vuuTable.module}/${vuuTable.table}`
+      );
+    }
+  },
+  rpcCall: async (message) => {
+    if (message.type === "RPC_CALL" && message.service === "TypeAheadRpcHandler") {
+      const [vuuTable] = message.params;
+      if (isSimulTable(vuuTable)) {
+        const typeahead = simulModule.typeaheadHook();
+        return typeahead(message.params);
+      } else if (isBasketTable(vuuTable)) {
+        const typeahead = basketModule.typeaheadHook();
+        return typeahead(message.params);
+      }
+    }
+    throw Error("LocalDataSource provider only handles TypeAhead rpc calls");
+  }
+};
+const getServerAPI = async () => serverAPI;
+class VuuDataSource {
+  constructor({
+    aggregations,
+    columns,
+    filterSpec,
+    groupBy,
+    sort,
+    table,
+    viewport,
+    visualLink
+  }) {
+    const config = {
+      aggregations,
+      columns,
+      filterSpec,
+      groupBy,
+      sort,
+      visualLink
+    };
+    if (isSimulTable(table)) {
+      return simulModule.createDataSource(table.table, viewport, config);
+    } else if (isBasketTable(table)) {
+      return basketModule.createDataSource(table.table, viewport, config);
+    } else {
+      throw Error(`unsupported module/table ${table.module}/${table.table}`);
+    }
+  }
+}
+const LocalDataSourceProvider = ({
+  children
+}) => {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    vuuUtils.DataProvider,
+    {
+      VuuDataSource,
+      getServerAPI,
+      children
+    }
+  );
+};
+
+exports.ArrayProxy = ArrayProxy;
+exports.DefaultColumnGenerator = DefaultColumnGenerator;
+exports.DefaultRowGenerator = DefaultRowGenerator;
+exports.LocalDataSourceProvider = LocalDataSourceProvider;
+exports.Table = Table;
+exports.TickingArrayDataSource = TickingArrayDataSource;
+exports.VuuModule = VuuModule;
+exports.basketModule = basketModule;
+exports.basketSchemas = schemas$3;
+exports.buildDataColumnMap = buildDataColumnMap$1;
+exports.buildDataColumnMapFromSchema = buildDataColumnMapFromSchema;
+exports.createBasketTradingRow = createBasketTradingRow;
+exports.defaultGenerators = defaultGenerators;
+exports.getAllSchemas = getAllSchemas;
+exports.getColumnAndRowGenerator = getColumnAndRowGenerator;
+exports.getSchema = getSchema;
+exports.isBasketTable = isBasketTable;
+exports.isSimulTable = isSimulTable;
+exports.joinTables = joinTables;
+exports.makeSuggestions = makeSuggestions;
+exports.populateArray = populateArray;
+exports.schemas = schemas;
+exports.simulModule = simulModule;
+exports.simulSchemas = schemas$2;
+exports.tables = tables$2;
+exports.testModule = testModule;
+exports.vuuModule = vuuModule;
+exports.withNamedParams = withNamedParams;
+exports.withParams = withParams;
 //# sourceMappingURL=index.js.map