@vuu-ui/vuu-data-test 4.0.0-beta.6 → 4.0.0

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "4.0.0-beta.6",
+  "version": "4.0.0",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
@@ -9,13 +9,13 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "dependencies": {
-    "@vuu-ui/vuu-data-local": "4.0.0-beta.6",
-    "@vuu-ui/vuu-utils": "4.0.0-beta.6"
+    "@vuu-ui/vuu-data-local": "4.0.0",
+    "@vuu-ui/vuu-utils": "4.0.0"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "4.0.0-beta.6",
-    "@vuu-ui/vuu-data-types": "4.0.0-beta.6",
-    "@vuu-ui/vuu-table-types": "4.0.0-beta.6"
+    "@vuu-ui/vuu-protocol-types": "4.0.0",
+    "@vuu-ui/vuu-data-types": "4.0.0",
+    "@vuu-ui/vuu-table-types": "4.0.0"
   },
   "sideEffects": false,
   "files": [

package/src/core/module/VuuModule.js

@@ -265,9 +265,7 @@ class VuuModule {
                     sessionTable.delete(key);
                     return {
                         type: "SUCCESS_RESULT",
-                        data: {
-                            wasInsertedRow: true
-                        }
+                        data: void 0
                     };
                 }
                 if ("deleteRow" === action || "editCell" === action) {

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

@@ -1,12 +1,63 @@
-import { random } from "../../data-utils.js";
 import { buildDataColumnMap } from "../../Table.js";
 import { schemas } from "../simul-schemas.js";
-import { instrumentsData } from "./instruments.js";
+import { InstrumentColumnMap, instrumentsData } from "./instruments.js";
 import TableContainer from "../../core/table/TableContainer.js";
-const instrumentsExtendedData = instrumentsData.map((row)=>row.slice(0, -1).concat([
-        1 === random(0, 1),
-        1 === random(0, 1),
-        new Date().getTime()
-    ]));
+const createRandom = (seed)=>()=>{
+        seed = seed + 0x6d2b79f5 | 0;
+        let t = Math.imul(seed ^ seed >>> 15, 1 | seed);
+        t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+        return ((t ^ t >>> 14) >>> 0) / 4294967296;
+    };
+const randomInt = (next, min, max)=>Math.floor(next() * (max - min + 1)) + min;
+const toScaledDecimal = (value, decimals)=>String(Math.round(value * 10 ** decimals));
+const scaledDecimalEdgeCases = (decimals)=>[
+        "0",
+        toScaledDecimal(-1234.5, decimals),
+        toScaledDecimal(100, decimals),
+        "1",
+        "-1",
+        toScaledDecimal(1.5, decimals)
+    ];
+const scaledDecimalColumn = (seed, decimals, min, max)=>{
+    const next = createRandom(seed);
+    const edgeCases = scaledDecimalEdgeCases(decimals);
+    const scale = 10 ** decimals;
+    return (rowIndex)=>rowIndex < edgeCases.length ? edgeCases[rowIndex] : String(randomInt(next, min * scale, max * scale));
+};
+const nextNotional = scaledDecimalColumn(2, 2, -1000000, 10000000);
+const nextClosePrice = scaledDecimalColumn(4, 4, 0, 5000);
+const nextFxRate = scaledDecimalColumn(6, 6, 0.5, 2);
+const nextWeight = scaledDecimalColumn(8, 8, 0, 0.05);
+const nextRandom = createRandom(1);
+const ONE_DAY = 86400000;
+const today = new Date();
+today.setHours(0, 0, 0, 0);
+const startOfToday = today.getTime();
+const columns = schemas.instrumentsExtended.columns;
+const instrumentsExtendedData = instrumentsData.map((instrument, rowIndex)=>{
+    const values = {
+        bbg: instrument[InstrumentColumnMap.bbg],
+        currency: instrument[InstrumentColumnMap.currency],
+        description: instrument[InstrumentColumnMap.description],
+        exchange: instrument[InstrumentColumnMap.exchange],
+        isin: instrument[InstrumentColumnMap.string],
+        lotSize: instrument[InstrumentColumnMap.number],
+        ric: instrument[InstrumentColumnMap.ric],
+        side: nextRandom() < 0.5 ? "B" : "S",
+        supported: nextRandom() < 0.5,
+        wishlist: nextRandom() < 0.5,
+        lastUpdated: instrument[InstrumentColumnMap.vuuUpdatedTimestamp],
+        price: Math.round(100000 * nextRandom()) / 100,
+        notional: nextNotional(rowIndex),
+        closePrice: nextClosePrice(rowIndex),
+        fxRate: nextFxRate(rowIndex),
+        weight: nextWeight(rowIndex),
+        tradeDate: startOfToday - rowIndex % 30 * ONE_DAY,
+        vuuCreatedTimestamp: instrument[InstrumentColumnMap.vuuCreatedTimestamp],
+        vuuUpdatedTimestamp: instrument[InstrumentColumnMap.vuuUpdatedTimestamp],
+        vuuMsg: ""
+    };
+    return columns.map(({ name })=>values[name]);
+});
 const instrumentsExtendedTable = TableContainer.createTable(schemas.instrumentsExtended, instrumentsExtendedData, buildDataColumnMap(schemas, "instrumentsExtended"));
 export { instrumentsExtendedTable };

package/src/simul/simul-schemas.js

@@ -73,6 +73,10 @@ const schemas = {
                 name: "ric",
                 serverDataType: "string"
             },
+            {
+                name: "side",
+                serverDataType: "char"
+            },
             {
                 name: "supported",
                 serverDataType: "boolean"
@@ -90,8 +94,24 @@ const schemas = {
                 serverDataType: "double"
             },
             {
-                name: "date",
-                serverDataType: "long"
+                name: "notional",
+                serverDataType: "scaleddecimal2"
+            },
+            {
+                name: "closePrice",
+                serverDataType: "scaleddecimal4"
+            },
+            {
+                name: "fxRate",
+                serverDataType: "scaleddecimal6"
+            },
+            {
+                name: "weight",
+                serverDataType: "scaleddecimal8"
+            },
+            {
+                name: "tradeDate",
+                serverDataType: "epochtimestamp"
             },
             ...VUU_DEFAULT_COLUMNS
         ],

package/types/core/filter/PermissionFilter.d.ts

@@ -0,0 +1,41 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { VuuModuleUser } from "../user/CurrentUser";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type tableContainer from "../table/TableContainer";
+export type TableRow = Array<bigint | VuuRowDataItemType>;
+export type RowPredicate = (row: TableRow) => boolean;
+/**
+ * Read access to a single row, by column name.
+ */
+export interface RowData {
+    get: (columnName: string) => bigint | VuuRowDataItemType | undefined;
+}
+/**
+ * Restricts the rows of a table visible through a viewport, typically
+ * based on the user that owns the viewport. Permission filters are applied
+ * in addition to any client filter.
+ */
+export interface PermissionFilter {
+    /**
+     * Bind this permission filter to the column layout of a table, returning a
+     * predicate that can be evaluated against raw table rows.
+     */
+    createPredicate: (columnMap: ColumnMap) => RowPredicate;
+}
+/**
+ * The subset of viewport state available to a PermissionFunction.
+ */
+export interface PermissionViewport {
+    id: string;
+    user: VuuModuleUser;
+}
+export type TableContainer = typeof tableContainer;
+/**
+ * Creates the PermissionFilter for a viewport. Configured per table on a VuuModule.
+ */
+export type PermissionFunction = (viewport: PermissionViewport, tableContainer: TableContainer) => PermissionFilter;
+export declare const AllowAllPermissionFilter: PermissionFilter;
+export declare const DenyAllPermissionFilter: PermissionFilter;
+export declare function PermissionFilter(rowPredicate: (row: RowData) => boolean): PermissionFilter;
+export declare function PermissionFilter(columnName: string, allowedValues: Set<string>): PermissionFilter;
+export declare function PermissionFilter(filters: Iterable<PermissionFilter>): PermissionFilter;

package/types/core/filter/PermissionFilteredTable.d.ts

@@ -0,0 +1,24 @@
+import { Table } from "../../Table";
+import type { RowPredicate } from "./PermissionFilter";
+/**
+ * A per-viewport view of a source table, containing only those rows that
+ * satisfy a permission predicate. Changes to the source table are mirrored,
+ * an update that moves a row into or out of the permitted set is emitted as
+ * an insert or delete.
+ */
+export declare class PermissionFilteredTable extends Table {
+    #private;
+    constructor(source: Table, predicate: RowPredicate);
+    get source(): Table;
+    /**
+     * Start mirroring changes from the source table. Invoked on construction,
+     * only needs to be called again following dispose.
+     */
+    attach(): void;
+    dispose(): void;
+    private contains;
+    private handleSourceInsert;
+    private handleSourceUpdate;
+    private handleSourceDelete;
+    private replaceRow;
+}

package/types/core/user/CurrentUser.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The user that owns a viewport, as seen by permission functions and
+ * rpc services.
+ */
+export interface VuuModuleUser {
+    authorizations: string[];
+    name: string;
+}
+export declare const getCurrentUser: () => VuuModuleUser;
+/**
+ * Applies to viewports created after the change. Pass undefined to restore
+ * the default user.
+ */
+export declare const setCurrentUser: (user?: string | VuuModuleUser) => void;

package/types/module-admin/ModuleAdminModule.d.ts

@@ -0,0 +1,32 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
+import { type Table } from "../Table";
+import { type ModuleAdminTableName } from "./module-admin-schemas";
+import { type ModuleAdminSnapshot } from "./snapshot-projection";
+type ModuleAdminTables = Record<ModuleAdminTableName, Table>;
+export declare const MODULE_ADMIN_INITIAL_SNAPSHOT: ModuleAdminSnapshot;
+/**
+ * In-browser MODULE_DISCOVERY server. Supports the module admin RPCs from
+ * `@heswell/module-admin/contracts` on both tables; state is held in memory.
+ */
+export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
+    #private;
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
+    get menus(): {
+        modulePermissions: undefined;
+        modules: undefined;
+    };
+    protected get includeDefaultServices(): boolean;
+    get menuServices(): undefined;
+    get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
+    get tables(): ModuleAdminTables;
+    get visualLinks(): undefined;
+}
+export declare const moduleAdminModule: ModuleAdminModule;
+export {};

package/types/module-admin/index.d.ts

@@ -0,0 +1,4 @@
+export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, moduleAdminModule, } from "./ModuleAdminModule";
+export { MODULE_ADMIN_MODULE_NAME, MODULE_ADMIN_TABLE_SCHEMAS, type ModuleAdminTableName, } from "./module-admin-schemas";
+export { projectModuleAdminSnapshot, reconcileModuleAdminTables, type ModuleAdminSnapshot, } from "./snapshot-projection";
+export type { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";

package/types/module-admin/module-admin-schemas.d.ts

@@ -0,0 +1,4 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export declare const MODULE_ADMIN_MODULE_NAME = "MODULE_DISCOVERY";
+export type ModuleAdminTableName = "modules" | "modulePermissions";
+export declare const MODULE_ADMIN_TABLE_SCHEMAS: Readonly<Record<ModuleAdminTableName, Readonly<TableSchema>>>;

package/types/module-admin/snapshot-projection.d.ts

@@ -0,0 +1,13 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "../Table";
+import type { ModuleAdminTableName } from "./module-admin-schemas";
+type Row = Array<bigint | VuuRowDataItemType>;
+type Tables = Record<ModuleAdminTableName, Table>;
+export type ModuleAdminSnapshot = {
+    modules: readonly ManagedModule[];
+};
+export declare const projectModuleAdminSnapshot: (snapshot: ModuleAdminSnapshot, tables: Tables) => Record<ModuleAdminTableName, Row[]>;
+/** Brings the tables into line with the snapshot, emitting row-level updates. */
+export declare const reconcileModuleAdminTables: (snapshot: ModuleAdminSnapshot, tables: Tables) => void;
+export {};

package/types/notifications/NotificationModule.d.ts

@@ -0,0 +1,60 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { type RpcService, VuuModule } from "../core/module/VuuModule";
+import type { PermissionFunction } from "../core/filter/PermissionFilter";
+import { type Table } from "../Table";
+import { type ColumnDefinition } from "./NotificationsSchema";
+export type NotificationsTableName = "notifications";
+/**
+ * Source of notifications. Started when the first dataSource is
+ * created for the notifications table, or explicitly via module.start().
+ */
+export interface NotificationsProvider {
+    start: () => void;
+    stop: () => void;
+}
+export type NotificationsProviderFactory = (table: Table) => NotificationsProvider;
+/**
+ * A notification to publish. Values are keyed by column name; columns not
+ * supplied are defaulted. `expiryTime` (epoch ms) schedules deletion of the row.
+ */
+export interface NotificationInput {
+    id?: string;
+    type?: string;
+    expiryTime?: number;
+    title?: string;
+    message?: string;
+    level?: string;
+    audience?: string;
+    [columnName: string]: VuuRowDataItemType | undefined;
+}
+export type NotificationsServiceFactory = (table: Table, module: NotificationModule) => RpcService[];
+/**
+ * A generic Notifications module, exposing a single 'notifications' table.
+ * The source of notifications (provider), the rows visible to each user
+ * (permissionFunction) and any rpc services (serviceFactory) are supplied
+ * by the consumer. Any additional columns are appended to the generic
+ * notification columns (see NotificationsSchema).
+ */
+export declare class NotificationModule extends VuuModule<NotificationsTableName> {
+    #private;
+    static readonly NAME = "NOTIFICATIONS";
+    static readonly TABLE_NAME: "notifications";
+    constructor(providerFactory: NotificationsProviderFactory, permissionFunction: PermissionFunction, serviceFactory: NotificationsServiceFactory, ...additionalColumns: ColumnDefinition[]);
+    protected beforeCreateDataSource(): void;
+    /**
+     * Inserts a notification row, as a server-side publisher would. Defaults:
+     * a random `id`, `type` "toast", `level` "INFO", `audience` "all" and
+     * empty strings for other string columns. Returns the row id.
+     */
+    publish(notification?: NotificationInput): string;
+    get isRunning(): boolean;
+    start(): void;
+    stop(): void;
+    get menus(): undefined;
+    get menuServices(): undefined;
+    get schemas(): Record<"notifications", TableSchema>;
+    get services(): Record<"notifications", RpcService[]>;
+    get tables(): Record<"notifications", Table>;
+    get visualLinks(): undefined;
+}

package/types/notifications/NotificationsSchema.d.ts

@@ -0,0 +1,20 @@
+import type { SchemaColumn } from "@vuu-ui/vuu-data-types";
+/**
+ * Accepts either a SchemaColumn or a column definition in the Scala server
+ * 'name:Type' format, e.g. "source:String", "priority:Int".
+ */
+export type ColumnDefinition = SchemaColumn | string;
+export declare const toColumn: (columnDefinition: ColumnDefinition) => SchemaColumn;
+export declare const NotificationsSchema: {
+    Id: string;
+    Type: string;
+    ExpiryTime: string;
+    Title: string;
+    Message: string;
+    Level: string;
+    Audience: string;
+    /**
+     * The generic notification columns, plus any additional columns.
+     */
+    allFrom: (...additionalColumns: ColumnDefinition[]) => SchemaColumn[];
+};

package/types/notifications/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./NotificationModule";
+export * from "./NotificationsSchema";
+export * from "./simulated/DismissNotificationRpcHandler";
+export * from "./simulated/SimulatedNotificationsModule";
+export * from "./simulated/SimulatedNotificationsProvider";
+export * from "./simulated/notificationsModule";

package/types/notifications/simulated/DismissNotificationRpcHandler.d.ts

@@ -0,0 +1,8 @@
+import type { RpcService } from "../../core/module/VuuModule";
+import type { Table } from "../../Table";
+import type { NotificationModule } from "../NotificationModule";
+/**
+ * Marks the notifications selected in the requesting viewport as dismissed
+ * by the user that owns the viewport.
+ */
+export declare const DismissNotificationRpcHandler: (table: Table, module: NotificationModule) => RpcService[];

package/types/notifications/simulated/SimulatedNotificationsModule.d.ts

@@ -0,0 +1,9 @@
+import { NotificationModule } from "../NotificationModule";
+export interface SimulatedNotificationsModuleOptions {
+    /**
+     * Generate random notifications. When false, notifications are only
+     * created by calls to `publish`. Default true.
+     */
+    simulate?: boolean;
+}
+export declare const SimulatedNotificationsModule: ({ simulate, }?: SimulatedNotificationsModuleOptions) => NotificationModule;

package/types/notifications/simulated/SimulatedNotificationsProvider.d.ts

@@ -0,0 +1,21 @@
+import type { Table } from "../../Table";
+import type { NotificationsProvider } from "../NotificationModule";
+/**
+ * Minimal implementation of the subset of Java String.format used by
+ * the message templates: %d, %0nd and %%. Args are consumed in order.
+ */
+export declare const formatMessage: (format: string, ...args: number[]) => string;
+/**
+ * Generates random notifications. Seeds an initial set of notifications on
+ * start then, on each cycle, deletes expired notifications and adds a new
+ * notification if fewer than the maximum are active.
+ */
+export declare class SimulatedNotificationsProvider implements NotificationsProvider {
+    #private;
+    constructor(table: Table);
+    start(): void;
+    stop(): void;
+    runOnce: () => void;
+    private generateRandomNotification;
+    private toDataRow;
+}

package/types/notifications/simulated/notificationsModule.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Simulated notifications. The provider starts generating notifications
+ * when the first dataSource is created for the notifications table.
+ */
+export declare const notificationsModule: import("..").NotificationModule;

package/types/src/ArrayProxy.d.ts

@@ -0,0 +1,8 @@
+export type RowAtIndexFunc<T = unknown> = (index: number) => T | undefined;
+export declare class ArrayProxy<T = string> {
+    #private;
+    length: number;
+    constructor(size: number, getRow: RowAtIndexFunc);
+    map: (func: (item: T, i: number) => unknown) => ArrayProxy<string>;
+    slice: (from: number, to: number) => unknown[];
+}

package/types/src/RuntimeVisualLink.d.ts

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

package/types/src/Table.d.ts

@@ -0,0 +1,34 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap, EventEmitter } from "@vuu-ui/vuu-utils";
+import { UpdateGenerator } from "./rowUpdates";
+export type TableEvents = {
+    delete: (key: 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: Array<Array<VuuRowDataItemType | bigint>>, dataMap: ColumnMap, updateGenerator?: UpdateGenerator);
+    private buildIndex;
+    get data(): (bigint | VuuRowDataItemType)[][];
+    get map(): ColumnMap;
+    get schema(): TableSchema;
+    get name(): string;
+    delete(key: string, emitEvent?: boolean): 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;
+/**
+ * Build a data ColumnMap for a table in the provided schema.
+ * A data ColumnMap is a mapping from a raw data array to a map, keyed
+ * by column name with no additional metadata.
+ *
+ * @param schemas
+ * @param tableName
+ * @returns
+ */
+export declare function buildDataColumnMap<TableName extends string = string>(schemas: Readonly<Record<TableName, Readonly<TableSchema>>>, tableName: TableName): ColumnMap;

package/types/src/TickingArrayDataSource.d.ts

@@ -0,0 +1,44 @@
+import { ArrayDataSource, type ArrayDataSourceConstructorProps } from "@vuu-ui/vuu-data-local";
+import type { DataSourceBase, DataSource, DataSourceRowWithBigint, DataSourceSubscribeCallback, DataSourceSubscribeProps, DataSourceVisualLinkCreatedMessage, DeleteRowMode, CopyOption, EditSessionMode, SessionDataSourceOverrides, SessionType } from "@vuu-ui/vuu-data-types";
+import type { LinkDescriptorWithLabel, RpcResult, RpcResultError, RpcResultSuccess, VuuCreateVisualLink, VuuMenu, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
+import type { IVuuModule, RpcMenuService, RpcService } from "./core/module/VuuModule";
+import type { Table } from "./Table";
+export type VisualLinkHandler = (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | void>;
+export interface TickingArrayDataSourceConstructorProps extends Omit<ArrayDataSourceConstructorProps, "data"> {
+    data?: Array<VuuRowDataItemType[]>;
+    getVisualLinks?: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
+    menu?: VuuMenu;
+    rpcMenuServices?: RpcMenuService[];
+    rpcServices?: RpcService[];
+    table?: Table;
+    visualLinkService?: VisualLinkHandler;
+    vuuModule?: IVuuModule;
+}
+export declare class TickingArrayDataSource extends ArrayDataSource {
+    #private;
+    constructor({ data, getVisualLinks, rpcServices, rpcMenuServices, session, table, menu, visualLink, visualLinkService, vuuModule, ...arrayDataSourceProps }: TickingArrayDataSourceConstructorProps);
+    updateRowWithSessionCheck: (row: Array<bigint | VuuRowDataItemType>, columnName?: string, sessionId?: string) => void;
+    subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    unsubscribe(): void;
+    set links(links: LinkDescriptorWithLabel[] | undefined);
+    get links(): LinkDescriptorWithLabel[] | undefined;
+    getSelectedRowIds(): string[];
+    isSessionDataSourceOf(dataSource: DataSource): boolean;
+    createSessionDataSource(copyOption: CopyOption, sessionType?: SessionType, overrides?: SessionDataSourceOverrides): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    beginEditSession(editSessionMode?: EditSessionMode, overrides?: SessionDataSourceOverrides): Promise<DataSourceBase<DataSourceRowWithBigint> | undefined>;
+    editCell(key: string, column: string, data: VuuRowDataItemType): Promise<RpcResultError | RpcResultSuccess>;
+    addRow: (rowData?: Record<string, VuuRowDataItemType>) => Promise<RpcResult>;
+    deleteRow: (key: string, mode?: DeleteRowMode) => Promise<true | string>;
+    deleteSelectedRows: (mode?: DeleteRowMode) => Promise<RpcResultSuccess | RpcResultError>;
+    undoRowChange: (key: string) => Promise<RpcResultSuccess | RpcResultError>;
+    set columns(columns: string[]);
+    get columns(): string[];
+    endEditSession(saveChanges?: boolean): Promise<void>;
+    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;
+    getTypeaheadSuggestions(column: string, pattern?: string): Promise<string[]>;
+    get visualLink(): LinkDescriptorWithLabel | undefined;
+    set visualLink(visualLink: LinkDescriptorWithLabel | undefined);
+    freeze(): void;
+    unfreeze(): void;
+}

package/types/src/UpdateGenerator.d.ts

@@ -0,0 +1,18 @@
+import { VuuRange } from "@vuu-ui/vuu-protocol-types";
+import type { UpdateGenerator } from "./rowUpdates";
+import { Table } from "./Table";
+export declare class BaseUpdateGenerator implements UpdateGenerator {
+    private table;
+    private range;
+    private updating;
+    private timer;
+    private tickingColumns;
+    constructor(tickingColumns: {
+        [key: string]: number;
+    });
+    setRange(range: VuuRange): void;
+    setTable(table: Table): void;
+    private startUpdating;
+    private stopUpdating;
+    update: () => void;
+}

package/types/src/basket/BasketModule.d.ts

@@ -0,0 +1,55 @@
+import { VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { RpcMenuService, ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import { BasketsTableName } from "./basket-schemas";
+import { type Table } from "../Table";
+export declare const createBasketTradingRow: (basketId: string, basketName: string, side?: string, status?: string) => (string | number)[];
+/**
+ * This is an example of how we might extend the built-in VuuModule to
+ * implement a module-specific service in such a way that it can invoke
+ * methods on the VuuModule.
+ */
+export declare class BasketModule extends VuuModule<BasketsTableName> {
+    #private;
+    constructor();
+    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;
+        }[];
+        basketTrading: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+        basketTradingConstituentJoin: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+    };
+    get menuServices(): Record<BasketsTableName, RpcMenuService[] | undefined> | undefined;
+    get tables(): Record<BasketsTableName, Table>;
+    get visualLinks(): {
+        algoType: undefined;
+        basket: undefined;
+        basketTrading: undefined;
+        basketTradingConstituent: undefined;
+        basketTradingConstituentJoin: undefined;
+        priceStrategyType: undefined;
+        basketConstituent: {
+            fromColumn: string;
+            toColumn: string;
+            toTable: string;
+        }[];
+    };
+    private createTradingBasket;
+    private createNewBasket;
+    private sendToMarket;
+    private takeOffMarket;
+    private addConstituent;
+}
+export declare const basketModule: BasketModule;

package/types/src/basket/basket-schemas.d.ts

@@ -0,0 +1,9 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuTable } from "@vuu-ui/vuu-protocol-types";
+export type BasketsTableName = "algoType" | "basket" | "basketConstituent" | "basketTrading" | "basketTradingConstituent" | "basketTradingConstituentJoin" | "priceStrategyType";
+export declare const schemas: Readonly<Record<BasketsTableName, Readonly<TableSchema>>>;
+export type BasketVuuTable = {
+    module: "BASKET";
+    table: BasketsTableName;
+};
+export declare const isBasketTable: (table: VuuTable) => table is BasketVuuTable;

package/types/src/basket/index.d.ts

@@ -0,0 +1,2 @@
+export { type BasketsTableName, schemas as basketSchemas, isBasketTable, } from "./basket-schemas";
+export { basketModule } from "./BasketModule";

package/types/src/basket/reference-data/constituents.d.ts

@@ -0,0 +1,3 @@
+import { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+declare const _default: VuuRowDataItemType[][];
+export default _default;

package/types/src/basket/reference-data/ftse100.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[][];
+export default _default;

package/types/src/basket/reference-data/hsi.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (string | number)[][];
+export default _default;

package/types/src/basket/reference-data/nasdaq100.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (string | number)[][];
+export default _default;