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

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/types/test/test-schemas.d.ts

@@ -1,3 +0,0 @@
-import { TableSchema } from "@vuu-ui/vuu-data-types";
-export type TestTableName = "TestDates" | "TwoHundredColumns" | "LinkParent" | "LinkChild";
-export declare const schemas: Readonly<Record<TestTableName, Readonly<TableSchema>>>;