@heswell/vuu-data-engine-local 0.0.0-stage → 2.0.0

package/package.json

@@ -1,6 +1,39 @@
 {
   "name": "@heswell/vuu-data-engine-local",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "2.0.0",
+  "description": "In-browser Vuu server (VuuModule, tables, EngineDataSource) built on @heswell/vuu-table and @heswell/vuu-viewport",
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./index.js"
+    }
+  },
+  "type": "module",
+  "author": "heswell",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@heswell/module-admin": "2.0.0",
+    "@heswell/user-admin": "1.0.2",
+    "@heswell/vuu-table": "1.0.1",
+    "@heswell/vuu-viewport": "1.1.2",
+    "@vuu-ui/vuu-data-editing": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-data-local": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.20",
+    "@vuu-ui/vuu-utils": "4.0.0-alpha.20"
+  },
+  "peerDependencies": {
+    "@vuu-ui/core": "^4.0.0-alpha.20",
+    "@vuu-ui/vuu-data-types": "^4.0.0-alpha.20",
+    "@vuu-ui/vuu-filter-types": "^4.0.0-alpha.20",
+    "@vuu-ui/vuu-protocol-types": "^4.0.0-alpha.20",
+    "@vuu-ui/vuu-table-types": "^4.0.0-alpha.20",
+    "react": "^19.2.3"
+  },
+  "sideEffects": false
+}

package/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/src/EngineDataSource.d.ts

@@ -0,0 +1,109 @@
+import { type DataEngine, type LinkFilter, type RowPredicate, type ViewportEngine } from "@heswell/vuu-viewport";
+import type { DataSourceBase, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceRowWithBigint, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, TableSchema, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+import type { Filter } from "@vuu-ui/vuu-filter-types";
+import type { LinkDescriptorWithLabel, SelectRequest, VuuAggregation, VuuGroupBy, VuuMenu, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest, RpcResultError, RpcResultSuccess, VuuSort } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import { type ColumnMap, EventEmitter, Range } from "@vuu-ui/vuu-utils";
+import { Table } from "./Table";
+export interface EngineDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
+    /**
+     * Columns available to the dataSource, defaults to the columns of the
+     * table schema. These are the default columns of the dataSource.
+     */
+    columnDescriptors?: readonly ColumnDescriptor[];
+    /** Raw data, used to create a Table when no table is provided */
+    data?: Array<Array<bigint | VuuRowDataItemType>>;
+    /** analytics engine, defaults to the in-memory engine */
+    dataEngine?: DataEngine;
+    keyColumn?: string;
+    menu?: VuuMenu;
+    /** row level permission, applied before all other filters */
+    permissionFilter?: RowPredicate;
+    /** number of rows to fetch either side of the visible range */
+    renderBufferSize?: number;
+    table?: Table;
+}
+export declare class EngineDataSource extends EventEmitter<DataSourceEvents> implements DataSourceBase<DataSourceRowWithBigint> {
+    #private;
+    protected clientCallback: DataSourceSubscribeCallback | undefined;
+    protected columnDescriptors: readonly ColumnDescriptor[];
+    protected _config: WithBaseFilter<WithFullConfig> & {
+        visualLink?: LinkDescriptorWithLabel;
+    };
+    protected _menu: VuuMenu | undefined;
+    tableSchema: TableSchema;
+    viewport: string;
+    constructor({ aggregations, baseFilterSpec, columnDescriptors, columns, data, dataEngine, filterSpec, groupBy, keyColumn, menu, permissionFilter, renderBufferSize, sort, table, title, viewport, }: EngineDataSourceConstructorProps);
+    protected get engine(): ViewportEngine<DataSourceRowWithBigint>;
+    sendSizeUpdateToClient(): void;
+    /** Send every row in the current range, irrespective of what was sent before */
+    sendRowsToClient(): void;
+    subscribe({ viewport, columns, aggregations, baseFilterSpec, range, sort, groupBy, filterSpec, }: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    unsubscribe(): void;
+    suspend(): void;
+    resume(callback?: DataSourceSubscribeCallback): void;
+    disable(): void;
+    enable(): void;
+    get status(): DataSourceStatus;
+    get range(): Range;
+    set range(range: Range);
+    get maxRangeEnd(): number;
+    get pageSize(): number;
+    protected setRange(range: Range, forceFullRefresh?: boolean): void;
+    get config(): WithBaseFilter<WithFullConfig>;
+    set config(config: WithBaseFilter<WithFullConfig>);
+    get aggregations(): VuuAggregation[];
+    set aggregations(aggregations: VuuAggregation[]);
+    get baseFilter(): DataSourceFilter | undefined;
+    set baseFilter(baseFilterSpec: DataSourceFilter | undefined);
+    get columns(): string[];
+    set columns(columns: string[]);
+    get filter(): DataSourceFilter;
+    set filter(filterSpec: DataSourceFilter);
+    setFilter(filter: Filter): void;
+    clearFilter(): void;
+    get groupBy(): VuuGroupBy;
+    set groupBy(groupBy: VuuGroupBy);
+    get sort(): VuuSort;
+    set sort(sort: VuuSort);
+    get visualLink(): LinkDescriptorWithLabel | undefined;
+    set visualLink(visualLink: LinkDescriptorWithLabel | undefined);
+    setPermissionFilter(permissionFilter: RowPredicate | undefined): void;
+    /**
+     * Restrict rows to those whose column value is one of values. Used to
+     * implement visual linking. Undefined removes the restriction.
+     */
+    setLinkFilter(linkFilter: LinkFilter | undefined): void;
+    select(selectRequest: Omit<SelectRequest, "vpId">): void;
+    get selectedRowsCount(): number;
+    /** keys (in the source table) of selected rows */
+    getSelectedRowIds(): string[];
+    /** distinct values of column across selected rows */
+    getSelectedValues(column: string): Set<VuuRowDataItemType>;
+    openTreeNode(keyOrIndex: string | number): void;
+    closeTreeNode(keyOrIndex: string | number): void;
+    get size(): number;
+    get table(): import("@vuu-ui/vuu-data-types").TableSchemaTable;
+    /** The table backing this dataSource */
+    get dataTable(): Table;
+    get columnMap(): ColumnMap;
+    /**
+     * Flat (ungrouped) rows can be resolved at any index. Grouped rows are
+     * only available within the current (buffered) client range, consistent
+     * with a remote Vuu dataSource.
+     */
+    getRowAtIndex(rowIndex: number): DataSourceRowWithBigint | undefined;
+    getRowByKey(key: string): DataSourceRowWithBigint | undefined;
+    getTypeaheadSuggestions(column: string, pattern?: string): Promise<string[]>;
+    get links(): LinkDescriptorWithLabel[] | undefined;
+    set links(links: LinkDescriptorWithLabel[] | undefined);
+    get menu(): VuuMenu | undefined;
+    get title(): string;
+    set title(title: string);
+    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;
+    freeze(): void;
+    unfreeze(): void;
+    get freezeTimestamp(): number | undefined;
+    get isFrozen(): boolean;
+}

package/src/ModuleDataSource.d.ts

@@ -0,0 +1,41 @@
+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, VuuRemoveVisualLink, VuuRowDataItemType, VuuRpcMenuRequest, VuuRpcMenuResponse, VuuRpcServiceRequest } from "@vuu-ui/vuu-protocol-types";
+import type { IVuuModule, RpcMenuService, RpcService } from "./core/module/VuuModule";
+import { EngineDataSource, type EngineDataSourceConstructorProps } from "./EngineDataSource";
+export type VisualLinkHandler = (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | undefined>;
+export interface ModuleDataSourceConstructorProps extends EngineDataSourceConstructorProps {
+    getVisualLinks?: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
+    rpcMenuServices?: RpcMenuService[];
+    rpcServices?: RpcService[];
+    session?: SessionDataSourceOverrides;
+    visualLinkService?: VisualLinkHandler;
+    vuuModule?: Pick<IVuuModule, "createDataSource">;
+}
+/**
+ * An EngineDataSource hosted by a VuuModule. Adds RPC services, menus,
+ * edit sessions and visual links.
+ */
+export declare class ModuleDataSource extends EngineDataSource {
+    #private;
+    constructor({ getVisualLinks, rpcServices, rpcMenuServices, session, visualLink, visualLinkService, vuuModule, ...engineDataSourceProps }: ModuleDataSourceConstructorProps);
+    subscribe(subscribeProps: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    set links(links: LinkDescriptorWithLabel[] | undefined);
+    get links(): LinkDescriptorWithLabel[] | undefined;
+    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<RpcResultSuccess | RpcResultError>;
+    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>;
+    endEditSession(saveChanges?: boolean): Promise<void>;
+    rpcRequest(rpcRequest: Omit<VuuRpcServiceRequest, "context">): Promise<RpcResultSuccess | RpcResultError>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcMenuRequest, "vpId">): Promise<VuuRpcMenuResponse>;
+    get visualLink(): LinkDescriptorWithLabel | undefined;
+    set visualLink(visualLink: LinkDescriptorWithLabel | undefined);
+}
+/** @deprecated legacy name, use ModuleDataSource */
+export declare const TickingArrayDataSource: typeof ModuleDataSource;
+/** @deprecated legacy name, use ModuleDataSource */
+export type TickingArrayDataSource = ModuleDataSource;

package/src/RowKeys.d.ts

@@ -0,0 +1,17 @@
+import type { VuuRange } from "@vuu-ui/vuu-protocol-types";
+/**
+ * Assigns stable render keys to row indices in the client range, recycling
+ * the keys of rows that leave the range. Same contract as KeySet from
+ * vuu-utils, but array backed, so reset costs O(range size) with no Map
+ * scans or array shifts.
+ */
+export declare class RowKeys {
+    #private;
+    constructor(range: VuuRange);
+    /**
+     * Returns true when keys have been resequenced (range size reduced), in
+     * which case all rows must be re-sent to the client.
+     */
+    reset(range: VuuRange): boolean;
+    keyFor(rowIndex: number): number;
+}

package/src/RuntimeVisualLink.d.ts

@@ -0,0 +1,16 @@
+import type { RowSelectionEventHandler } from "@vuu-ui/vuu-data-types";
+import type { EngineDataSource } from "./EngineDataSource";
+/**
+ * A visual link between two dataSources. Selection in the parent restricts
+ * the rows of the child to those whose childColumn value matches the
+ * parentColumn value of a selected parent row. Implemented with the engine
+ * link filter, so it composes with (and does not overwrite) the child's
+ * client filter and baseFilter.
+ */
+export declare class RuntimeVisualLink {
+    #private;
+    constructor(childDataSource: EngineDataSource, parentDataSource: EngineDataSource, childColumnName: string, parentColumnName: string);
+    destroy(): void;
+    remove(): void;
+    handleParentSelectEvent: RowSelectionEventHandler;
+}

package/src/Table.d.ts

@@ -0,0 +1,46 @@
+import { Table as EngineTable } from "@heswell/vuu-table";
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { type ColumnMap, EventEmitter } from "@vuu-ui/vuu-utils";
+import type { UpdateGenerator } from "./rowUpdates";
+export type TableRow = Array<VuuRowDataItemType | bigint>;
+export type TableEvents = {
+    delete: (key: string) => void;
+    insert: (row: TableRow) => void;
+    update: (row: TableRow, columnName?: string, sessionId?: string) => void;
+};
+/**
+ * Module-facing table API, backed by an `@heswell/vuu-table` engine Table.
+ *
+ * Rows are stored by the engine. Note that deletes are swap-remove, so the
+ * order of `data` is insertion order only until the first delete.
+ *
+ * Events are emitted from engine table listeners, so changes applied
+ * directly to the engine table (e.g. by a JoinTable) are also observed.
+ */
+export declare class Table extends EventEmitter<TableEvents> {
+    #private;
+    readonly engineTable: EngineTable;
+    constructor(schemaOrEngineTable: TableSchema | EngineTable, data?: TableRow[], dataMap?: ColumnMap, updateGenerator?: UpdateGenerator);
+    get data(): TableRow[];
+    get map(): ColumnMap;
+    get schema(): TableSchema;
+    get name(): string;
+    get rowCount(): number;
+    delete(key: string): void;
+    /**
+     * @param _emitEvent retained for compatibility with vuu-data-test, the
+     * engine always notifies dependent viewports of an insert.
+     */
+    insert(row: TableRow, _emitEvent?: boolean): void;
+    findByKey(key: string): TableRow | undefined;
+    update(key: string, columnName: string, value: bigint | VuuRowDataItemType): void;
+    updateRow(row: TableRow): 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.
+ */
+export declare function buildDataColumnMap<TableName extends string = string>(schemas: Readonly<Record<TableName, Readonly<TableSchema>>>, tableName: TableName): ColumnMap;

package/src/UpdateGenerator.d.ts

@@ -0,0 +1,18 @@
+import type { VuuRange } from "@vuu-ui/vuu-protocol-types";
+import type { UpdateGenerator } from "./rowUpdates";
+import type { 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/src/basket/BasketModule.d.ts

@@ -0,0 +1,55 @@
+import type { VuuMenu } from "@vuu-ui/vuu-protocol-types";
+import { type RpcMenuService, type ServiceHandler, VuuModule } from "../core/module/VuuModule";
+import { type 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(): {
+        basket: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+        basketTrading: {
+            rpcName: string;
+            service: ServiceHandler;
+        }[];
+        basketTradingConstituentJoin: {
+            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;
+    };
+    private createTradingBasket;
+    private createNewBasket;
+    private sendToMarket;
+    private takeOffMarket;
+    private addConstituent;
+}
+export declare const basketModule: BasketModule;

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

@@ -0,0 +1,9 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import type { 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/src/basket/index.d.ts

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

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

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

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

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

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

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

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

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

package/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/src/basket/reference-data/sp500.d.ts

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

package/src/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/src/core/module/ModuleContainer.d.ts

@@ -0,0 +1,15 @@
+import type { VuuModule } from "./VuuModule";
+type RegisteredVuuModule = VuuModule<any>;
+declare class ModuleContainer {
+    #private;
+    private constructor();
+    static get instance(): ModuleContainer;
+    register(module: RegisteredVuuModule): void;
+    unregister(name: string): boolean;
+    has(name: string): boolean;
+    get(name: string): RegisteredVuuModule;
+    get moduleNames(): MapIterator<string>;
+}
+declare const _default: ModuleContainer;
+export default _default;
+export declare const ensureVuuModule: <T extends RegisteredVuuModule>(module: T) => T;

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

@@ -0,0 +1,103 @@
+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 { ModuleDataSource } from "../../ModuleDataSource";
+import { type PermissionFunction } from "../filter/PermissionFilter";
+import { type VuuModuleUser } from "../user/CurrentUser";
+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;
+    /**
+     * The table viewed by this subscription. Row permissions are applied
+     * by the dataSource engine, not by the table.
+     */
+    table: Table;
+    user: VuuModuleUser;
+};
+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>;
+    protected get includeDefaultServices(): boolean;
+    protected beforeSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
+    protected afterSessionSave(_sourceTable: Table, _sessionTable: Table): Promise<void>;
+    /**
+     * Optional, per table. Restricts the rows visible to each viewport, based on
+     * the viewport (and the user who owns it).
+     */
+    protected permissionFunctions?: Partial<Record<T, PermissionFunction>>;
+    /**
+     * Invoked before a dataSource is created. Can be used, for example, to
+     * lazily start a data provider.
+     */
+    protected beforeCreateDataSource?(tableName: T): void;
+    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): ModuleDataSource;
+    getLinks: (subscriptionMap: Map<string, Subscription[]>, vuuLinks: VuuLink[]) => LinkDescriptorWithLabel[];
+    visualLinkService: (message: VuuCreateVisualLink | VuuRemoveVisualLink) => Promise<DataSourceVisualLinkCreatedMessage | undefined>;
+    getVisualLinks: (tableName: string) => LinkDescriptorWithLabel[] | undefined;
+    createDataSource: (tableName: T, viewport?: string, config?: DataSourceConfig & {
+        session?: SessionDataSourceOverrides;
+    }) => DataSourceBase<DataSourceRowWithBigint>;
+    private createPermissionPredicate;
+    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: ModuleDataSource, 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: ModuleDataSource): Table;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-types";
+import { Table } from "../../Table";
+import type { VuuRowDataItemType, VuuTable } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type { 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;
+    /**
+     * Create a materialized (inner) join of two existing tables, backed by an
+     * engine JoinTable, maintained incrementally as either source changes.
+     * Both source tables must already have been created.
+     */
+    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/src/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/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/src/default-column-definitions.d.ts

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