@vuu-ui/vuu-data-local 3.3.9 → 3.3.10

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "3.3.9",
+  "version": "3.3.10",
   "main": "./src/index.js",
   "author": "heswell",
   "license": "Apache-2.0",
@@ -10,14 +10,14 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "3.3.9",
-    "@vuu-ui/vuu-table-types": "3.3.9",
-    "@vuu-ui/vuu-filter-types": "3.3.9",
-    "@vuu-ui/vuu-protocol-types": "3.3.9"
+    "@vuu-ui/vuu-data-types": "3.3.10",
+    "@vuu-ui/vuu-table-types": "3.3.10",
+    "@vuu-ui/vuu-filter-types": "3.3.10",
+    "@vuu-ui/vuu-protocol-types": "3.3.10"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "3.3.9",
-    "@vuu-ui/vuu-utils": "3.3.9"
+    "@vuu-ui/vuu-filter-parser": "3.3.10",
+    "@vuu-ui/vuu-utils": "3.3.10"
   },
   "sideEffects": false,
   "files": [

package/types/src/array-data-source/aggregate-utils.d.ts

@@ -0,0 +1,8 @@
+import type { DataSourceRowWithBigint } from "@vuu-ui/vuu-data-types";
+import type { VuuAggregation, VuuGroupBy } from "@vuu-ui/vuu-protocol-types";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
+import type { GroupMap } from "./group-utils";
+export declare const count: (arr: unknown[]) => number;
+export declare const aggregateData: (aggregations: VuuAggregation[], targetData: readonly DataSourceRowWithBigint[], groupBy: VuuGroupBy, leafData: readonly DataSourceRowWithBigint[], columnMap: ColumnMap, groupMap: GroupMap) => {
+    [key: string]: number;
+};

package/types/src/array-data-source/array-data-source.d.ts

@@ -0,0 +1,111 @@
+import type { DataSourceBase, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceRow, 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, VuuRpcRequest, VuuRpcResponse, 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";
+export interface ArrayDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
+    columnDescriptors: readonly ColumnDescriptor[];
+    data: Array<Array<bigint | VuuRowDataItemType>>;
+    dataMap?: ColumnMap;
+    keyColumn?: string;
+    rangeChangeRowset?: "delta" | "full";
+}
+export declare class ArrayDataSource extends EventEmitter<DataSourceEvents> implements DataSourceBase<DataSourceRowWithBigint> {
+    #private;
+    protected clientCallback: DataSourceSubscribeCallback | undefined;
+    protected columnDescriptors: readonly ColumnDescriptor[];
+    /** sorted offsets of data within raw data, reflecting sort order
+     * of columns specified by client.
+     */
+    private dataIndices;
+    /** Map reflecting positions of data items in raw data */
+    private dataMap;
+    private groupMap;
+    /** the index of key field within raw data row */
+    private key;
+    private lastRangeServed;
+    private rangeChangeRowset;
+    private openTreeNodes;
+    private preserveScrollPositionAcrossConfigChange;
+    protected _config: WithBaseFilter<WithFullConfig> & {
+        visualLink?: LinkDescriptorWithLabel;
+    };
+    protected _menu: VuuMenu | undefined;
+    protected selectedRows: Set<string>;
+    protected index: Map<string, number>;
+    tableSchema: TableSchema;
+    viewport: string;
+    protected processedData: DataSourceRowWithBigint[] | undefined;
+    constructor({ aggregations, baseFilterSpec, columnDescriptors, data, dataMap, filterSpec, groupBy, keyColumn, rangeChangeRowset, sort, title, viewport, }: ArrayDataSourceConstructorProps);
+    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;
+    select(selectRequest: Omit<SelectRequest, "vpId">): void;
+    private getRowKey;
+    openTreeNode(keyOrIndex: string | number): void;
+    closeTreeNode(keyOrIndex: string | number): void;
+    get pageSize(): number;
+    get links(): LinkDescriptorWithLabel[] | undefined;
+    set links(links: LinkDescriptorWithLabel[] | undefined);
+    get menu(): VuuMenu | undefined;
+    get status(): DataSourceStatus;
+    get data(): DataSourceRow<bigint | VuuRowDataItemType>[];
+    get currentData(): DataSourceRow<bigint | VuuRowDataItemType>[];
+    get table(): import("@vuu-ui/vuu-data-types").TableSchemaTable;
+    get columns(): string[];
+    set columns(columns: string[]);
+    get config(): WithBaseFilter<WithFullConfig>;
+    set config(config: WithBaseFilter<WithFullConfig>);
+    private processNewColumns;
+    private indexProcessedData;
+    private getFilterPredicate;
+    private applyConfig;
+    get columnMap(): ColumnMap;
+    get selectedRowsCount(): number;
+    get size(): number;
+    get maxRangeEnd(): number;
+    get range(): Range;
+    set range(range: Range);
+    protected delete(row: VuuRowDataItemType[]): void;
+    protected insert: (row: Array<bigint | VuuRowDataItemType>) => void;
+    private insertIntoSortedData;
+    private validateDataValue;
+    protected updateDataItem: (keyValue: string, columnName: string, value: VuuRowDataItemType) => void;
+    getRowByKey(key: string): DataSourceRow<bigint | VuuRowDataItemType> | undefined;
+    getRowAtIndex(rowIndex: number): DataSourceRow<bigint | VuuRowDataItemType>;
+    indexOfRowWithKey: (key: string) => number;
+    protected update: (row: VuuRowDataItemType[], columnName: string) => void;
+    protected updateRow: (row: Array<bigint | VuuRowDataItemType>, _columnName?: string) => void;
+    protected handleDeleteFromTable: (key: string) => Promise<true | string>;
+    private setRange;
+    private constrainRangeToMaxRangeEnd;
+    private get rangeWithBufferWithinMaxRangeEnd();
+    sendSizeUpdateToClient(): void;
+    sendRowsToClient(forceFullRefresh?: boolean, row?: DataSourceRowWithBigint): void;
+    get aggregations(): VuuAggregation[];
+    set aggregations(aggregations: VuuAggregation[]);
+    get sort(): VuuSort;
+    set sort(sort: VuuSort);
+    get baseFilter(): DataSourceFilter | undefined;
+    set baseFilter(baseFilter: DataSourceFilter | undefined);
+    get filter(): DataSourceFilter;
+    set filter(filter: DataSourceFilter);
+    setFilter(filter: Filter): void;
+    clearFilter(): void;
+    get groupBy(): VuuGroupBy;
+    set groupBy(groupBy: VuuGroupBy);
+    get title(): string;
+    set title(title: string);
+    get _clientCallback(): DataSourceSubscribeCallback | undefined;
+    createLink({ parentVpId, link: { fromColumn, toColumn }, }: LinkDescriptorWithLabel): void;
+    removeLink(): void;
+    remoteProcedureCall<T extends VuuRpcResponse = VuuRpcResponse>(): Promise<T>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcRequest, "vpId">): Promise<VuuRpcResponse>;
+    freeze(): void;
+    unfreeze(): void;
+    get freezeTimestamp(): number | undefined;
+    get isFrozen(): boolean;
+}

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

@@ -0,0 +1,4 @@
+import type { DataSourceRow, DataSourceRowWithBigint } from "@vuu-ui/vuu-data-types";
+import { ColumnMap, KeySet } from "@vuu-ui/vuu-utils";
+export declare const toClientRow: (row: DataSourceRowWithBigint, keys: KeySet, selectedRows: Set<string>, dataIndices?: number[]) => DataSourceRow;
+export declare const buildDataToClientMap: (columnMap: ColumnMap, dataMap?: ColumnMap) => number[] | undefined;

package/types/src/array-data-source/group-utils.d.ts

@@ -0,0 +1,10 @@
+import type { DataSourceRow } from "@vuu-ui/vuu-data-types";
+import type { VuuGroupBy, VuuRowDataItemType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "@vuu-ui/vuu-utils";
+export type KeyList = number[];
+export type GroupMap = {
+    [key: string]: GroupMap | KeyList;
+};
+export declare const collapseGroup: (key: string, groupedRows: readonly DataSourceRow<bigint | VuuRowDataItemType>[]) => DataSourceRow<bigint | VuuRowDataItemType>[];
+export declare const expandGroup: (keys: string[], sourceRows: readonly DataSourceRow<bigint | VuuRowDataItemType>[], groupBy: VuuGroupBy, columnMap: ColumnMap, groupMap: GroupMap, processedData: readonly DataSourceRow[]) => DataSourceRow[];
+export declare const groupRows: (rows: ReadonlyArray<Array<bigint | VuuRowDataItemType>>, groupBy: VuuGroupBy, columnMap: ColumnMap) => [DataSourceRow[], GroupMap];

package/types/src/array-data-source/sort-utils.d.ts

@@ -0,0 +1,10 @@
+import type { DataSourceRowWithBigint } from "@vuu-ui/vuu-data-types";
+import type { VuuSort, VuuSortType } from "@vuu-ui/vuu-protocol-types";
+import { ColumnMap } from "@vuu-ui/vuu-utils";
+export type ColIndexSortDef = [number, VuuSortType];
+type SortCompareResult = 0 | 1 | -1;
+export type RowSortComparator = (item1: DataSourceRowWithBigint, item2: DataSourceRowWithBigint) => SortCompareResult;
+export declare const sortComparator: (sortDefs: ColIndexSortDef[]) => RowSortComparator;
+export declare const sortRows: (rows: readonly DataSourceRowWithBigint[], { sortDefs }: VuuSort, columnMap: ColumnMap) => DataSourceRowWithBigint[];
+export declare function binarySearch(items: DataSourceRowWithBigint[], item: DataSourceRowWithBigint, comparator: RowSortComparator): number;
+export {};

package/types/src/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./array-data-source/array-data-source";
+export * from "./json-data-source/JsonDataSource";
+export * from "./tree-data-source/TreeDataSource";

package/types/src/json-data-source/JsonDataSource.d.ts

@@ -0,0 +1,55 @@
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import type { LinkDescriptorWithLabel, VuuGroupBy, VuuAggregation, VuuSort, VuuRpcResponse, VuuRpcRequest, SelectRequest } from "@vuu-ui/vuu-protocol-types";
+import type { DataSourceFilter, DataSourceRow, DataSourceConstructorProps, DataSourceEvents, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, WithFullConfig, MenuRpcResponse, DataSourceBase } from "@vuu-ui/vuu-data-types";
+import { EventEmitter, JsonData, Range } from "@vuu-ui/vuu-utils";
+export interface JsonDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
+    data: JsonData;
+}
+export declare class JsonDataSource extends EventEmitter<DataSourceEvents> implements DataSourceBase {
+    #private;
+    columnDescriptors: ColumnDescriptor[];
+    private clientCallback;
+    private expandedRows;
+    private visibleRows;
+    rowCount: number | undefined;
+    viewport: string;
+    private keys;
+    constructor({ aggregations, data, filterSpec, groupBy, sort, title, viewport, }: JsonDataSourceConstructorProps);
+    subscribe({ viewport, columns, aggregations, range, sort, groupBy, filterSpec, }: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    unsubscribe(): void;
+    suspend(): this;
+    resume(): this;
+    disable(): this;
+    enable(): this;
+    set data(data: JsonData);
+    select(selectRequest: Omit<SelectRequest, "vpId">): void;
+    private getRowKey;
+    openTreeNode(keyOrIndex: string | number): void;
+    closeTreeNode(keyOrIndex: string | number, cascade?: boolean): void;
+    get status(): DataSourceStatus;
+    get config(): WithFullConfig;
+    applyConfig(): import("@vuu-ui/vuu-utils").MaybeDataSourceConfigChanges;
+    get selectedRowsCount(): number;
+    get size(): number;
+    get range(): Range;
+    set range(range: Range);
+    private sendRowsToClient;
+    get columns(): string[];
+    set columns(columns: string[]);
+    get aggregations(): VuuAggregation[];
+    set aggregations(aggregations: VuuAggregation[]);
+    get sort(): VuuSort;
+    set sort(sort: VuuSort);
+    get filter(): DataSourceFilter;
+    set filter(filter: DataSourceFilter);
+    get groupBy(): VuuGroupBy;
+    set groupBy(groupBy: VuuGroupBy);
+    get title(): string;
+    set title(title: string);
+    createLink({ parentVpId, link: { fromColumn, toColumn }, }: LinkDescriptorWithLabel): void;
+    removeLink(): void;
+    remoteProcedureCall<T extends VuuRpcResponse = VuuRpcResponse>(): Promise<T>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcRequest, "vpId">): Promise<MenuRpcResponse | undefined>;
+    getChildRows(rowKey: string): DataSourceRow[];
+    getRowsAtDepth(depth: number, visibleOnly?: boolean): DataSourceRow[];
+}

package/types/src/tree-data-source/IconProvider.d.ts

@@ -0,0 +1,6 @@
+import { DataRow } from "@vuu-ui/vuu-table-types";
+export declare class IconProvider {
+    #private;
+    getIcon: (dataRow: DataRow) => string;
+    setIcon(key: string, icon: string): void;
+}

package/types/src/tree-data-source/TreeDataSource.d.ts

@@ -0,0 +1,51 @@
+import type { ColumnDescriptor } from "@vuu-ui/vuu-table-types";
+import type { LinkDescriptorWithLabel, VuuRange, VuuRpcResponse, VuuRpcRequest, SelectRequest } from "@vuu-ui/vuu-protocol-types";
+import type { DataSourceRow, DataSourceConstructorProps, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, MenuRpcResponse, DataSourceFilter, DataSourceBase } from "@vuu-ui/vuu-data-types";
+import { BaseDataSource, TreeSourceNode } from "@vuu-ui/vuu-utils";
+export interface TreeDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
+    data: TreeSourceNode[];
+}
+export declare class TreeDataSource extends BaseDataSource implements DataSourceBase {
+    #private;
+    columnDescriptors: ColumnDescriptor[];
+    private clientCallback;
+    private expandedRows;
+    private visibleRows;
+    private visibleRowIndex;
+    rowCount: number | undefined;
+    private keys;
+    constructor({ data, ...props }: TreeDataSourceConstructorProps);
+    subscribe({ aggregations, columns, range, revealSelected, selectedKeyValues, viewport, }: DataSourceSubscribeProps, callback: DataSourceSubscribeCallback): Promise<void>;
+    unsubscribe(): void;
+    suspend(): this;
+    resume(): this;
+    disable(): this;
+    enable(): this;
+    set data(data: TreeSourceNode[]);
+    get filter(): DataSourceFilter;
+    set filter(filter: DataSourceFilter);
+    private applyFilter;
+    /**
+     * used to apply an initial selection. These may not necessarily be
+     * visible. If revealOnSelect is in force, expand nodes as necessary
+     * to ensure selected nodes are visible
+     */
+    private applySelectedKeyValues;
+    private indexOfRowWithKey;
+    select(selectRequest: Omit<SelectRequest, "vpId">): void;
+    private getRowKey;
+    openTreeNode(keyOrIndex: string | number): void;
+    closeTreeNode(keyOrIndex: string | number, cascade?: boolean): void;
+    get status(): DataSourceStatus;
+    get selectedRowsCount(): number;
+    get size(): number;
+    rangeRequest(range: VuuRange): void;
+    private sendRowsToClient;
+    createLink({ parentVpId, link: { fromColumn, toColumn }, }: LinkDescriptorWithLabel): void;
+    removeLink(): void;
+    remoteProcedureCall<T extends VuuRpcResponse = VuuRpcResponse>(): Promise<T>;
+    menuRpcCall(rpcRequest: Omit<VuuRpcRequest, "vpId">): Promise<MenuRpcResponse | undefined>;
+    getChildRows(rowKey: string): DataSourceRow[];
+    getRowsAtDepth(depth: number, visibleOnly?: boolean): DataSourceRow[];
+    getRowAtIndex(rowIdx: number): DataSourceRow;
+}