@heswell/vuu-data-engine-local 4.0.0-alpha.20 → 4.0.0

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

@@ -1,21 +1,48 @@
+import { type JoinType } from "@heswell/vuu-table";
 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 {
+/**
+ * Create a table. The table is not registered anywhere; it belongs to
+ * whichever VuuModule returns it from `tables`.
+ */
+export declare const createTable: (schema: TableSchema, data?: Array<Array<VuuRowDataItemType | bigint>>, dataMap?: ColumnMap, updateGenerator?: UpdateGenerator) => Table;
+/**
+ * Create a materialized join of two tables, backed by an engine JoinTable,
+ * maintained incrementally as either source changes. `joinType` defaults to
+ * "inner" (only rows with a match in table2). With "leftOuter" every table1
+ * row is present and unmatched table2 columns are null, as in vuu-server.
+ */
+export declare const createJoinTable: (joinTable: VuuTable, table1: Table, table2: Table, joinColumn: string, joinType?: JoinType) => Table;
+/**
+ * Tables, keyed by `{module, table}`. Each LocalEngine owns one, populated
+ * from the tables of its registered modules. Tables created through
+ * `createTable` / `createJoinTable` are added to this container.
+ */
+export 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.
+     * Create a join of two tables already in this container. Pass full
+     * `{module, table}` references; a bare name is accepted only if unique.
      */
-    createJoinTable(joinTable: VuuTable, { table: t1 }: VuuTable, { table: t2 }: VuuTable, joinColumn: string): Table;
-    addTable(table: Table): void;
-    getTable<T = Table>(tableName: string): NonNullable<T>;
+    createJoinTable(joinTable: VuuTable, table1: VuuTable | string, table2: VuuTable | string, joinColumn: string, joinType?: JoinType): Table;
+    /**
+     * Add a table, keyed by `as` if given, otherwise by its schema's
+     * `{module, table}`.
+     */
+    addTable(table: Table, as?: VuuTable): void;
+    removeTable(table: VuuTable): boolean;
+    hasTable(table: VuuTable): boolean;
+    /**
+     * Resolve a table by `{module, table}`. A bare table name is accepted for
+     * backward compatibility, but only resolves if exactly one module has a
+     * table with that name.
+     */
+    getTable(table: VuuTable | string): Table;
+    getTable<T>(table: VuuTable | string): T;
+    get tables(): Table[];
+    clear(): void;
 }
-declare const _default: TableContainer;
-export default _default;

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

@@ -0,0 +1,6 @@
+import type { TableContainer } from "./TableContainer";
+/**
+ * @deprecated The default engine's table container, resolved lazily on each
+ * access. Use `engine.tableContainer` of an engine you create.
+ */
+export declare const tableContainer: TableContainer;

package/src/data-utils.d.ts

@@ -5,3 +5,10 @@ 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;
+/**
+ * Copy rows, so tables created from shared reference data do not share
+ * (and mutate) the same row arrays.
+ */
+export declare const cloneRows: <R extends unknown[]>(rows: readonly R[]) => R[];
+/** Memoise a zero-arg factory. */
+export declare const lazy: <V>(factory: () => V) => () => V;

package/src/demo-modules.d.ts

@@ -0,0 +1,18 @@
+import { BasketModule } from "./basket/BasketModule";
+import { type LocalEngine } from "./core/engine/LocalEngine";
+import { SimulModule } from "./simul/SimulModule";
+import { TestModule } from "./test/TestModule";
+export type DemoModules = {
+    simulModule: SimulModule;
+    basketModule: BasketModule;
+    testModule: TestModule;
+};
+/**
+ * Create new SIMUL, BASKET and TEST demo modules and register them with an
+ * engine (by default, the default engine used by LocalDataSourceProvider).
+ * BASKET shares SIMUL's prices table. Prices tick only once a dataSource is
+ * created; `engine.dispose()` stops all timers.
+ *
+ * Nothing is created or registered until this is called.
+ */
+export declare const registerDemoModules: (engine?: LocalEngine) => DemoModules;

package/src/index.d.ts

@@ -1,10 +1,13 @@
 export * from "./ArrayProxy";
 export * from "./core/filter/PermissionFilter";
 export * from "./core/module/VuuModule";
-export { ensureVuuModule } from "./core/module/ModuleContainer";
+export * from "./core/module/edit-hooks";
+export { type AnyVuuModule, createLocalEngine, ensureVuuModule, getDefaultEngine, LocalEngine, type LocalEngineOptions, resetDefaultEngine, } from "./core/engine/LocalEngine";
 export * from "./core/user/CurrentUser";
-export { default as tableContainer } from "./core/table/TableContainer";
-export * from "./local-datasource-provider/LocalDatasourceProvider";
+export { createJoinTable, createTable, TableContainer, } from "./core/table/TableContainer";
+export { tableContainer } from "./core/table/defaultTableContainer";
+export { registerDemoModules, type DemoModules } from "./demo-modules";
+export { BaseUpdateGenerator } from "./UpdateGenerator";
 export * from "./makeSuggestions";
 export * from "./notifications";
 export * from "./schemas";

package/src/legacy.d.ts

@@ -0,0 +1,12 @@
+import { ModuleAdminModule } from "./module-admin/ModuleAdminModule";
+import { UserAdminModule } from "./user-admin/UserAdminModule";
+export * from "./index";
+export * from "./react";
+/** @deprecated */
+export declare const simulModule: import("./simul").SimulModule, basketModule: import("./basket").BasketModule, testModule: import("./test").TestModule;
+/** @deprecated */
+export declare const moduleAdminModule: ModuleAdminModule;
+/** @deprecated */
+export declare const userAdminModule: UserAdminModule;
+/** @deprecated */
+export declare const notificationsModule: import("./notifications").NotificationModule;

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

@@ -1,18 +1,29 @@
-import { type LocalVuuServer } from "@vuu-ui/core";
+import type { LocalVuuServer } from "@vuu-ui/core";
 import type { ReactNode } from "react";
-import type { VuuModule } from "../core/module/VuuModule";
-/** Data context covering every VuuModule registered in the browser. */
-export declare const LocalDataSourceProvider: ({ children }: {
+import { type AnyVuuModule, LocalEngine } from "../core/engine/LocalEngine";
+/**
+ * Data context covering every VuuModule registered with the default engine.
+ * @deprecated use `engine.DataSourceProvider` (see `createLocalEngine`).
+ */
+export declare const LocalDataSourceProvider: ({ children, }: {
     children: ReactNode;
 }) => import("react").JSX.Element;
 export interface LocalVuuServerOptions {
     /** Matches the `vuu.connectionId` of the modules this server serves. */
     connectionId: string;
-    modules: VuuModule<any>[];
+    modules: AnyVuuModule[];
+    /**
+     * The engine to register the modules with. Defaults to a new, isolated
+     * engine, so each server publishes only its own modules.
+     */
+    engine?: LocalEngine;
 }
 /**
  * Simulates a Vuu server in the browser, publishing the tables of the given
  * modules. Pass the result to a local-mode `AuthenticationProvider` as one of
- * its `localServers`.
+ * its `localServers`. The returned `engine` can be disposed when the server
+ * is no longer needed.
  */
-export declare const createLocalVuuServer: ({ connectionId, modules, }: LocalVuuServerOptions) => LocalVuuServer;
+export declare const createLocalVuuServer: ({ connectionId, modules, engine, }: LocalVuuServerOptions) => LocalVuuServer & {
+    engine: LocalEngine;
+};

package/src/local-datasource-provider/createDataSourceProvider.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import type { LocalEngine } from "../core/engine/LocalEngine";
+/**
+ * Creates a Provider that installs both legacy and core data contexts,
+ * backed by the VuuModules registered with `engine`. Modules are resolved
+ * when used, so modules registered later are visible too.
+ */
+export declare const createDataSourceProvider: (engine: LocalEngine) => (({ children }: {
+    children: ReactNode;
+}) => ReactNode) | (({ children }: {
+    children: ReactNode;
+}) => import("react").JSX.Element);

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

@@ -28,5 +28,4 @@ export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     get tables(): ModuleAdminTables;
     get visualLinks(): undefined;
 }
-export declare const moduleAdminModule: ModuleAdminModule;
 export {};

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

@@ -1,4 +1,4 @@
-export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, moduleAdminModule, } from "./ModuleAdminModule";
+export { ModuleAdminModule, MODULE_ADMIN_INITIAL_SNAPSHOT, } 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";
+export type { ManagedModule, ModuleConfig, } from "@heswell/module-admin/contracts";

package/src/notifications/NotificationModule.d.ts

@@ -29,6 +29,7 @@ export declare class NotificationModule extends VuuModule<NotificationsTableName
     protected beforeCreateDataSource(): void;
     get isRunning(): boolean;
     start(): void;
+    dispose(): void;
     stop(): void;
     get menus(): undefined;
     get menuServices(): undefined;

package/src/notifications/index.d.ts

@@ -3,4 +3,3 @@ export * from "./NotificationsSchema";
 export * from "./simulated/DismissNotificationRpcHandler";
 export * from "./simulated/SimulatedNotificationsModule";
 export * from "./simulated/SimulatedNotificationsProvider";
-export * from "./simulated/notificationsModule";

package/src/react.d.ts

@@ -0,0 +1,7 @@
+/**
+ * React bindings for the local engine. Kept out of the main entry because
+ * `@vuu-ui/core` (via `@vuu-ui/vuu-ui-controls`) needs a DOM at import time
+ * (`ResizeObserver`); the main entry runs in plain Node/Bun.
+ */
+export * from "./local-datasource-provider/LocalDatasourceProvider";
+export { createDataSourceProvider } from "./local-datasource-provider/createDataSourceProvider";

package/src/simul/SimulModule.d.ts

@@ -1,6 +1,7 @@
 import type { VuuLink, VuuMenu } from "@vuu-ui/vuu-protocol-types";
 import { type MenuServiceHandler, type RpcMenuService, type RpcService, type ServiceHandler, VuuModule } from "../core/module/VuuModule";
 import type { Table } from "../Table";
+import { type PricesTable } from "./reference-data/prices";
 import { type SimulTableName } from "./simul-schemas";
 /**
  * This is an example of how we might extend the built-in VuuModule to
@@ -9,7 +10,15 @@ import { type SimulTableName } from "./simul-schemas";
  */
 export declare class SimulModule extends VuuModule<SimulTableName> {
     #private;
+    /**
+     * Each instance generates its own tables. Prices start ticking when the
+     * first dataSource is created; call `dispose` to stop all timers.
+     */
     constructor();
+    protected beforeCreateDataSource(): void;
+    /** The prices table and its update generator, e.g. to share with BasketModule. */
+    get prices(): PricesTable;
+    dispose(): void;
     get menus(): Record<SimulTableName, VuuMenu | undefined> | undefined;
     get schemas(): Readonly<Record<SimulTableName, Readonly<import("@vuu-ui/vuu-data-types").TableSchema>>>;
     get editServices(): undefined;
@@ -21,4 +30,3 @@ export declare class SimulModule extends VuuModule<SimulTableName> {
     startOrders: ServiceHandler;
     stopOrders: ServiceHandler;
 }
-export declare const simulModule: SimulModule;

package/src/simul/index.d.ts

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

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

@@ -56,5 +56,5 @@ export declare const InstrumentPricesColumnMap: {
     vuuCreatedTimestamp: number;
     vuuUpdatedTimestamp: number;
 };
-declare const instrumentPrices: InstrumentPricesDataRow[];
-export { instrumentPrices };
+export declare const getInstrumentPrices: () => InstrumentPricesDataRow[];
+export {};

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

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

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

@@ -29,7 +29,6 @@ export declare const InstrumentColumnMap: {
     readonly vuuUpdatedTimestamp: 8;
     readonly vuuMsg: 9;
 };
-declare const instrumentsData: InstrumentsDataRow[];
+export declare const getInstrumentsData: () => InstrumentsDataRow[];
 export declare const getRic: (defaultRic: string) => string;
-export declare const instrumentsTable: import("../..").Table;
-export { instrumentsData };
+export declare const createInstrumentsTable: () => import("../..").Table;

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

@@ -31,6 +31,5 @@ export declare const OrderColumnMap: {
     readonly side: 7;
     readonly trader: 8;
 };
-declare const ordersData: OrdersDataRow[];
-export declare const ordersTable: import("../..").Table;
-export { ordersData };
+export declare const getOrdersData: () => OrdersDataRow[];
+export declare const createOrdersTable: () => import("../..").Table;

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

@@ -1,4 +1,15 @@
-export declare const parentOrdersTable: import("../..").Table;
-export declare const childOrdersTable: import("../..").Table;
-export declare function startGeneratingNewOrders(): void;
-export declare function stopGeneratingNewOrders(): void;
+import type { Table } from "../../Table";
+/**
+ * Generated parent and child orders. Each instance has its own tables
+ * and (optional) timer generating new orders.
+ */
+export declare class ParentChildOrders {
+    #private;
+    readonly parentOrdersTable: Table;
+    readonly childOrdersTable: Table;
+    constructor();
+    get isGenerating(): boolean;
+    startGeneratingNewOrders(): void;
+    stopGeneratingNewOrders(): void;
+    createParentAndChildOrders(): void;
+}

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

@@ -1,3 +1,5 @@
+import { type Table } from "../../Table";
+import { BaseUpdateGenerator } from "../../UpdateGenerator";
 type ask = number;
 type askSize = number;
 type bid = number;
@@ -26,9 +28,19 @@ export type PricesDataRow = [
     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 };
+export declare const getPricesData: () => PricesDataRow[];
+export type PricesTableOptions = {
+    /**
+     * Start ticking prices immediately. Default false, call
+     * `updateGenerator.start()`.
+     */
+    autoStart?: boolean;
+};
+export type PricesTable = {
+    table: Table;
+    updateGenerator?: BaseUpdateGenerator;
+};
+export declare const createPricesTable: ({ autoStart, }?: PricesTableOptions) => PricesTable & {
+    updateGenerator: BaseUpdateGenerator;
+};
+export {};

package/src/test/TestModule.d.ts

@@ -2,7 +2,8 @@ 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> {
+export declare const testSchemas: Record<TestTableName, TableSchema>;
+export declare class TestModule extends VuuModule<TestTableName> {
     #private;
     constructor();
     get menus(): undefined;
@@ -12,5 +13,3 @@ declare class TestModule extends VuuModule<TestTableName> {
     get tables(): Record<TestTableName, Table>;
     get visualLinks(): undefined;
 }
-export declare const testModule: TestModule;
-export {};

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

@@ -50,5 +50,4 @@ export declare class UserAdminModule extends VuuModule<UserAdminTableName> {
     private setUserModuleAccess;
     private assertUsernameIsUnique;
 }
-export declare const userAdminModule: UserAdminModule;
 export {};

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

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

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

@@ -1,24 +0,0 @@
-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/core/module/ModuleContainer.d.ts

@@ -1,15 +0,0 @@
-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/notifications/simulated/notificationsModule.d.ts

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