@vuu-ui/vuu-data-local 4.0.1 → 4.1.1

package/package.json

@@ -1,23 +1,22 @@
 {
-  "version": "4.0.1",
+  "version": "4.1.1",
   "main": "./src/index.js",
   "author": "heswell",
   "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": "4.1.1",
+    "@vuu-ui/vuu-table-types": "4.1.1",
+    "@vuu-ui/vuu-filter-types": "4.1.1",
+    "@vuu-ui/vuu-protocol-types": "4.1.1"
   },
   "dependencies": {
-    "@vuu-ui/vuu-filter-parser": "4.0.1",
-    "@vuu-ui/vuu-utils": "4.0.1"
+    "@vuu-ui/vuu-filter-parser": "4.1.1",
+    "@vuu-ui/vuu-utils": "4.1.1"
   },
   "sideEffects": false,
   "files": [

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/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 type { DataSourceRow, DataSourceConstructorProps, DataSourceStatus, DataSourceSubscribeCallback, DataSourceSubscribeProps, MenuRpcResponse, DataSourceFilter, TableSchema, DataSourceBase } from "@vuu-ui/vuu-data-types";
 import { BaseDataSource, 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;