@vuu-ui/vuu-data-local 4.0.1 → 5.0.0-alpha.1

package/package.json

@@ -1,23 +1,23 @@
 {
-  "version": "4.0.1",
+  "version": "5.0.0-alpha.1",
   "main": "./src/index.js",
   "author": "heswell",
+  "type": "module",
   "license": "Apache-2.0",
   "scripts": {
-    "build:dev": "node ../../scripts/run-build.mjs",
     "build": "node ../../scripts/run-build-rslib.ts",
     "test": "vitest run",
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.1",
-    "@vuu-ui/vuu-table-types": "4.0.1",
-    "@vuu-ui/vuu-filter-types": "4.0.1",
-    "@vuu-ui/vuu-protocol-types": "4.0.1"
+    "@vuu-ui/vuu-data-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-table-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-filter-types": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-protocol-types": "5.0.0-alpha.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "4.0.1",
-    "@vuu-ui/vuu-utils": "4.0.1"
+    "@vuu-ui/vuu-filter-parser": "5.0.0-alpha.1",
+    "@vuu-ui/vuu-utils": "5.0.0-alpha.1"
   },
   "sideEffects": false,
   "files": [
@@ -27,13 +27,12 @@
   ],
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./src/index.js",
-      "default": "./src/index.js",
-      "types": "./types/index.d.ts"
+      "default": "./src/index.js"
     }
   },
   "module": "./src/index.js",
   "name": "@vuu-ui/vuu-data-local",
-  "type": "module",
   "types": "types/index.d.ts"
 }

package/src/array-data-source/array-data-source.js

@@ -71,7 +71,7 @@ class ArrayDataSource extends EventEmitter {
         this.columnDescriptors = columnDescriptors;
         this.#filterColumnsByName = getColumnsByName(columnDescriptors);
         this.dataMap = dataMap;
-        this.key = keyColumn ? this.columnDescriptors.findIndex((col)=>col.name === keyColumn) : 0;
+        this.key = keyColumn ? dataMap?.[keyColumn] ?? this.columnDescriptors.findIndex((col)=>col.name === keyColumn) : 0;
         this.rangeChangeRowset = rangeChangeRowset;
         this.tableSchema = buildTableSchema(columnDescriptors, keyColumn);
         this.viewport = viewport || uuid();
@@ -120,8 +120,15 @@ class ArrayDataSource extends EventEmitter {
         };
         this.clientCallback?.(subscribedMessage);
         this.emit("subscribed", subscribedMessage);
-        if (hasConfigProps) this.config = config;
-        else {
+        if (hasConfigProps) {
+            if (range) {
+                this.constrainRangeToMaxRangeEnd(range);
+                this.#range = range;
+                this.#keys.reset(this.rangeWithBufferWithinMaxRangeEnd);
+            }
+            this.config = config;
+            this.sendRowsToClient(true);
+        } else {
             this.sendSizeUpdateToClient();
             this.emit("resize", this.processedData ? this.processedData.length : this.#data.length, this.#maxRangeEnd);
             if (range && !this.#range.equals(range)) this.range = range;
@@ -452,17 +459,17 @@ class ArrayDataSource extends EventEmitter {
     }
     indexOfRowWithKey = (key)=>this.#data.findIndex((row)=>row[KEY] === key);
     update = (row, columnName)=>{
-        const keyValue = row[this.key];
+        const keyValue = String(row[this.key]);
         const dataColIndex = this.dataMap?.[columnName];
         return this.updateDataItem(keyValue, columnName, row[dataColIndex]);
     };
     updateRow = (row, _columnName)=>{
-        const keyValue = row[this.key];
+        const keyValue = String(row[this.key]);
         const dataIndex = this.#data.findIndex((row)=>row[KEY] === keyValue);
         if (-1 !== dataIndex) {
             const dataSourceRow = toDataSourceRow(this.key)(row, dataIndex);
             this.#data[dataIndex] = dataSourceRow;
-            const { from, to } = this.#range;
+            const { from, to } = this.rangeWithBufferWithinMaxRangeEnd;
             const isFiltered = hasFilter(this.config) || hasBaseFilter(this.config);
             const isSorted = hasSort(this.config);
             if (isFiltered) {

package/src/tree-data-source/TreeDataSource.js

@@ -1,4 +1,4 @@
-import { BaseDataSource, KeySet, NULL_RANGE, getParentRow, isSingleValueFilter, lastPathSegment, metadataKeys, missingAncestor, treeToDataSourceRows, uuid } from "@vuu-ui/vuu-utils";
+import { BaseDataSource, KeySet, NULL_RANGE, getParentRow, isSingleValueFilter, lastPathSegment, metadataKeys, treeToDataSourceRows, uuid } from "@vuu-ui/vuu-utils";
 import { IconProvider } from "./IconProvider.js";
 import { parseFilter } from "@vuu-ui/vuu-filter-parser";
 const treeSchema = (columns)=>({
@@ -32,6 +32,7 @@ class TreeDataSource extends BaseDataSource {
     #size = 0;
     #status = "initialising";
     #filterSet;
+    #filterCollapsedRows = new Set();
     rowCount;
     keys = new KeySet(this._range);
     constructor({ data, ...props }){
@@ -40,7 +41,6 @@ class TreeDataSource extends BaseDataSource {
         this.#iconProvider = new IconProvider();
         [this.columnDescriptors, this.#data] = treeToDataSourceRows(data, this.#iconProvider);
         this.expandedRows = getInitiallyExpandedKeys(data);
-        console.table(this.#data);
         if (this.columnDescriptors) {
             const columns = this.columnDescriptors.map((c)=>c.name);
             this._configWithVisualLink = {
@@ -62,7 +62,7 @@ class TreeDataSource extends BaseDataSource {
         this.#status = "subscribed";
         this.#selectedRowsCount = selectedKeyValues?.length ?? 0;
         if (selectedKeyValues) this.applySelectedKeyValues(selectedKeyValues, revealSelected);
-        [this.visibleRows, this.visibleRowIndex] = getVisibleRows(this.#data, this.expandedRows);
+        this.computeVisibleRows();
         this.clientCallback?.({
             aggregations: this.#aggregations,
             type: "subscribed",
@@ -72,7 +72,7 @@ class TreeDataSource extends BaseDataSource {
             groupBy: this._configWithVisualLink.groupBy,
             range: this.range,
             sort: this.sort,
-            tableSchema: treeSchema(this.columnDescriptors)
+            tableSchema: this.tableSchema
         });
         this.clientCallback({
             clientViewportId: this.viewport,
@@ -118,7 +118,32 @@ class TreeDataSource extends BaseDataSource {
         };
         if (filter.filter) this.applyFilter(filter);
         else this.#filterSet = void 0;
-        [this.visibleRows, this.visibleRowIndex] = getVisibleRows(this.#data, this.expandedRows, this.#filterSet);
+        this.refreshVisibleRows();
+    }
+    filterNodes(predicate) {
+        if (predicate) {
+            const filterSet = [];
+            const { count: nodeDataIndex } = metadataKeys;
+            for (const row of this.#data){
+                const { [DEPTH]: depth, [KEY]: key, [IDX]: idx } = row;
+                const label = row[nodeDataIndex + depth];
+                if (predicate({
+                    depth,
+                    key,
+                    label: "string" == typeof label ? label : "",
+                    nodeData: row[nodeDataIndex]
+                })) filterSet.push(idx);
+            }
+            this.#filterSet = filterSet;
+        } else this.#filterSet = void 0;
+        this.refreshVisibleRows();
+    }
+    computeVisibleRows() {
+        [this.visibleRows, this.visibleRowIndex] = getVisibleRows(this.#data, this.expandedRows, this.#filterSet, this.#filterCollapsedRows);
+    }
+    refreshVisibleRows() {
+        this.#filterCollapsedRows.clear();
+        this.computeVisibleRows();
         const { from, to } = this.range;
         this.clientCallback?.({
             clientViewportId: this.viewport,
@@ -134,8 +159,9 @@ class TreeDataSource extends BaseDataSource {
             const filterSet = [];
             const regex = new RegExp(`${filter.value}`, "i");
             for (const row of this.#data){
-                const { [KEY]: key, [IDX]: idx } = row;
-                if (regex.test(lastPathSegment(key, "|"))) filterSet.push(idx);
+                const { [DEPTH]: depth, [KEY]: key, [IDX]: idx } = row;
+                const label = row[metadataKeys.count + depth];
+                if (regex.test(lastPathSegment(key, "|")) || "string" == typeof label && regex.test(label)) filterSet.push(idx);
             }
             this.#filterSet = filterSet;
         }
@@ -198,8 +224,9 @@ class TreeDataSource extends BaseDataSource {
     }
     openTreeNode(keyOrIndex) {
         const key = this.getRowKey(keyOrIndex);
-        this.expandedRows.add(key);
-        [this.visibleRows, this.visibleRowIndex] = getVisibleRows(this.#data, this.expandedRows);
+        if (this.#filterSet) this.#filterCollapsedRows.delete(key);
+        else this.expandedRows.add(key);
+        this.computeVisibleRows();
         const { from, to } = this._range;
         this.clientCallback?.({
             clientViewportId: this.viewport,
@@ -211,13 +238,19 @@ class TreeDataSource extends BaseDataSource {
     }
     closeTreeNode(keyOrIndex, cascade = false) {
         const key = this.getRowKey(keyOrIndex);
-        this.expandedRows.delete(key);
-        if (cascade) {
-            for (const rowKey of this.expandedRows.keys())if (rowKey.startsWith(key)) this.expandedRows.delete(rowKey);
+        if (this.#filterSet) this.#filterCollapsedRows.add(key);
+        else {
+            this.expandedRows.delete(key);
+            if (cascade) {
+                for (const rowKey of this.expandedRows.keys())if (rowKey.startsWith(key)) this.expandedRows.delete(rowKey);
+            }
         }
-        [this.visibleRows, this.visibleRowIndex] = getVisibleRows(this.#data, this.expandedRows);
+        this.computeVisibleRows();
         this.sendRowsToClient();
     }
+    get tableSchema() {
+        return treeSchema(this.columnDescriptors);
+    }
     get status() {
         return this.#status;
     }
@@ -287,44 +320,45 @@ class TreeDataSource extends BaseDataSource {
     }
 }
 const getInitiallyExpandedKeys = (treeSourceNodes, keyBase = "$root", expandedKeys = new Set())=>{
-    for (const { childNodes, expanded, label } of treeSourceNodes){
-        const key = `${keyBase}|${label}`;
+    for (const { childNodes, expanded, keySegment, label } of treeSourceNodes){
+        const key = `${keyBase}|${keySegment ?? label}`;
         if (expanded) expandedKeys.add(key);
         if (childNodes) getInitiallyExpandedKeys(childNodes, key, expandedKeys);
     }
     return expandedKeys;
 };
-function getVisibleRows(rows, expandedKeys, filterset) {
+function getVisibleRows(rows, expandedKeys, filterset, filterCollapsedKeys) {
     const visibleRows = [];
     const visibleRowIndex = {};
-    const data = filterset ?? rows;
-    for(let i = 0, index = 0; i < data.length; i++){
-        const idx = filterset ? filterset[i] : i;
-        const row = rows[idx];
-        const { [COUNT]: count, [DEPTH]: depth, [KEY]: key, [IS_LEAF]: isLeaf } = row;
-        if (filterset) {
-            const previousRow = visibleRows.at(-1);
-            if (missingAncestor(row, previousRow)) {
-                let currentRow = row;
-                const missingRows = [];
-                while(currentRow){
-                    currentRow = getParentRow(rows, currentRow);
-                    if (currentRow) missingRows.unshift(currentRow);
-                }
-                missingRows.forEach((row)=>{
-                    visibleRows.push(cloneRow(row, index++, true));
-                });
+    if (filterset) {
+        const included = new Set();
+        for (const idx of filterset){
+            let row = rows[idx];
+            while(row && !included.has(row[IDX])){
+                included.add(row[IDX]);
+                row = getParentRow(rows, row);
             }
-            visibleRows.push(cloneRow(row, index++, true));
+        }
+        let collapsedKey;
+        for(let i = 0, index = 0; i < rows.length; i++){
+            const row = rows[i];
+            const { [COUNT]: count, [KEY]: key } = row;
+            if (!included.has(row[IDX])) continue;
+            if (void 0 !== collapsedKey && key.startsWith(`${collapsedKey}|`)) continue;
+            const isCollapsed = filterCollapsedKeys?.has(key) ?? false;
+            collapsedKey = isCollapsed ? key : void 0;
             visibleRowIndex[index] = i;
-        } else {
-            const isExpanded = expandedKeys.has(key);
-            visibleRows.push(cloneRow(row, index, isExpanded));
-            visibleRowIndex[index++] = i;
-            const skipNonVisibleRows = !isLeaf && !isExpanded && count > 0;
-            if (skipNonVisibleRows) do i += 1;
-            while (i < rows.length - 1 && rows[i + 1][DEPTH] > depth)
+            visibleRows.push(cloneRow(row, index++, count > 0 && !isCollapsed));
         }
+    } else for(let i = 0, index = 0; i < rows.length; i++){
+        const row = rows[i];
+        const { [COUNT]: count, [DEPTH]: depth, [KEY]: key, [IS_LEAF]: isLeaf } = row;
+        const isExpanded = expandedKeys.has(key);
+        visibleRows.push(cloneRow(row, index, isExpanded));
+        visibleRowIndex[index++] = i;
+        const skipNonVisibleRows = !isLeaf && !isExpanded && count > 0;
+        if (skipNonVisibleRows) do i += 1;
+        while (i < rows.length - 1 && rows[i + 1][DEPTH] > depth)
     }
     return [
         visibleRows,

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

@@ -1,6 +1,6 @@
 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";
+import { type ColumnMap } from "@vuu-ui/vuu-utils";
 export type KeyList = number[];
 export type GroupMap = {
     [key: string]: GroupMap | KeyList;

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

@@ -1,6 +1,6 @@
 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";
+import type { ColumnMap } from "@vuu-ui/vuu-utils";
 export type ColIndexSortDef = [number, VuuSortType];
 type SortCompareResult = 0 | 1 | -1;
 export type RowSortComparator = (item1: DataSourceRowWithBigint, item2: DataSourceRowWithBigint) => SortCompareResult;

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

@@ -1,7 +1,18 @@
 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";
+import type { DataSourceRow, DataSourceConstructorProps, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, MenuRpcResponse, DataSourceFilter, TableSchema, DataSourceBase } from "@vuu-ui/vuu-data-types";
+import { BaseDataSource, type TreeSourceNode } from "@vuu-ui/vuu-utils";
+export interface TreeNodeFilterProps {
+    depth: number;
+    key: string;
+    label: string;
+    nodeData: unknown;
+}
+/**
+ * Tests a single tree node. Nodes that pass are displayed, along with all of
+ * their ancestors.
+ */
+export type TreeNodeFilterPredicate = (node: TreeNodeFilterProps) => boolean;
 export interface TreeDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
     data: TreeSourceNode[];
 }
@@ -24,6 +35,13 @@ export declare class TreeDataSource extends BaseDataSource implements DataSource
     set data(data: TreeSourceNode[]);
     get filter(): DataSourceFilter;
     set filter(filter: DataSourceFilter);
+    /**
+     * An alternative to a filter expression, filters on any attribute of a
+     * tree node, including nodeData. Pass undefined to clear the filter.
+     */
+    filterNodes(predicate?: TreeNodeFilterPredicate): void;
+    private computeVisibleRows;
+    private refreshVisibleRows;
     private applyFilter;
     /**
      * used to apply an initial selection. These may not necessarily be
@@ -36,6 +54,7 @@ export declare class TreeDataSource extends BaseDataSource implements DataSource
     private getRowKey;
     openTreeNode(keyOrIndex: string | number): void;
     closeTreeNode(keyOrIndex: string | number, cascade?: boolean): void;
+    get tableSchema(): TableSchema;
     get status(): DataSourceStatus;
     get selectedRowsCount(): number;
     get size(): number;

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

@@ -1,8 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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;
-}