@vuu-ui/vuu-data-test 3.5.2 → 3.5.3

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.5.2",
+  "version": "3.5.3",
   "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.2",
-    "@vuu-ui/vuu-utils": "3.5.2"
+    "@vuu-ui/vuu-data-local": "3.5.3",
+    "@vuu-ui/vuu-utils": "3.5.3"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-protocol-types": "3.5.2",
-    "@vuu-ui/vuu-data-types": "3.5.2",
-    "@vuu-ui/vuu-table-types": "3.5.2"
+    "@vuu-ui/vuu-protocol-types": "3.5.3",
+    "@vuu-ui/vuu-data-types": "3.5.3",
+    "@vuu-ui/vuu-table-types": "3.5.3"
   },
   "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

@@ -1,13 +1,21 @@
+import { type ManagedModule } from "@heswell/module-admin/contracts";
 import type { TableSchema } from "@vuu-ui/vuu-data-types";
-import { VuuModule } from "../core/module/VuuModule";
+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;
-    constructor(snapshot?: ModuleAdminSnapshot);
+    private readonly now;
+    constructor(snapshot?: ModuleAdminSnapshot, now?: () => number);
+    /** Current module state. */
+    get modules(): readonly ManagedModule[];
     get menus(): {
         modulePermissions: undefined;
         modules: undefined;
@@ -15,7 +23,8 @@ export declare class ModuleAdminModule extends VuuModule<ModuleAdminTableName> {
     protected get includeDefaultServices(): boolean;
     get menuServices(): undefined;
     get schemas(): Record<ModuleAdminTableName, Readonly<TableSchema>>;
-    get services(): undefined;
+    private service;
+    get services(): Record<ModuleAdminTableName, RpcService[]>;
     get tables(): ModuleAdminTables;
     get visualLinks(): undefined;
 }

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

@@ -1,4 +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 { ModuleAccessRole, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";
+export type { ManagedModule, ModuleAccessRole, ModuleConfig, ModuleDefinition, ModulePermissionRow, ModuleRow, } from "@heswell/module-admin/contracts";

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

@@ -1,14 +1,13 @@
-import { type ModuleAccessRole, type ModuleDefinition } from "@heswell/module-admin/contracts";
+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 = {
-    moduleAccessRoles: readonly ModuleAccessRole[];
-    modules: readonly ModuleDefinition[];
-    timestamp: number;
+    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,39 @@
+import type { TableSchema } from "@vuu-ui/vuu-data-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;
+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;
+    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,2 @@
+import { NotificationModule } from "../NotificationModule";
+export declare const SimulatedNotificationsModule: () => 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;