@vuu-ui/vuu-data-local 4.0.0-alpha.8 → 4.0.0-beta.1

package/package.json

@@ -1,8 +1,7 @@
 {
-  "version": "4.0.0-alpha.8",
+  "version": "4.0.0-beta.1",
   "main": "./src/index.js",
   "author": "heswell",
-  "type": "module",
   "license": "Apache-2.0",
   "scripts": {
     "build:dev": "node ../../scripts/run-build.mjs",
@@ -11,14 +10,14 @@
     "type-defs": "node ../../scripts/build-type-defs.mjs"
   },
   "devDependencies": {
-    "@vuu-ui/vuu-data-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-table-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-filter-types": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-protocol-types": "4.0.0-alpha.8"
+    "@vuu-ui/vuu-data-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-table-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-filter-types": "4.0.0-beta.1",
+    "@vuu-ui/vuu-protocol-types": "4.0.0-beta.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "4.0.0-alpha.8",
-    "@vuu-ui/vuu-utils": "4.0.0-alpha.8"
+    "@vuu-ui/vuu-filter-parser": "4.0.0-beta.1",
+    "@vuu-ui/vuu-utils": "4.0.0-beta.1"
   },
   "sideEffects": false,
   "files": [
@@ -29,10 +28,12 @@
   "exports": {
     ".": {
       "import": "./src/index.js",
+      "default": "./src/index.js",
       "types": "./types/index.d.ts"
     }
   },
   "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

@@ -1,5 +1,5 @@
 import { filterPredicate, parseFilter } from "@vuu-ui/vuu-filter-parser";
-import { EventEmitter, KeySet, NULL_RANGE, Range, buildColumnMap, combineFilters, filterAsQuery, getAddedItems, hasBaseFilter, hasFilter, hasGroupBy, hasSort, isConfigChanged, isGroupByChanged, logger, metadataKeys, rangeNewItems, toSchemaColumn, uuid, vanillaConfig, withConfigDefaults } from "@vuu-ui/vuu-utils";
+import { EventEmitter, KeySet, NULL_RANGE, Range, buildColumnMap, combineFilters, filterAsQuery, filterRequiresResolution, getAddedItems, getColumnsByName, getColumnsByNameForFilter, hasBaseFilter, hasFilter, hasGroupBy, hasSort, isConfigChanged, isGroupByChanged, logger, metadataKeys, rangeNewItems, toSchemaColumn, uuid, vanillaConfig, withConfigDefaults } from "@vuu-ui/vuu-utils";
 import { aggregateData } from "./aggregate-utils.js";
 import { buildDataToClientMap, toClientRow } from "./array-data-utils.js";
 import { collapseGroup, expandGroup, groupRows } from "./group-utils.js";
@@ -49,6 +49,7 @@ class ArrayDataSource extends EventEmitter {
     openTreeNodes = [];
     preserveScrollPositionAcrossConfigChange = false;
     #columnMap;
+    #filterColumnsByName;
     _config = vanillaConfig;
     #data;
     #freezeTimestamp = void 0;
@@ -68,6 +69,7 @@ class ArrayDataSource extends EventEmitter {
         super();
         if (!data || !columnDescriptors) throw Error("ArrayDataSource constructor called without data or without columnDescriptors");
         this.columnDescriptors = columnDescriptors;
+        this.#filterColumnsByName = getColumnsByName(columnDescriptors);
         this.dataMap = dataMap;
         this.key = keyColumn ? this.columnDescriptors.findIndex((col)=>col.name === keyColumn) : 0;
         this.rangeChangeRowset = rangeChangeRowset;
@@ -316,7 +318,8 @@ class ArrayDataSource extends EventEmitter {
         });
     }
     getFilterPredicate() {
-        const { filterSpec: { filterStruct } } = combineFilters(this._config);
+        const { filterSpec: { filter, filterStruct: rawFilterStruct } } = combineFilters(this._config);
+        const filterStruct = rawFilterStruct && filter && filterRequiresResolution(rawFilterStruct, getColumnsByNameForFilter(this.tableSchema, this.#filterColumnsByName)) ? parseFilter(filter) : rawFilterStruct;
         if (filterStruct) {
             if (this.dataMap) {
                 const { count: offset } = metadataKeys;
@@ -448,12 +451,12 @@ class ArrayDataSource extends EventEmitter {
     }
     indexOfRowWithKey = (key)=>this.#data.findIndex((row)=>row[KEY] === key);
     update = (row, columnName)=>{
-        const keyValue = String(row[this.key]);
+        const keyValue = row[this.key];
         const dataColIndex = this.dataMap?.[columnName];
         return this.updateDataItem(keyValue, columnName, row[dataColIndex]);
     };
     updateRow = (row, _columnName)=>{
-        const keyValue = String(row[this.key]);
+        const keyValue = row[this.key];
         const dataIndex = this.#data.findIndex((row)=>row[KEY] === keyValue);
         if (-1 !== dataIndex) {
             const dataSourceRow = toDataSourceRow(this.key)(row, dataIndex);
@@ -617,9 +620,15 @@ class ArrayDataSource extends EventEmitter {
             filterSpec: filter
         };
     }
-    setFilter(filter) {
+    setFilter(filter, options) {
+        this.#filterColumnsByName = {
+            ...getColumnsByName(this.columnDescriptors),
+            ...options?.columnsByName
+        };
         const dataSourceFilter = {
-            filter: filterAsQuery(filter),
+            filter: filterAsQuery(filter, {
+                columnsByName: getColumnsByNameForFilter(this.tableSchema, this.#filterColumnsByName)
+            }),
             filterStruct: filter
         };
         this.filter = dataSourceFilter;

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

@@ -1,39 +1,17 @@
 import { BaseDataSource, KeySet, NULL_RANGE, getParentRow, isSingleValueFilter, lastPathSegment, metadataKeys, missingAncestor, treeToDataSourceRows, uuid } from "@vuu-ui/vuu-utils";
 import { IconProvider } from "./IconProvider.js";
 import { parseFilter } from "@vuu-ui/vuu-filter-parser";
-const TREE_SCHEMA = {
-    columns: [
-        {
-            name: "nodeData",
-            serverDataType: "string"
-        },
-        {
-            name: "Level 1",
-            serverDataType: "string"
-        },
-        {
-            name: "Level 2",
-            serverDataType: "string"
-        },
-        {
-            name: "Level 3",
-            serverDataType: "string"
-        },
-        {
-            name: "Level 4",
-            serverDataType: "string"
-        },
-        {
-            name: "Level 5",
-            serverDataType: "string"
+const treeSchema = (columns)=>({
+        columns: columns.map(({ name })=>({
+                name,
+                serverDataType: "string"
+            })),
+        key: "",
+        table: {
+            module: "",
+            table: ""
         }
-    ],
-    key: "",
-    table: {
-        module: "",
-        table: ""
-    }
-};
+    });
 const { COUNT: COUNT, DEPTH: DEPTH, IDX: IDX, IS_EXPANDED: IS_EXPANDED, IS_LEAF: IS_LEAF, KEY: KEY, SELECTED: SELECTED } = metadataKeys;
 const toClientRow = (row, keys)=>{
     const [rowIndex] = row;
@@ -61,6 +39,8 @@ class TreeDataSource extends BaseDataSource {
         if (!data) throw Error("TreeDataSource constructor called without data");
         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 = {
@@ -92,7 +72,7 @@ class TreeDataSource extends BaseDataSource {
             groupBy: this._configWithVisualLink.groupBy,
             range: this.range,
             sort: this.sort,
-            tableSchema: TREE_SCHEMA
+            tableSchema: treeSchema(this.columnDescriptors)
         });
         this.clientCallback({
             clientViewportId: this.viewport,
@@ -163,6 +143,7 @@ class TreeDataSource extends BaseDataSource {
     applySelectedKeyValues(keys, revealSelected = false) {
         keys.forEach((key)=>{
             const rowIdx = this.indexOfRowWithKey(key);
+            if (-1 === rowIdx) return;
             const row = this.#data[rowIdx];
             row[SELECTED] = 1;
             if (revealSelected && 1 !== row[DEPTH]) {
@@ -305,6 +286,14 @@ class TreeDataSource extends BaseDataSource {
         return this.visibleRows[rowIdx];
     }
 }
+const getInitiallyExpandedKeys = (treeSourceNodes, keyBase = "$root", expandedKeys = new Set())=>{
+    for (const { childNodes, expanded, label } of treeSourceNodes){
+        const key = `${keyBase}|${label}`;
+        if (expanded) expandedKeys.add(key);
+        if (childNodes) getInitiallyExpandedKeys(childNodes, key, expandedKeys);
+    }
+    return expandedKeys;
+};
 function getVisibleRows(rows, expandedKeys, filterset) {
     const visibleRows = [];
     const visibleRowIndex = {};

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

@@ -1,4 +1,4 @@
-import type { DataSourceBase, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceRow, DataSourceRowWithBigint, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, TableSchema, WithBaseFilter, WithFullConfig } from "@vuu-ui/vuu-data-types";
+import type { DataSourceBase, DataSourceConstructorProps, DataSourceEvents, DataSourceFilter, DataSourceRow, DataSourceRowWithBigint, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, SetFilterOptions, 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";
@@ -93,7 +93,7 @@ export declare class ArrayDataSource extends EventEmitter<DataSourceEvents> impl
     set baseFilter(baseFilter: DataSourceFilter | undefined);
     get filter(): DataSourceFilter;
     set filter(filter: DataSourceFilter);
-    setFilter(filter: Filter): void;
+    setFilter(filter: Filter, options?: SetFilterOptions): void;
     clearFilter(): void;
     get groupBy(): VuuGroupBy;
     set groupBy(groupBy: VuuGroupBy);

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 { type ColumnMap } from "@vuu-ui/vuu-utils";
+import { 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 type { ColumnMap } from "@vuu-ui/vuu-utils";
+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;

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

@@ -1,7 +1,7 @@
 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, type TreeSourceNode } from "@vuu-ui/vuu-utils";
+import { BaseDataSource, TreeSourceNode } from "@vuu-ui/vuu-utils";
 export interface TreeDataSourceConstructorProps extends Omit<DataSourceConstructorProps, "bufferSize" | "table"> {
     data: TreeSourceNode[];
 }

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;
-}