@vuu-ui/vuu-data-test 3.5.7 → 3.5.8

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.7",
+  "version": "3.5.8",
   "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": "3.5.7",
-    "@vuu-ui/vuu-utils": "3.5.7"
+    "@vuu-ui/vuu-data-local": "3.5.8",
+    "@vuu-ui/vuu-utils": "3.5.8"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "3.5.7",
-    "@vuu-ui/vuu-data-types": "3.5.7",
-    "@vuu-ui/vuu-table-types": "3.5.7"
+    "@vuu-ui/vuu-protocol-types": "3.5.8",
+    "@vuu-ui/vuu-data-types": "3.5.8",
+    "@vuu-ui/vuu-table-types": "3.5.8"
   },
   "sideEffects": false,
   "files": [

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;

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

@@ -0,0 +1,24 @@
+export type ask = number;
+export type askSize = number;
+export type bid = number;
+export type bidSize = number;
+export type close = number;
+export type last = number;
+export type open = number;
+export type phase = "C";
+export type ric = string;
+export type scenario = "close";
+export type PricesDataRow = [
+    ask,
+    askSize,
+    bid,
+    bidSize,
+    close,
+    last,
+    open,
+    phase,
+    ric,
+    scenario
+];
+declare const pricesTable: import("../..").Table;
+export default pricesTable;

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

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

package/types/src/core/module/ModuleContainer.d.ts

@@ -0,0 +1,11 @@
+import { VuuModule } from "./VuuModule";
+declare class ModuleContainer {
+    #private;
+    private constructor();
+    static get instance(): ModuleContainer;
+    register(module: VuuModule<any>): void;
+    get(name: string): VuuModule<string>;
+    get moduleNames(): MapIterator<string>;
+}
+declare const _default: ModuleContainer;
+export default _default;

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

@@ -0,0 +1,81 @@
+import type { DataSourceBase, DataSourceConfig, DataSourceRowWithBigint, DataSourceSubscribedMessage, DataSourceVisualLinkCreatedMessage, EditSessionMode, CopyOption, SessionDataSourceOverrides, SessionType, TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuMenu, VuuLink, LinkDescriptorWithLabel, VuuRpcMenuResponse, VuuCreateVisualLink, VuuRemoveVisualLink, VuuRpcServiceRequest, RpcResultSuccess, RpcResultError, VuuRpcMenuRequest } from "@vuu-ui/vuu-protocol-types";
+import { Table } from "../../Table";
+import { TickingArrayDataSource } from "../../TickingArrayDataSource";
+export interface IVuuModule<T extends string = string> {
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
+        session?: SessionDataSourceOverrides;
+    }) => DataSourceBase<DataSourceRowWithBigint>;
+}
+export type SessionTableMap = Record<string, Table>;
+export type ServiceHandler = (rpcRequest: VuuRpcServiceRequest) => Promise<RpcResultSuccess | RpcResultError>;
+export type MenuServiceHandler = (rpcRequest: VuuRpcMenuRequest) => Promise<VuuRpcMenuResponse>;
+export type RpcService = {
+    rpcName: string;
+    service: ServiceHandler;
+};
+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: DataSourceBase<DataSourceRowWithBigint>;
+    sessionTableName?: string;
+    sourceTableName?: string;
+};
+export declare abstract class VuuModule<T extends string = string> implements IVuuModule<T> {
+    #private;
+    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>;
+    protected abstract menuServices?: Record<T, RpcMenuService[] | undefined> | undefined;
+    protected abstract services?: Record<T, RpcService[] | undefined> | undefined;
+    protected abstract visualLinks?: Record<T, VuuLink[] | undefined>;
+    getTableSchema(tableName: string): Record<T, Readonly<TableSchema>>[T];
+    getTableList(): string[];
+    protected handlePostSubscribeActivities: ({ clientViewportId, tableSchema, }: DataSourceSubscribedMessage) => void;
+    protected unregisterViewport: (viewportId: string) => void;
+    get name(): string;
+    getSubscriptionByViewport(viewportId: string): Subscription;
+    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 & {
+        session?: SessionDataSourceOverrides;
+    }) => DataSourceBase<DataSourceRowWithBigint>;
+    getServices(tableName: T): RpcService[];
+    getMenuServices(tableName: T): RpcMenuService[];
+    protected get sessionTableMap(): SessionTableMap;
+    protected getSessionTable(sessionTableName: string): Table;
+    protected getSessionTable(sessionTableName: string, throwIfNotFound: true): Table;
+    protected getSessionTable(sessionTableName: string, throwIfNotFound: false): Table | undefined;
+    protected deleteRow: ServiceHandler;
+    private deleteSelectedRows;
+    private undoRowChange;
+    private getColumnDescriptors;
+    private editCell;
+    private beginEditSessionMenuHandler;
+    /**
+     * Creates a standalone session table.
+     * The `copyOption` determines which rows are copied into the session table.
+     * Returns the session table reference so the caller can subscribe to it.
+     */
+    private createSessionTableService;
+    private beginEditSession;
+    private addRow;
+    private endEditSession;
+    private applyBulkEdits;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: EditSessionMode | CopyOption, dataSource: TickingArrayDataSource, sessionType?: SessionType): Table;
+    protected createSessionTableWithAllRows({ data, schema }: Table, _sessionTableName: string): Table;
+    protected createEmptySessionTable({ schema }: Table, sessionTableName: string, sessionType?: SessionType): Table;
+    protected createSessionTableFromSelectedRows({ data, map, schema }: Table, sessionTableName: string, dataSource: TickingArrayDataSource): Table;
+}
+export {};

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

@@ -0,0 +1,16 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { Table } from "../../Table";
+import { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "@vuu-ui/vuu-utils";
+import { UpdateGenerator } from "../../rowUpdates";
+declare class TableContainer {
+    #private;
+    private constructor();
+    static get instance(): TableContainer;
+    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>;
+}
+declare const _default: TableContainer;
+export default _default;

package/types/src/data-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function random(min: number, max: number): number;
+export declare function randomPercentage(value: number): number;
+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/src/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/src/index.d.ts

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

package/types/src/local-datasource-provider/LocalDatasourceProvider.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from "react";
+export declare const LocalDataSourceProvider: ({ children, }: {
+    children: ReactNode;
+}) => import("react").JSX.Element;

package/types/src/makeSuggestions.d.ts

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

package/types/src/rowUpdates.d.ts

@@ -0,0 +1,15 @@
+import { VuuRange, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { Table } from "./Table";
+export type UpdateHandler = (updates: (RowUpdates | RowInsert | RowDelete)[]) => void;
+export interface UpdateGenerator {
+    setTable: (table: Table) => void;
+    setRange: (range: VuuRange) => void;
+}
+export type UpdateType = "I" | "D" | "U";
+type MAXIMUM_ALLOWED_BOUNDARY = 20;
+type RepeatingTuple<Tuple extends Array<unknown>, Result extends Array<unknown> = [], Count extends ReadonlyArray<number> = []> = Count["length"] extends MAXIMUM_ALLOWED_BOUNDARY ? Result : Tuple extends [] ? [] : Result extends [] ? RepeatingTuple<Tuple, Tuple, [...Count, 1]> : RepeatingTuple<Tuple, Result | [...Result, ...Tuple], [...Count, 1]>;
+type UpdatePairs = RepeatingTuple<[number, VuuRowDataItemType]>;
+export type RowUpdates = ["U", number, ...UpdatePairs];
+export type RowInsert = ["I", ...VuuRowDataItemType[]];
+export type RowDelete = ["D", string];
+export {};

package/types/src/schemas.d.ts

@@ -0,0 +1,8 @@
+import { TableSchema } from "@vuu-ui/vuu-data-types";
+import { type BasketsTableName } from "./basket/basket-schemas";
+import { type SimulTableName } from "./simul/simul-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>;
+export declare const getSchema: (tableName: VuuTableName) => Readonly<TableSchema>;

package/types/src/session-table-utils.d.ts

@@ -0,0 +1,6 @@
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { Table } from "./Table";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+export declare const sessionTableRow: (row: Array<bigint | VuuRowDataItemType>, schema: TableSchema) => (bigint | VuuRowDataItemType)[];
+export declare const createSessionTableFromSelectedRows: (table: Table, selectedRowIds: string[]) => Table;
+export declare const sessionTableSchema: (schema: TableSchema) => TableSchema;

package/types/src/simul/SimulModule.d.ts

@@ -0,0 +1,24 @@
+import { VuuLink, VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { MenuServiceHandler, RpcMenuService, RpcService, ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import { Table } from "../Table";
+import { type SimulTableName } from "./simul-schemas";
+/**
+ * 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 SimulModule extends VuuModule<SimulTableName> {
+    #private;
+    constructor();
+    get menus(): Record<SimulTableName, VuuMenu | undefined> | undefined;
+    get schemas(): Readonly<Record<SimulTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
+    get editServices(): undefined;
+    get menuServices(): Record<SimulTableName, RpcMenuService[] | undefined> | undefined;
+    get services(): Record<SimulTableName, RpcService[] | undefined> | undefined;
+    get tables(): Record<SimulTableName, Table>;
+    get visualLinks(): Record<SimulTableName, VuuLink[] | undefined>;
+    cancelOrder: MenuServiceHandler;
+    startOrders: ServiceHandler;
+    stopOrders: ServiceHandler;
+}
+export declare const simulModule: SimulModule;

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

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

package/types/src/simul/reference-data/accounts.d.ts

@@ -0,0 +1 @@
+export declare const accounts: string[];

package/types/src/simul/reference-data/algos.d.ts

@@ -0,0 +1 @@
+export declare const algos: string[];

package/types/src/simul/reference-data/currencies.d.ts

@@ -0,0 +1 @@
+export declare const currencies: string[];

package/types/src/simul/reference-data/index.d.ts

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

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

@@ -0,0 +1,60 @@
+type ask = number;
+type askSize = number;
+type bbg = string;
+type bid = number;
+type bidSize = number;
+type close = number;
+type currency = string;
+type description = string;
+type exchange = string;
+type isin = string;
+type last = number;
+type lotSize = number;
+type open = number;
+type phase = string;
+type ric = string;
+type scenario = string;
+type vuuCreatedTimestamp = number;
+type vuuUpdatedTimestamp = number;
+export type InstrumentPricesDataRow = [
+    ask,
+    askSize,
+    bbg,
+    bid,
+    bidSize,
+    close,
+    currency,
+    description,
+    exchange,
+    isin,
+    last,
+    lotSize,
+    open,
+    phase,
+    ric,
+    scenario,
+    vuuCreatedTimestamp,
+    vuuUpdatedTimestamp
+];
+export declare const InstrumentPricesColumnMap: {
+    ask: number;
+    askSize: number;
+    bbg: number;
+    bid: number;
+    bidSize: number;
+    close: number;
+    currency: number;
+    description: number;
+    exchange: number;
+    isin: number;
+    last: number;
+    lotSize: number;
+    open: number;
+    phase: number;
+    ric: number;
+    scenario: number;
+    vuuCreatedTimestamp: number;
+    vuuUpdatedTimestamp: number;
+};
+declare const instrumentPrices: InstrumentPricesDataRow[];
+export { instrumentPrices };

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

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

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

@@ -0,0 +1,35 @@
+export type bbg = string;
+export type currency = string;
+export type ric = string;
+export type description = string;
+export type exchange = string;
+export type price = string;
+export type date = number;
+export type InstrumentsDataRow = [
+    bbg,
+    currency,
+    description,
+    exchange,
+    string,
+    number,
+    ric,
+    date,
+    date,
+    string
+];
+export declare const InstrumentColumnMap: {
+    readonly bbg: 0;
+    readonly currency: 1;
+    readonly description: 2;
+    readonly exchange: 3;
+    readonly string: 4;
+    readonly number: 5;
+    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 { instrumentsData };

package/types/src/simul/reference-data/isin-generator/convert-string-to-base-ten-number.d.ts

@@ -0,0 +1 @@
+export declare const convertStringToBaseTenNumber: (value: string) => number;

package/types/src/simul/reference-data/isin-generator/fixtures/alphabet.d.ts

@@ -0,0 +1 @@
+export declare const alphabet: string[];

package/types/src/simul/reference-data/isin-generator/fixtures/alphanumeric-values.d.ts

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

package/types/src/simul/reference-data/isin-generator/fixtures/base-ten-numbers.d.ts

@@ -0,0 +1 @@
+export declare const baseTenNumbers: number[];

package/types/src/simul/reference-data/isin-generator/generate-cusip-check-code.d.ts

@@ -0,0 +1 @@
+export declare const generateCusipCheckCode: (cusip: string) => number;

package/types/src/simul/reference-data/isin-generator/generate-cusip-without-check-code.d.ts

@@ -0,0 +1 @@
+export declare const generateCusipWithoutCheckCode: () => string;

package/types/src/simul/reference-data/isin-generator/generate-cusip.d.ts

@@ -0,0 +1 @@
+export declare const generateCusip: () => string;

package/types/src/simul/reference-data/isin-generator/generate-random-alphanumeric.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomAlphanumeric: () => string | number;

package/types/src/simul/reference-data/isin-generator/generate-random-base-ten-number.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomBaseTenNumber: () => number;

package/types/src/simul/reference-data/isin-generator/generate-random-string-of-alphanumeric-chars.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomStringOfAlphanumericChars: () => string;

package/types/src/simul/reference-data/isin-generator/generate-random-string-of-base-ten-chars.d.ts

@@ -0,0 +1 @@
+export declare const generateRandomStringOfBaseTenChars: () => string;

package/types/src/simul/reference-data/isin-generator/index.d.ts

@@ -0,0 +1 @@
+export declare const isinGenerator: () => string;

package/types/src/simul/reference-data/isin-generator/is-odd.d.ts

@@ -0,0 +1 @@
+export declare const isOdd: (value: number) => boolean;

package/types/src/simul/reference-data/locations.d.ts

@@ -0,0 +1,4 @@
+export declare const locations: {
+    [key: string]: string[];
+};
+export declare const suffixes: string[];

package/types/src/simul/reference-data/lotsizes.d.ts

@@ -0,0 +1 @@
+export declare const lotsizes: number[];

package/types/src/simul/reference-data/orderStatus.d.ts

@@ -0,0 +1 @@
+export declare const orderStatus: string[];

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

@@ -0,0 +1,36 @@
+export type status = string;
+export type ccy = string;
+export type created = number;
+export type filledQuantity = number;
+export type lastUpdate = number;
+export type orderId = string;
+export type quantity = number;
+export type ric = string;
+export type side = string;
+export type trader = string;
+export type OrdersDataRow = [
+    status,
+    ccy,
+    created,
+    filledQuantity,
+    lastUpdate,
+    orderId,
+    quantity,
+    ric,
+    side,
+    trader
+];
+export declare const OrderColumnMap: {
+    readonly ccy: 0;
+    readonly created: 1;
+    readonly filledQuantity: 2;
+    readonly lastUpdate: 3;
+    readonly orderId: 4;
+    readonly quantity: 5;
+    readonly ric: 6;
+    readonly side: 7;
+    readonly trader: 8;
+};
+declare const ordersData: OrdersDataRow[];
+export declare const ordersTable: import("../..").Table;
+export { ordersData };

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

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

package/types/src/simul/reference-data/priceStrategies.d.ts

@@ -0,0 +1 @@
+export declare const priceStrategies: string[];

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

@@ -0,0 +1,34 @@
+type ask = number;
+type askSize = number;
+type bid = number;
+type bidSize = number;
+type close = number;
+type last = number;
+type open = number;
+type phase = "C";
+type ric = string;
+type scenario = "close";
+type lastUpdate = number;
+type created = number;
+type vuuMsg = string;
+export type PricesDataRow = [
+    ask,
+    askSize,
+    bid,
+    bidSize,
+    close,
+    last,
+    open,
+    phase,
+    ric,
+    scenario,
+    lastUpdate,
+    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 { pricesData };

package/types/src/simul/reference-data/sides.d.ts

@@ -0,0 +1 @@
+export declare const sides: string[];

package/types/src/simul/simul-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 SimulTableName = "instruments" | "instrumentsExtended" | "instrumentPrices" | "orders" | "childOrders" | "parentOrders" | "prices";
+export declare const schemas: Readonly<Record<SimulTableName, Readonly<TableSchema>>>;
+export type SimulVuuTable = {
+    module: "SIMUL";
+    table: SimulTableName;
+};
+export declare const isSimulTable: (table: VuuTable) => table is SimulVuuTable;

package/types/src/test/TestModule.d.ts

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

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

@@ -0,0 +1 @@
+export * from "./TestModule";

package/types/src/vuu-row-generator.d.ts

@@ -0,0 +1,17 @@
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import type { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import { UpdateGenerator } from "./rowUpdates";
+type GenerateRowFunc = (index: number) => VuuRowDataItemType[];
+export type RowGeneratorFactory = (columns: string[]) => GenerateRowFunc;
+export type ColumnGeneratorFn = (columns?: number | string[], columnConfig?: {
+    [key: string]: Partial<ColumnDescriptor>;
+}) => ColumnDescriptor[];
+export declare const DefaultRowGenerator: RowGeneratorFactory;
+export declare const DefaultColumnGenerator: ColumnGeneratorFn;
+export declare const defaultGenerators: {
+    ColumnGenerator: ColumnGeneratorFn;
+    RowGenerator: RowGeneratorFactory;
+};
+export declare const getColumnAndRowGenerator: (table?: VuuTable) => [ColumnGeneratorFn, RowGeneratorFactory] | [ColumnGeneratorFn, RowGeneratorFactory, () => UpdateGenerator];
+export declare const populateArray: (count: number, colGen: ColumnGeneratorFn, rowGen: RowGeneratorFactory, columns?: number | string[]) => VuuRowDataItemType[][];
+export {};

package/types/user-admin/UserAdminModule.d.ts

@@ -0,0 +1,54 @@
+import { type UserAdminSnapshot, type UserAdminTableName } from "@heswell/user-admin/contracts";
+import { InMemoryUserAdminStore } from "@heswell/user-admin/in-memory";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { VuuModule, type RpcService } from "../core/module/VuuModule";
+import { Table } from "../Table";
+type UserAdminTables = Record<UserAdminTableName, Table>;
+export declare class UserAdminModule extends VuuModule<UserAdminTableName> {
+    #private;
+    readonly store: InMemoryUserAdminStore;
+    constructor(snapshot?: UserAdminSnapshot);
+    get schemas(): Record<UserAdminTableName, Readonly<TableSchema>>;
+    get tables(): UserAdminTables;
+    get menus(): {
+        clients: undefined;
+        group_roles: undefined;
+        groups: undefined;
+        roles: undefined;
+        user_group_roles: undefined;
+        user_groups: undefined;
+        users: undefined;
+    };
+    get visualLinks(): undefined;
+    get menuServices(): undefined;
+    get services(): Record<UserAdminTableName, RpcService[]>;
+    reconcile(): Promise<void>;
+    protected createSessionTable(sourceTable: Table, sessionTableName: string, editSessionMode: import("@vuu-ui/vuu-data-types").EditSessionMode | import("@vuu-ui/vuu-data-types").CopyOption, dataSource: import("../TickingArrayDataSource").TickingArrayDataSource, sessionType?: import("@vuu-ui/vuu-data-types").SessionType): Table;
+    protected beforeSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    protected afterSessionSave(sourceTable: Table, sessionTable: Table): Promise<void>;
+    private saveGroupsFromSession;
+    private saveGroupRoleAssignments;
+    private resolveGroupRoleAssignments;
+    private saveClientRolesFromSession;
+    private mutation;
+    private addUser;
+    private updateUser;
+    private deleteUser;
+    private addGroup;
+    private updateGroup;
+    private deleteGroup;
+    private addClient;
+    private updateClient;
+    private addRole;
+    private addClientRole;
+    private updateRole;
+    private assignGroupRole;
+    private removeGroupRole;
+    private assignUserToGroup;
+    private removeUserFromGroup;
+    private getUserModuleAccessOptions;
+    private setUserModuleAccess;
+    private assertUsernameIsUnique;
+}
+export declare const userAdminModule: UserAdminModule;
+export {};

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

@@ -0,0 +1,3 @@
+export { UserAdminModule, userAdminModule, } from "./UserAdminModule";
+export { USER_ADMIN_INITIAL_SNAPSHOT } from "./initialSnapshot";
+export { projectUserAdminSnapshot, reconcileUserAdminTables, } from "./snapshot-projection";

package/types/user-admin/initialSnapshot.d.ts

@@ -0,0 +1,2 @@
+import type { UserAdminSnapshot } from "@heswell/user-admin";
+export declare const USER_ADMIN_INITIAL_SNAPSHOT: UserAdminSnapshot;

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

@@ -0,0 +1,9 @@
+import type { UserAdminSnapshot, UserAdminTableName } from "@heswell/user-admin/contracts";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import type { Table } from "../Table";
+type Row = Array<bigint | VuuRowDataItemType>;
+type Tables = Record<UserAdminTableName, Table>;
+export declare const resolveDisplayName: (name: string, configuredDisplayName?: string) => string;
+export declare const projectUserAdminSnapshot: (snapshot: UserAdminSnapshot, tables: Tables) => Record<UserAdminTableName, Row[]>;
+export declare const reconcileUserAdminTables: (snapshot: UserAdminSnapshot, tables: Tables) => void;
+export {};