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

package/types/RuntimeVisualLink.d.ts

@@ -1,7 +1,7 @@
-import { DataSource, RowSelectionEventHandler } from "@vuu-ui/vuu-data-types";
+import { DataSourceBase, DataSourceRowWithBigint, RowSelectionEventHandler } from "@vuu-ui/vuu-data-types";
 export declare class RuntimeVisualLink {
     #private;
-    constructor(childDataSource: DataSource, parentDataSource: DataSource, childColumnName: string, parentColumnName: string);
+    constructor(childDataSource: DataSourceBase<DataSourceRowWithBigint>, parentDataSource: DataSourceBase<DataSourceRowWithBigint>, childColumnName: string, parentColumnName: string);
     destroy(): void;
     remove(): void;
     handleParentSelectEvent: RowSelectionEventHandler;

package/types/Table.d.ts

@@ -4,22 +4,22 @@ import { ColumnMap, EventEmitter } from "@vuu-ui/vuu-utils";
 import { UpdateGenerator } from "./rowUpdates";
 export type TableEvents = {
     delete: (key: string) => void;
-    insert: (row: VuuRowDataItemType[]) => void;
-    update: (row: VuuRowDataItemType[], columnName?: string, sessionId?: string) => void;
+    insert: (row: Array<bigint | VuuRowDataItemType>) => void;
+    update: (row: Array<bigint | VuuRowDataItemType>, columnName?: string, sessionId?: string) => void;
 };
 export declare class Table extends EventEmitter<TableEvents> {
     #private;
-    constructor(schema: TableSchema, data: VuuRowDataItemType[][], dataMap: ColumnMap, updateGenerator?: UpdateGenerator);
+    constructor(schema: TableSchema, data: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator);
     private buildIndex;
-    get data(): VuuRowDataItemType[][];
+    get data(): (bigint | VuuRowDataItemType)[][];
     get map(): ColumnMap;
     get schema(): TableSchema;
     get name(): string;
     delete(key: string, emitEvent?: boolean): void;
-    insert(row: VuuRowDataItemType[], emitEvent?: boolean): void;
-    findByKey(key: string): VuuRowDataItemType[];
-    update(key: string, columnName: string, value: VuuRowDataItemType): void;
-    updateRow(row: VuuRowDataItemType[]): void;
+    insert(row: Array<bigint | VuuRowDataItemType>, emitEvent?: boolean): void;
+    findByKey(key: string): (bigint | VuuRowDataItemType)[];
+    update(key: string, columnName: string, value: bigint | VuuRowDataItemType): void;
+    updateRow(row: Array<bigint | VuuRowDataItemType>): void;
 }
 export declare function buildDataColumnMapFromSchema(schema: Readonly<TableSchema>): ColumnMap;
 /**

package/types/TickingArrayDataSource.d.ts

@@ -1,6 +1,6 @@
 import { ArrayDataSource, ArrayDataSourceConstructorProps } from "@vuu-ui/vuu-data-local";
-import type { DataSource, DataSourceCallbackMessage, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, EditSessionMode } from "@vuu-ui/vuu-data-types";
-import type { LinkDescriptorWithLabel, RpcResultError, RpcResultSuccess, VuuCreateVisualLink, VuuMenu, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import type { DataSourceBase, DataSourceCallbackMessage, DataSourceRowWithBigint, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, DeleteRowMode, EditSessionMode } from "@vuu-ui/vuu-data-types";
+import type { LinkDescriptorWithLabel, RpcResultError, RpcResultSuccess, SelectRequest, VuuCreateVisualLink, VuuMenu, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest, VuuTable } from "@vuu-ui/vuu-protocol-types";
 import { Range } from "@vuu-ui/vuu-utils";
 import { IVuuModule, RpcMenuService, RpcService, SessionTableMap } from "./core/module/VuuModule";
 import { Table } from "./Table";
@@ -19,7 +19,7 @@ export interface TickingArrayDataSourceConstructorProps extends Omit<ArrayDataSo
 export declare class TickingArrayDataSource extends ArrayDataSource {
     #private;
     constructor({ data, getVisualLinks, rpcServices, rpcMenuServices, sessionTables, table, menu, visualLink, visualLinkService, vuuModule, ...arrayDataSourceProps }: TickingArrayDataSourceConstructorProps);
-    updateRowWithSessionCheck: (row: VuuRowDataItemType[], columnName?: string, sessionId?: string) => void;
+    updateRowWithSessionCheck: (row: Array<bigint | VuuRowDataItemType>, columnName?: string, sessionId?: string) => void;
     subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
     unsubscribe(): void;
     set range(range: Range);
@@ -27,10 +27,29 @@ export declare class TickingArrayDataSource extends ArrayDataSource {
     set links(links: LinkDescriptorWithLabel[] | undefined);
     get links(): LinkDescriptorWithLabel[] | undefined;
     getSelectedRowIds(): string[];
+    /**
+     * Suppress row flushes from the source datasource while a session is active.
+     *
+     * `updateRowWithSessionCheck` already blocks individual row updates arriving
+     * via the table's "update" event.  However, `sendRowsToClient` can also be
+     * reached through other paths that bypass that handler:
+     *   - `setRange` (user scrolls the viewport)
+     *   - config changes (filter / sort / group-by)
+     *   - row inserts into the backing table
+     *
+     * Without this guard those paths would push source-table rows to the
+     * client and overwrite the edited session view.
+     */
+    sendRowsToClient(forceFullRefresh?: boolean, row?: DataSourceRowWithBigint): void;
+    select(selectRequest: Omit<SelectRequest, "vpId">): void;
     handleSessionMessage: (msg: DataSourceCallbackMessage) => void;
-    createSessionDataSource(sessionTable: VuuTable): DataSource;
-    beginEditSession(editSessionMode?: EditSessionMode): Promise<DataSource | undefined>;
-    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultError | RpcResultSuccess | undefined>;
+    createSessionDataSource(sessionTable: VuuTable): DataSourceBase<DataSourceRowWithBigint>;
+    beginEditSession(editSessionMode?: EditSessionMode): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultSuccess | RpcResultError | undefined>;
+    addRow: (rowData?: Record<string, VuuRowDataItemType>) => Promise<true | string>;
+    deleteRow: (key: string, mode?: DeleteRowMode) => Promise<true | string>;
+    deleteSelectedRows: (mode?: DeleteRowMode) => Promise<RpcResultSuccess | RpcResultError>;
+    undoRowChange: (key: string) => Promise<RpcResultSuccess | RpcResultError>;
     endEditSession(saveChanges?: boolean): Promise<void>;
     rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
     menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;

package/types/basket/BasketModule.d.ts

@@ -14,10 +14,6 @@ export declare class BasketModule extends VuuModule<BasketsTableName> {
     get menus(): Record<BasketsTableName, VuuMenu | undefined>;
     get schemas(): Readonly<Record<BasketsTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
     get services(): {
-        algoType: undefined;
-        basketTradingConstituent: undefined;
-        basketConstituent: undefined;
-        priceStrategyType: undefined;
         basket: {
             rpcName: string;
             service: ServiceHandler;
@@ -30,21 +26,25 @@ export declare class BasketModule extends VuuModule<BasketsTableName> {
             rpcName: string;
             service: ServiceHandler;
         }[];
+        algoType: undefined;
+        basketTradingConstituent: undefined;
+        basketConstituent: undefined;
+        priceStrategyType: undefined;
     };
     get menuServices(): Record<BasketsTableName, RpcMenuService[] | undefined> | undefined;
     get tables(): Record<BasketsTableName, Table>;
     get visualLinks(): {
+        basketConstituent: {
+            fromColumn: string;
+            toColumn: string;
+            toTable: string;
+        }[];
         algoType: undefined;
         basket: undefined;
         basketTrading: undefined;
         basketTradingConstituent: undefined;
         basketTradingConstituentJoin: undefined;
         priceStrategyType: undefined;
-        basketConstituent: {
-            fromColumn: string;
-            toColumn: string;
-            toTable: string;
-        }[];
     };
     private createTradingBasket;
     private createNewBasket;

package/types/basket/reference-data/prices.d.ts

@@ -20,5 +20,5 @@ export type PricesDataRow = [
     ric,
     scenario
 ];
-declare const pricesTable: import("../..").Table;
+declare const pricesTable: import("../../Table").Table;
 export default pricesTable;

package/types/core/module/VuuModule.d.ts

@@ -1,10 +1,10 @@
-import { DataSource, DataSourceConfig, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, TableSchema } from "@vuu-ui/vuu-data-types";
+import { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, TableSchema } from "@vuu-ui/vuu-data-types";
 import { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
 import { Table } from "../../Table";
 import { SessionTable } from "../../SessionTable";
 import { TickingArrayDataSource } from "../../TickingArrayDataSource";
 export interface IVuuModule<T extends string = string> {
-    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig) => DataSource;
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig) => DataSourceBase<DataSourceRowWithBigint>;
 }
 export type SessionTableMap = Record<string, SessionTable | Table>;
 export type ServiceHandler = (rpcRequest: VuuRpcServiceRequest) => Promise<RpcResultSuccess | RpcResultError>;
@@ -17,14 +17,19 @@ export type RpcMenuService = {
     rpcName: string;
     service: MenuServiceHandler;
 };
+export type VuuModuleOptions = {
+    /** Column written by session services (deleteRow, endEditSession) to report row-level status.
+     *  Defaults to `"vuuMsg"` which matches the column added by `sessionTableSchema`. */
+    sessionTableMessageColumn?: string;
+};
 type Subscription = {
     viewportId: string;
-    dataSource: DataSource;
+    dataSource: DataSourceBase<DataSourceRowWithBigint>;
     sessionTableName?: string;
 };
 export declare abstract class VuuModule<T extends string = string> implements IVuuModule<T> {
     #private;
-    constructor(name: string);
+    constructor(name: string, { sessionTableMessageColumn }?: VuuModuleOptions);
     protected abstract menus?: Record<T, VuuMenu | undefined> | undefined;
     protected abstract schemas: Record<T, Readonly<TableSchema>>;
     protected abstract tables: Record<T, Table>;
@@ -37,11 +42,11 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     protected unregisterViewport: (viewportId: string) => void;
     get name(): string;
     getSubscriptionByViewport(viewportId: string): Subscription;
-    getSubscribedDataSource(vpId: string): DataSource;
+    getSubscribedDataSource(vpId: string): DataSourceBase<DataSourceRowWithBigint>;
     getLinks: (subscriptionMap: Map<string, Subscription[]>, vuuLinks: VuuLink[]) => LinkDescriptorWithLabel[];
     visualLinkService: (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | void>;
     getVisualLinks: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
-    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig) => DataSource;
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig) => DataSourceBase<DataSourceRowWithBigint>;
     getServices(tableName: T): RpcService[];
     getMenuServices(tableName: T): RpcMenuService[];
     protected get sessionTableMap(): SessionTableMap;
@@ -49,6 +54,8 @@ export declare abstract class VuuModule<T extends string = string> implements IV
     protected getSessionTable(sessionTableName: string, throwIfNotFound: true): SessionTable;
     protected getSessionTable(sessionTableName: string, throwIfNotFound: false): SessionTable | undefined;
     protected deleteRow: ServiceHandler;
+    private deleteSelectedRows;
+    private undoRowChange;
     private getColumnDescriptors;
     private editCell;
     private beginEditSessionMenuHandler;

package/types/core/table/TableContainer.d.ts

@@ -7,7 +7,7 @@ declare class TableContainer {
     #private;
     private constructor();
     static get instance(): TableContainer;
-    createTable: (schema: TableSchema, data: VuuRowDataItemType[][], dataMap: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
+    createTable: (schema: TableSchema, data: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
     createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
     addTable(table: Table): void;
     getTable<T = Table>(tableName: string): NonNullable<T>;

package/types/data-utils.d.ts

@@ -4,3 +4,4 @@ export type PriceGenerator = (min: number, max: number) => number;
 export declare const nextRandomDouble: PriceGenerator;
 export declare const initBidAsk: (priceMaxDelta: number, nextRandomDouble: PriceGenerator) => number[];
 export declare const generateNextBidAsk: (bid: number, ask: number, spreadMultipler: number, priceMaxDelta: number, nextRandomDouble: PriceGenerator) => number[];
+export declare const withNanoMs: (ts: number, nanos?: number) => bigint;

package/types/default-column-definitions.d.ts

@@ -0,0 +1,2 @@
+import { SchemaColumn } from "@vuu-ui/vuu-data-types";
+export declare const VUU_DEFAULT_COLUMNS: SchemaColumn[];

package/types/makeSuggestions.d.ts

@@ -1,2 +1,3 @@
 import { DataSourceRow } from "@vuu-ui/vuu-data-types";
-export declare const makeSuggestions: (data: DataSourceRow[], columnIndex: number, pattern?: string) => Promise<string[]>;
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+export declare const makeSuggestions: (data: DataSourceRow<bigint | VuuRowDataItemType>[], columnIndex: number, pattern?: string) => Promise<string[]>;

package/types/schemas.d.ts

@@ -1,7 +1,7 @@
 import { TableSchema } from "@vuu-ui/vuu-data-types";
 import { type BasketsTableName } from "./basket/basket-schemas";
 import { type SimulTableName } from "./simul/simul-schemas";
-import { type TestTableName } from "./test/test-schemas";
+import { TestTableName } from "./test/TestModule";
 export type VuuTableName = BasketsTableName | SimulTableName | TestTableName;
 export declare const schemas: Record<VuuTableName, TableSchema>;
 export declare const getAllSchemas: () => Record<VuuTableName, TableSchema>;

package/types/simul/reference-data/instruments-extended.d.ts

@@ -1 +1 @@
-export declare const instrumentsExtendedTable: import("../..").Table;
+export declare const instrumentsExtendedTable: import("../../Table").Table;

package/types/simul/reference-data/instruments.d.ts

@@ -14,7 +14,8 @@ export type InstrumentsDataRow = [
     number,
     ric,
     date,
-    date
+    date,
+    string
 ];
 export declare const InstrumentColumnMap: {
     readonly bbg: 0;
@@ -26,8 +27,9 @@ export declare const InstrumentColumnMap: {
     readonly ric: 6;
     readonly vuuCreatedTimestamp: 7;
     readonly vuuUpdatedTimestamp: 8;
+    readonly vuuMsg: 9;
 };
 declare const instrumentsData: InstrumentsDataRow[];
 export declare const getRic: (defaultRic: string) => string;
-export declare const instrumentsTable: import("../..").Table;
+export declare const instrumentsTable: import("../../Table").Table;
 export { instrumentsData };

package/types/simul/reference-data/orders.d.ts

@@ -32,5 +32,5 @@ export declare const OrderColumnMap: {
     readonly trader: 8;
 };
 declare const ordersData: OrdersDataRow[];
-export declare const ordersTable: import("../..").Table;
+export declare const ordersTable: import("../../Table").Table;
 export { ordersData };

package/types/simul/reference-data/parent-child-orders.d.ts

@@ -1,4 +1,4 @@
-export declare const parentOrdersTable: import("../..").Table;
-export declare const childOrdersTable: import("../..").Table;
+export declare const parentOrdersTable: import("../../Table").Table;
+export declare const childOrdersTable: import("../../Table").Table;
 export declare function startGeneratingNewOrders(): void;
 export declare function stopGeneratingNewOrders(): void;

package/types/simul/reference-data/prices.d.ts

@@ -10,6 +10,7 @@ type ric = string;
 type scenario = "close";
 type lastUpdate = number;
 type created = number;
+type vuuMsg = string;
 export type PricesDataRow = [
     ask,
     askSize,
@@ -22,11 +23,12 @@ export type PricesDataRow = [
     ric,
     scenario,
     lastUpdate,
-    created
+    created,
+    vuuMsg
 ];
 declare const bid: number, bidSize: number, ask: number, askSize: number;
 declare const lastUpdate: number;
 declare const created: number;
 declare const pricesData: Array<PricesDataRow>;
-export declare const pricesTable: import("../..").Table;
+export declare const pricesTable: import("../../Table").Table;
 export { pricesData };

package/types/test/TestModule.d.ts

@@ -1,13 +1,14 @@
 import { RpcMenuService, VuuModule } from "../core/module/VuuModule";
 import { Table } from "../Table";
-import { TestTableName } from "./test-schemas";
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+export type TestTableName = "TestDates" | "TwoHundredColumns" | "LinkParent" | "LinkChild" | "ChartTable";
 declare class TestModule extends VuuModule<TestTableName> {
     #private;
     constructor();
     get menus(): undefined;
     get services(): undefined;
     get menuServices(): Record<TestTableName, RpcMenuService[] | undefined> | undefined;
-    get schemas(): Readonly<Record<TestTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
+    get schemas(): Record<TestTableName, TableSchema>;
     get tables(): Record<TestTableName, Table>;
     get visualLinks(): undefined;
 }

package/types/test/index.d.ts

@@ -1,2 +1 @@
-export { type TestTableName } from "./test-schemas";
 export * from "./TestModule";

package/src/ArrayProxy.js

@@ -1,38 +0,0 @@
-class ArrayProxy {
-    #getItem;
-    length = 0;
-    constructor(size, getRow){
-        this.#getItem = getRow;
-        this.length = size;
-        const handler = {
-            get: (target, prop)=>{
-                if ("length" === prop) return target.length;
-                if ("slice" === prop) return target.slice;
-                if ("map" === prop) return target.map;
-                if ("toString" === prop) return "[ArrayProxy]";
-                if ("string" == typeof prop) {
-                    const index = parseInt(prop, 10);
-                    if (!isNaN(index)) if (index < this.length) return target.#getItem(index);
-                    else return;
-                }
-                throw Error(`unsupported property ${String(prop)} on ArrayProxy`);
-            },
-            set: (target, prop, newVal)=>{
-                if ("length" === prop) {
-                    target.length = newVal;
-                    return true;
-                }
-                throw Error("ArrayProxy is immutable except for length");
-            }
-        };
-        return new Proxy(this, handler);
-    }
-    map = (func)=>new ArrayProxy(this.length, (i)=>func(this.#getItem(i), i));
-    slice = (from, to)=>{
-        const out = [];
-        const end = Math.min(this.length, to);
-        for(let i = from; i < end; i++)out.push(this.#getItem(i));
-        return out;
-    };
-}
-export { ArrayProxy };

package/src/RuntimeVisualLink.js

@@ -1,45 +0,0 @@
-import { buildColumnMap } from "@vuu-ui/vuu-utils";
-class RuntimeVisualLink {
-    #childColumnName;
-    #childDataSource;
-    #parentColumnName;
-    #parentDataSource;
-    constructor(childDataSource, parentDataSource, childColumnName, parentColumnName){
-        this.#childColumnName = childColumnName;
-        this.#childDataSource = childDataSource;
-        this.#parentColumnName = parentColumnName;
-        this.#parentDataSource = parentDataSource;
-        parentDataSource.on("row-selection", this.handleParentSelectEvent);
-    }
-    destroy() {}
-    remove() {
-        this.#parentDataSource?.removeListener("row-selection", this.handleParentSelectEvent);
-        this.#childDataSource.baseFilter = {
-            filter: ""
-        };
-    }
-    handleParentSelectEvent = ()=>{
-        if (this.#childDataSource) {
-            const selectedValues = this.pickUniqueSelectedValues();
-            if (0 === selectedValues.length) this.#childDataSource.baseFilter = void 0;
-            else if (1 === selectedValues.length) this.#childDataSource.baseFilter = {
-                filter: `${this.#childColumnName} = "${selectedValues[0]}"`
-            };
-            else this.#childDataSource.baseFilter = {
-                filter: `${this.#childColumnName} in ["${selectedValues.join('","')}"]`
-            };
-        }
-    };
-    pickUniqueSelectedValues() {
-        const dataSource = this.#parentDataSource;
-        const map = buildColumnMap(dataSource.columns);
-        const colIndex = map[this.#parentColumnName];
-        const set = new Set();
-        for (const key of dataSource.getSelectedRowIds()){
-            const row = dataSource.getRowByKey(key);
-            if (row) set.add(row[colIndex]);
-        }
-        return Array.from(set);
-    }
-}
-export { RuntimeVisualLink };

package/src/SessionTable.js

@@ -1,49 +0,0 @@
-import { EventEmitter } from "@vuu-ui/vuu-utils";
-const isProxy = Symbol("proxy-session-table");
-const isProxySessionTable = (table)=>table[isProxy];
-const SessionTable = (table, sessionId)=>{
-    const updates = new Map();
-    const eventEmitter = new EventEmitter();
-    const getSessionUpdates = ()=>updates;
-    const addEventListener = (event, handler)=>{
-        eventEmitter.on(event, handler);
-    };
-    const update = (key, columnName, value)=>{
-        const row = table.findByKey(key);
-        if (row) {
-            const tsIndex = table.map.vuuUpdatedTimestamp;
-            let updatesForRow = updates.get(key);
-            if (void 0 === updatesForRow) {
-                updatesForRow = {
-                    lastUpdateTimestamp: row[tsIndex],
-                    cellUpdates: {}
-                };
-                updates.set(key, updatesForRow);
-            }
-            updatesForRow.cellUpdates[columnName] = value;
-            const newRow = row.slice();
-            for (const [columnName, value] of Object.entries(updatesForRow.cellUpdates)){
-                const colIndex = table.map[columnName];
-                newRow[colIndex] = value;
-            }
-            eventEmitter.emit("update", newRow, columnName, sessionId);
-        } else console.warn(`SessionTable update row ${key} not found`);
-    };
-    return new Proxy(table, {
-        get (_obj, prop) {
-            if ("symbol" == typeof prop) {
-                if (prop === isProxy) return true;
-                return;
-            }
-            if ("getSessionUpdates" === prop) return getSessionUpdates;
-            if ("on" === prop || "addEventListener" === prop) return addEventListener;
-            if ("update" === prop) return update;
-            if ("isProxy" === prop) return true;
-            return table[prop];
-        },
-        set () {
-            throw new TypeError("SessionTable is readonly");
-        }
-    });
-};
-export { SessionTable, isProxySessionTable };

package/src/Table.js

@@ -1,96 +0,0 @@
-import { EventEmitter } from "@vuu-ui/vuu-utils";
-class Table extends EventEmitter {
-    #data;
-    #dataMap;
-    #indexOfKey;
-    #index = new Map();
-    #schema;
-    constructor(schema, data, dataMap, updateGenerator){
-        super();
-        this.#data = data;
-        this.#dataMap = dataMap;
-        this.#schema = schema;
-        this.#indexOfKey = dataMap[schema.key];
-        this.buildIndex();
-        updateGenerator?.setTable(this);
-        updateGenerator?.setRange({
-            from: 0,
-            to: 100
-        });
-    }
-    buildIndex() {
-        for(let i = 0; i < this.#data.length; i++){
-            const key = this.#data[i][this.#indexOfKey];
-            this.#index.set(key, i);
-        }
-    }
-    get data() {
-        return this.#data;
-    }
-    get map() {
-        return this.#dataMap;
-    }
-    get schema() {
-        return this.#schema;
-    }
-    get name() {
-        return this.#schema.table.table;
-    }
-    delete(key, emitEvent = true) {
-        const index = this.#index.get(key) ?? -1;
-        if (-1 !== index) {
-            this.#index.delete(key);
-            this.#data.splice(index, 1);
-            for(let i = index; i < this.#data.length; i++)this.#index.set(this.#data[i][this.#indexOfKey], i);
-            if (emitEvent) this.emit("delete", key);
-        } else throw Error(`[Table] delete key ${key} not found`);
-    }
-    insert(row, emitEvent = true) {
-        const index = this.#data.length;
-        this.#data.push(row);
-        const key = row[this.#indexOfKey];
-        this.#index.set(key, index);
-        if (emitEvent) this.emit("insert", row);
-    }
-    findByKey(key) {
-        const index = this.#index.get(key) ?? -1;
-        return this.#data[index];
-    }
-    update(key, columnName, value) {
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
-        const colIndex = this.#dataMap[columnName];
-        if (-1 !== rowIndex) {
-            const row = this.#data[rowIndex];
-            const newRow = row.slice();
-            newRow[colIndex] = value;
-            const tsIndex = this.#dataMap.vuuUpdatedTimestamp;
-            if ("number" == typeof tsIndex) {
-                const lastUpdated = Date.now();
-                newRow[tsIndex] = lastUpdated;
-            }
-            this.#data[rowIndex] = newRow;
-            this.emit("update", newRow, columnName);
-        }
-    }
-    updateRow(row) {
-        const key = row[this.#indexOfKey];
-        const rowIndex = this.#data.findIndex((row)=>row[this.#indexOfKey] === key);
-        if (-1 !== rowIndex) {
-            const tsIndex = this.#dataMap.vuuUpdatedTimestamp;
-            const lastUpdated = Date.now();
-            row[tsIndex] = lastUpdated;
-            this.#data[rowIndex] = row;
-            this.emit("update", row);
-        }
-    }
-}
-function buildDataColumnMapFromSchema(schema) {
-    return Object.values(schema.columns).reduce((map, col, index)=>({
-            ...map,
-            [col.name]: index
-        }), {});
-}
-function buildDataColumnMap(schemas, tableName) {
-    return buildDataColumnMapFromSchema(schemas[tableName]);
-}
-export { Table, buildDataColumnMap, buildDataColumnMapFromSchema };