@myrmidon/paged-data-browsers 0.0.1

package/esm2022/lib/services/paged-tree.store.mjs

@@ -0,0 +1,419 @@
+import { BehaviorSubject, forkJoin, of, switchMap, tap, } from 'rxjs';
+import { LRUCache } from './lru-cache';
+import { DEFAULT_PAGED_LIST_STORE_OPTIONS } from './paged-list.store';
+/**
+ * A store for the node browser component. This store is used to keep a
+ * list of nodes, and to load them from the API. It also keeps the root
+ * node. Every tree node in the list is extended with page number,
+ * page count and total items, plus expansion-related metadata.
+ * The store keeps a flat list of these tree nodes, allowing users to
+ * expand and collapse them.
+ * F is the type of the filter object, E is the type of the paged tree nodes.
+ */
+export class PagedTreeStore {
+    /**
+     * The size of nodes pages in this store. If you change it, the store
+     * is reset. The default value is 20.
+     */
+    get pageSize() {
+        return this._pageSize;
+    }
+    set pageSize(value) {
+        if (this._pageSize === value) {
+            return;
+        }
+        this._pageSize = value;
+        this.reset(this._radix?.label || this._radixLabel);
+    }
+    /**
+     * Create an instance of the store.
+     * @param _service The service used to load nodes.
+     * @param options The options to configure this store.
+     */
+    constructor(_service, options = DEFAULT_PAGED_LIST_STORE_OPTIONS) {
+        this._service = _service;
+        this._pageSize = options.pageSize;
+        this._cache = new LRUCache(options.cacheSize);
+        this._customCacheKeyBuilder = options.buildCacheKey;
+        this._radixLabel = '(root)';
+        this._roots = [];
+        this._nodes$ = new BehaviorSubject([]);
+        this.nodes$ = this._nodes$.asObservable();
+        this._tags$ = new BehaviorSubject([]);
+        this.tags$ = this._tags$.asObservable();
+        this._filter$ = new BehaviorSubject({});
+        this.filter$ = this._filter$.asObservable();
+        this._dirty = true;
+        this.updateTags();
+    }
+    updateTags() {
+        this._service.getTags().subscribe((tags) => {
+            this._tags$.next(tags);
+        });
+    }
+    /**
+     * Gets the global filter eventually overridden with values
+     * from the specified node's filter.
+     * @param node The optional node.
+     * @returns The filter.
+     */
+    getFilter(node) {
+        return node?.filter
+            ? {
+                ...this._filter$.value,
+                ...node.filter,
+            }
+            : this._filter$.value;
+    }
+    /**
+     * Gets all the nodes in the store.
+     * @returns The nodes.
+     */
+    getNodes() {
+        return this._nodes$.value;
+    }
+    /**
+     * Gets the list of nodes tags.
+     * @returns The tags.
+     */
+    getTags() {
+        return this._tags$.value;
+    }
+    /**
+     * Build the cache key for the given page number and filter.
+     * The default implementation just returns a stringified object
+     * containing the page number and the filter. You may override
+     * this method to provide a custom cache key.
+     * @param pageNumber The page number.
+     * @param filter The filter.
+     * @returns A string to be used as cache key.
+     */
+    buildCacheKey(pageNumber, filter) {
+        if (this._customCacheKeyBuilder) {
+            return this._customCacheKeyBuilder(pageNumber, filter);
+        }
+        return JSON.stringify({ pageNumber, ...filter });
+    }
+    getPageFromCacheOrServer(filter, pageNumber) {
+        const key = this.buildCacheKey(pageNumber, filter);
+        const pageInCache = this._cache.get(key);
+        if (pageInCache) {
+            return of(pageInCache);
+        }
+        else {
+            return this._service.getNodes(filter, pageNumber, this._pageSize).pipe(tap((page) => {
+                this._cache.put(key, page, 0);
+            }));
+        }
+    }
+    createPageNodes(page) {
+        return page.items.map((n) => {
+            return {
+                ...n,
+                hasChildren: n.hasChildren,
+                paging: {
+                    pageNumber: page.pageNumber,
+                    pageCount: page.pageCount,
+                    total: page.total,
+                },
+            };
+        });
+    }
+    /**
+     * Applies the filter for this store. Whenever the filter is set,
+     * the store is reset.
+     * @param filter The filter.
+     * @param radixLabel The label of the radix node, if this needs to be set.
+     * @returns true if tree was changed, false otherwise.
+     */
+    applyFilter(filter, radixLabel) {
+        if (this._filter$.value === filter) {
+            return Promise.resolve(false);
+        }
+        this._filter$.next(filter);
+        this._dirty = true;
+        return this.reset(this._radix?.label || radixLabel || this._radixLabel);
+    }
+    /**
+     * Reset the store, loading the root nodes and their children.
+     * @param label The label of the radix node.
+     * @returns true if tree was changed, false otherwise.
+     */
+    reset(label) {
+        if (!this._dirty) {
+            return Promise.resolve(false);
+        }
+        this._cache.clear();
+        const filter = this._filter$.value;
+        this._radix = {
+            id: 0,
+            y: 0,
+            x: 1,
+            label: label,
+            paging: {
+                pageNumber: 0,
+                pageCount: 0,
+                total: 0,
+            },
+        };
+        return new Promise((resolve, reject) => {
+            this._service
+                .getRootNodes(filter.tags)
+                .pipe(switchMap((nodes) => {
+                // no roots, clear and return empty set
+                if (!nodes || nodes.length === 0) {
+                    this._roots = [];
+                    return of([]);
+                }
+                else {
+                    // got roots, set them and get their children
+                    this._roots = nodes.map((node) => ({
+                        ...node,
+                        paging: {
+                            pageNumber: 1,
+                            pageCount: 1,
+                            total: 1,
+                        },
+                    }));
+                    // fetch children for each root node
+                    return forkJoin(this._roots.map((root) => this.getPageFromCacheOrServer({ ...filter, parentId: root.id }, 1)));
+                }
+            }))
+                .subscribe({
+                next: (pages) => {
+                    this._dirty = false;
+                    if (pages.some((page) => page.total)) {
+                        // radix
+                        this._radix.hasChildren = true;
+                        this._radix.expanded = true;
+                        this._radix.paging = {
+                            pageNumber: 1,
+                            pageCount: 1,
+                            total: pages.length,
+                        };
+                        // roots
+                        this._roots.forEach((root, i) => {
+                            root.hasChildren = !!pages[i].total;
+                            root.expanded = !!pages[i].total;
+                        });
+                        const nodes = this._roots.flatMap((root, i) => [
+                            root,
+                            ...this.createPageNodes(pages[i]),
+                        ]);
+                        this._nodes$.next([this._radix, ...nodes]);
+                        resolve(true);
+                    }
+                    else {
+                        this._roots.forEach((root) => {
+                            root.hasChildren = false;
+                            root.expanded = false;
+                        });
+                        this._nodes$.next([this._radix, ...this._roots]);
+                        resolve(true);
+                    }
+                },
+                error: (error) => {
+                    reject(error);
+                },
+            });
+        });
+    }
+    /**
+     * Set the node filter for the node with the specified ID.
+     * @param id The node ID.
+     * @param filter The filter to set.
+     * @returns Promise with true if filter was set, false otherwise.
+     */
+    setNodeFilter(id, filter) {
+        if (!id) {
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve, reject) => {
+            const node = this._nodes$.value.find((n) => n.id === id);
+            if (!node) {
+                reject(`Node ID ${id} not found in store`);
+            }
+            node.filter = filter || undefined;
+            return this.changePage(id, 1);
+        });
+    }
+    /**
+     * Expand the node with the specified ID. If the node is not expandable,
+     * or it is already expanded, this method does nothing.
+     * @param node The ID of the node to expand.
+     * @returns Promise with true if the node was expanded, false otherwise.
+     */
+    expand(id) {
+        if (!id) {
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve, reject) => {
+            const node = this._nodes$.value.find((n) => n.id === id);
+            if (!node || node.hasChildren === false || node.expanded) {
+                resolve(false);
+            }
+            this.getPageFromCacheOrServer({ ...this.getFilter(node), parentId: id }, 1).subscribe((page) => {
+                // no children, set hasChildren to false
+                if (!page.total) {
+                    node.hasChildren = false;
+                    resolve(false);
+                }
+                else {
+                    this._dirty = true;
+                    // insert page nodes after the current node
+                    const nodes = this._nodes$.value;
+                    const index = nodes.indexOf(node);
+                    if (index === -1) {
+                        reject(`Node ID ${id} not found in store`);
+                    }
+                    else {
+                        const pageNodes = this.createPageNodes(page);
+                        nodes.splice(index + 1, 0, ...pageNodes);
+                        this._nodes$.next(nodes);
+                        node.hasChildren = true;
+                        node.expanded = true;
+                        resolve(true);
+                    }
+                }
+            });
+        });
+    }
+    expandAll(id) {
+        if (!id) {
+            return Promise.resolve(false);
+        }
+        // get the parent node to start from
+        const nodes = this._nodes$.value;
+        const nodeIndex = nodes.findIndex((n) => n.id === id);
+        if (nodeIndex === -1) {
+            return Promise.resolve(false);
+        }
+        // collect all the descendant nodes IDs
+        let i = nodeIndex + 1;
+        while (i < nodes.length && nodes[i].y > nodes[nodeIndex].y) {
+            i++;
+        }
+        const nodesToExpand = nodes.slice(nodeIndex, i).map((n) => n.id);
+        // expand all the descendant nodes
+        return new Promise((resolve, reject) => {
+            nodesToExpand.forEach((id) => {
+                this.expand(id);
+                this.expandAll(id);
+            });
+            resolve(true);
+        });
+    }
+    getChildren(id) {
+        const node = this._nodes$.value.find((n) => n.id === id);
+        if (!node || node.hasChildren === false) {
+            return [];
+        }
+        const nodes = this._nodes$.value;
+        const index = nodes.indexOf(node);
+        if (index === -1) {
+            return [];
+        }
+        const children = [];
+        let i = index + 1;
+        while (i < nodes.length && nodes[i].y > node.y) {
+            children.push(nodes[i]);
+            i++;
+        }
+        return children;
+    }
+    removeDescendants(nodes, nodeIndex) {
+        let i = nodeIndex + 1;
+        while (i < nodes.length && nodes[i].y > nodes[nodeIndex].y) {
+            i++;
+        }
+        nodes.splice(nodeIndex + 1, i - nodeIndex - 1);
+    }
+    /**
+     * Collapse the node with the specified ID. If the node is not expandable,
+     * or it is already collapsed, this method does nothing.
+     * @param node The node to collapse.
+     * @returns Promise with true if the node was collapsed, false otherwise.
+     */
+    collapse(id) {
+        if (!id) {
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve, reject) => {
+            const node = this._nodes$.value.find((n) => n.id === id);
+            if (!node || node.hasChildren === false || !node.expanded) {
+                resolve(false);
+            }
+            // remove all the descendant nodes after the current node
+            const nodes = this._nodes$.value;
+            const nodeIndex = nodes.indexOf(node);
+            if (nodeIndex === -1) {
+                reject(`Node ID ${id} not found in store`);
+            }
+            else {
+                this._dirty = true;
+                this.removeDescendants(nodes, nodeIndex);
+                this._nodes$.next(nodes);
+                node.expanded = false;
+                resolve(true);
+            }
+        });
+    }
+    /**
+     * Change the page including the node with the specified ID.
+     * @param node The parent node whose children are inside the page you want to change.
+     * @param pageNumber The new page number.
+     * @returns Promise with true if the page was changed, false otherwise.
+     */
+    changePage(parentId, pageNumber) {
+        return new Promise((resolve, reject) => {
+            const parentNode = this._nodes$.value.find((n) => n.id === parentId);
+            if (!parentNode) {
+                resolve(false);
+            }
+            this.getPageFromCacheOrServer({ ...this.getFilter(parentNode), parentId }, pageNumber).subscribe((page) => {
+                // if page is empty do nothing
+                if (!page.total) {
+                    resolve(false);
+                }
+                else {
+                    this._dirty = true;
+                    // remove all the nodes in the same page of node
+                    // with all their descendants
+                    const nodes = this._nodes$.value;
+                    const nodeIndex = nodes.indexOf(parentNode) + 1;
+                    const pageNodes = this.createPageNodes(page);
+                    // find the first node of the node's page
+                    let start = nodeIndex;
+                    const oldPageNr = nodes[start].paging.pageNumber;
+                    while (start > 0 &&
+                        nodes[start - 1].parentId === parentId &&
+                        nodes[start - 1].paging.pageNumber === oldPageNr) {
+                        start--;
+                    }
+                    // find the last node of the node's page,
+                    // including all their descendants
+                    let end = nodeIndex + 1;
+                    while (end < nodes.length &&
+                        nodes[end].parentId === parentId &&
+                        nodes[end].paging.pageNumber === oldPageNr) {
+                        end++;
+                    }
+                    // replace all these nodes with the new ones
+                    nodes.splice(start, end - start);
+                    nodes.splice(start, 0, ...pageNodes);
+                    // update the parent node paging info
+                    parentNode.paging.pageNumber = page.pageNumber;
+                    this._nodes$.next(nodes);
+                    resolve(true);
+                }
+            });
+        });
+    }
+    /**
+     * Collapse all the nodes in the store.
+     */
+    collapseAll() {
+        this._nodes$.next([this._radix, ...this._roots]);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paged-tree.store.js","sourceRoot":"","sources":["../../../../../../projects/myrmidon/paged-data-browsers/src/lib/services/paged-tree.store.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,QAAQ,EACR,EAAE,EACF,SAAS,EACT,GAAG,GACJ,MAAM,MAAM,CAAC;AAId,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AACvC,OAAO,EAAE,gCAAgC,EAAE,MAAM,oBAAoB,CAAC;AAgGtE;;;;;;;;GAQG;AACH,MAAM,OAAO,cAAc;IAoCzB;;;OAGG;IACH,IAAW,QAAQ;QACjB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IACD,IAAW,QAAQ,CAAC,KAAa;QAC/B,IAAI,IAAI,CAAC,SAAS,KAAK,KAAK,EAAE;YAC5B,OAAO;SACR;QACD,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;IACrD,CAAC;IAED;;;;OAIG;IACH,YACU,QAAkC,EAC1C,UAAiC,gCAAgC;QADzD,aAAQ,GAAR,QAAQ,CAA0B;QAG1C,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,QAAQ,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,IAAI,QAAQ,CAAqB,OAAO,CAAC,SAAS,CAAC,CAAC;QAClE,IAAI,CAAC,sBAAsB,GAAG,OAAO,CAAC,aAAa,CAAC;QACpD,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;QAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAW,EAAE,CAAC,CAAC;QAChD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC;QACxC,IAAI,CAAC,QAAQ,GAAG,IAAI,eAAe,CAAI,EAAO,CAAC,CAAC;QAChD,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,EAAE,CAAC;QAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,UAAU,EAAE,CAAC;IACpB,CAAC;IAEO,UAAU;QAChB,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YACzC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACzB,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACK,SAAS,CAAC,IAAuB;QACvC,OAAO,IAAI,EAAE,MAAM;YACjB,CAAC,CAAC;gBACE,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK;gBACtB,GAAG,IAAI,CAAC,MAAM;aACf;YACH,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;IAC1B,CAAC;IAED;;;OAGG;IACI,QAAQ;QACb,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC;IAC3B,CAAC;IAED;;;;;;;;OAQG;IACK,aAAa,CAAC,UAAkB,EAAE,MAAS;QACjD,IAAI,IAAI,CAAC,sBAAsB,EAAE;YAC/B,OAAO,IAAI,CAAC,sBAAsB,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;SACxD;QACD,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,UAAU,EAAE,GAAG,MAAM,EAAE,CAAC,CAAC;IACnD,CAAC;IAEO,wBAAwB,CAC9B,MAAS,EACT,UAAkB;QAElB,MAAM,GAAG,GAAG,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QACnD,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAEzC,IAAI,WAAW,EAAE;YACf,OAAO,EAAE,CAAC,WAAW,CAAC,CAAC;SACxB;aAAM;YACL,OAAO,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,IAAI,CACpE,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;gBACX,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;YAChC,CAAC,CAAC,CACH,CAAC;SACH;IACH,CAAC;IAEO,eAAe,CAAC,IAAwB;QAC9C,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE;YAC1B,OAAO;gBACL,GAAG,CAAC;gBACJ,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,MAAM,EAAE;oBACN,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,KAAK,EAAE,IAAI,CAAC,KAAK;iBAClB;aACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;OAMG;IACI,WAAW,CAAC,MAAS,EAAE,UAAmB;QAC/C,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,KAAK,MAAM,EAAE;YAClC,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,UAAU,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC;IAC1E,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,KAAa;QACxB,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;YAChB,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QACpB,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;QACnC,IAAI,CAAC,MAAM,GAAG;YACZ,EAAE,EAAE,CAAC;YACL,CAAC,EAAE,CAAC;YACJ,CAAC,EAAE,CAAC;YACJ,KAAK,EAAE,KAAK;YACZ,MAAM,EAAE;gBACN,UAAU,EAAE,CAAC;gBACb,SAAS,EAAE,CAAC;gBACZ,KAAK,EAAE,CAAC;aACT;SACG,CAAC;QAEP,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,IAAI,CAAC,QAAQ;iBACV,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC;iBACzB,IAAI,CACH,SAAS,CAAC,CAAC,KAAK,EAAE,EAAE;gBAClB,uCAAuC;gBACvC,IAAI,CAAC,KAAK,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;oBAChC,IAAI,CAAC,MAAM,GAAG,EAAE,CAAC;oBACjB,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;iBACf;qBAAM;oBACL,6CAA6C;oBAC7C,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,GAAG,CACrB,CAAC,IAAI,EAAE,EAAE,CACP,CAAC;wBACC,GAAG,IAAI;wBACP,MAAM,EAAE;4BACN,UAAU,EAAE,CAAC;4BACb,SAAS,EAAE,CAAC;4BACZ,KAAK,EAAE,CAAC;yBACT;qBACI,CAAA,CACV,CAAC;oBACF,oCAAoC;oBACpC,OAAO,QAAQ,CACb,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACvB,IAAI,CAAC,wBAAwB,CAC3B,EAAE,GAAG,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,EAAE,EAAE,EAChC,CAAC,CACF,CACF,CACF,CAAC;iBACH;YACH,CAAC,CAAC,CACH;iBACA,SAAS,CAAC;gBACT,IAAI,EAAE,CAAC,KAAK,EAAE,EAAE;oBACd,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;oBACpB,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE;wBACpC,QAAQ;wBACR,IAAI,CAAC,MAAO,CAAC,WAAW,GAAG,IAAI,CAAC;wBAChC,IAAI,CAAC,MAAO,CAAC,QAAQ,GAAG,IAAI,CAAC;wBAC7B,IAAI,CAAC,MAAO,CAAC,MAAM,GAAG;4BACpB,UAAU,EAAE,CAAC;4BACb,SAAS,EAAE,CAAC;4BACZ,KAAK,EAAE,KAAK,CAAC,MAAM;yBACpB,CAAC;wBACF,QAAQ;wBACR,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE;4BAC9B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;4BACpC,IAAI,CAAC,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;wBACnC,CAAC,CAAC,CAAC;wBACH,MAAM,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC;4BAC7C,IAAI;4BACJ,GAAG,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;yBAClC,CAAC,CAAC;wBACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAO,EAAE,GAAI,KAAa,CAAC,CAAC,CAAC;wBACrD,OAAO,CAAC,IAAI,CAAC,CAAC;qBACf;yBAAM;wBACL,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;4BAC3B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC;4BACzB,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;wBACxB,CAAC,CAAC,CAAC;wBACH,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAO,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;wBAClD,OAAO,CAAC,IAAI,CAAC,CAAC;qBACf;gBACH,CAAC;gBACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE;oBACf,MAAM,CAAC,KAAK,CAAC,CAAC;gBAChB,CAAC;aACF,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,aAAa,CAAC,EAAU,EAAE,MAAiB;QAChD,IAAI,CAAC,EAAE,EAAE;YACP,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,EAAE;gBACT,MAAM,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;aAC5C;YACD,IAAK,CAAC,MAAM,GAAG,MAAM,IAAI,SAAS,CAAC;YACnC,OAAO,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAChC,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,EAAU;QACtB,IAAI,CAAC,EAAE,EAAE;YACP,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE;gBACxD,OAAO,CAAC,KAAK,CAAC,CAAC;aAChB;YAED,IAAI,CAAC,wBAAwB,CAC3B,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,EACzC,CAAC,CACF,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;gBACnB,wCAAwC;gBACxC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;oBACf,IAAK,CAAC,WAAW,GAAG,KAAK,CAAC;oBAC1B,OAAO,CAAC,KAAK,CAAC,CAAC;iBAChB;qBAAM;oBACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;oBACnB,2CAA2C;oBAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBACjC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAK,CAAC,CAAC;oBACnC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;wBAChB,MAAM,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;qBAC5C;yBAAM;wBACL,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;wBAC7C,KAAK,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,GAAI,SAAiB,CAAC,CAAC;wBAClD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;wBACzB,IAAK,CAAC,WAAW,GAAG,IAAI,CAAC;wBACzB,IAAK,CAAC,QAAQ,GAAG,IAAI,CAAC;wBACtB,OAAO,CAAC,IAAI,CAAC,CAAC;qBACf;iBACF;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,SAAS,CAAC,EAAU;QACzB,IAAI,CAAC,EAAE,EAAE;YACP,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,oCAAoC;QACpC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACjC,MAAM,SAAS,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACtD,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE;YACpB,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QAED,uCAAuC;QACvC,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;QACtB,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;YAC1D,CAAC,EAAE,CAAC;SACL;QACD,MAAM,aAAa,GAAG,KAAK,CAAC,KAAK,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAEjE,kCAAkC;QAClC,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,aAAa,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE;gBAC3B,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;gBAChB,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC;YACrB,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,IAAI,CAAC,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;IAEM,WAAW,CAAC,EAAU;QAC3B,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;QACzD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,KAAK,EAAE;YACvC,OAAO,EAAE,CAAC;SACX;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;QACjC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;YAChB,OAAO,EAAE,CAAC;SACX;QACD,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,GAAG,KAAK,GAAG,CAAC,CAAC;QAClB,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,EAAE;YAC9C,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;YACxB,CAAC,EAAE,CAAC;SACL;QACD,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEO,iBAAiB,CACvB,KAAyB,EACzB,SAAiB;QAEjB,IAAI,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC;QACtB,OAAO,CAAC,GAAG,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE;YAC1D,CAAC,EAAE,CAAC;SACL;QACD,KAAK,CAAC,MAAM,CAAC,SAAS,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC;IACjD,CAAC;IAED;;;;;OAKG;IACI,QAAQ,CAAC,EAAU;QACxB,IAAI,CAAC,EAAE,EAAE;YACP,OAAO,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;SAC/B;QACD,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;YACzD,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,WAAW,KAAK,KAAK,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;gBACzD,OAAO,CAAC,KAAK,CAAC,CAAC;aAChB;YAED,yDAAyD;YACzD,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;YACjC,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,IAAK,CAAC,CAAC;YACvC,IAAI,SAAS,KAAK,CAAC,CAAC,EAAE;gBACpB,MAAM,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;aAC5C;iBAAM;gBACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;gBACnB,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;gBACzC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;gBACzB,IAAK,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACvB,OAAO,CAAC,IAAI,CAAC,CAAC;aACf;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,UAAU,CAAC,QAAgB,EAAE,UAAkB;QACpD,OAAO,IAAI,OAAO,CAAU,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC9C,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,QAAQ,CAAC,CAAC;YACrE,IAAI,CAAC,UAAU,EAAE;gBACf,OAAO,CAAC,KAAK,CAAC,CAAC;aAChB;YACD,IAAI,CAAC,wBAAwB,CAC3B,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,QAAQ,EAAE,EAC3C,UAAU,CACX,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;gBACnB,8BAA8B;gBAC9B,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE;oBACf,OAAO,CAAC,KAAK,CAAC,CAAC;iBAChB;qBAAM;oBACL,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;oBACnB,gDAAgD;oBAChD,6BAA6B;oBAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBACjC,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,UAAW,CAAC,GAAG,CAAC,CAAC;oBACjD,MAAM,SAAS,GAAG,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;oBAC7C,yCAAyC;oBACzC,IAAI,KAAK,GAAG,SAAS,CAAC;oBACtB,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC;oBACjD,OACE,KAAK,GAAG,CAAC;wBACT,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ;wBACtC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,EAChD;wBACA,KAAK,EAAE,CAAC;qBACT;oBACD,yCAAyC;oBACzC,kCAAkC;oBAClC,IAAI,GAAG,GAAG,SAAS,GAAG,CAAC,CAAC;oBACxB,OACE,GAAG,GAAG,KAAK,CAAC,MAAM;wBAClB,KAAK,CAAC,GAAG,CAAC,CAAC,QAAQ,KAAK,QAAQ;wBAChC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,KAAK,SAAS,EAC1C;wBACA,GAAG,EAAE,CAAC;qBACP;oBACD,4CAA4C;oBAC5C,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,CAAC,CAAC;oBACjC,KAAK,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,EAAE,GAAI,SAAiB,CAAC,CAAC;oBAC9C,qCAAqC;oBACrC,UAAW,CAAC,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,CAAC;oBAChD,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;oBACzB,OAAO,CAAC,IAAI,CAAC,CAAC;iBACf;YACH,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;OAEG;IACI,WAAW;QAChB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,MAAO,EAAE,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IACpD,CAAC;CACF","sourcesContent":["import {\r\n  BehaviorSubject,\r\n  Observable,\r\n  forkJoin,\r\n  of,\r\n  switchMap,\r\n  tap,\r\n} from 'rxjs';\r\n\r\nimport { DataPage } from '@myrmidon/ng-tools';\r\n\r\nimport { LRUCache } from './lru-cache';\r\nimport { DEFAULT_PAGED_LIST_STORE_OPTIONS } from './paged-list.store';\r\n\r\n/**\r\n * A tree node. Your data service should return a list of these nodes\r\n * or of any type extending this interface.\r\n */\r\nexport interface TreeNode {\r\n  id: number;\r\n  parentId?: number;\r\n  y: number;\r\n  x: number;\r\n  label: string;\r\n  tag?: string;\r\n  hasChildren?: boolean;\r\n}\r\n\r\n/**\r\n * A filter for tree nodes.\r\n */\r\nexport interface TreeNodeFilter {\r\n  tags?: string[];\r\n  parentId?: number;\r\n}\r\n\r\n/**\r\n * Paging information for a paged tree node.\r\n */\r\nexport interface PagingInfo {\r\n  pageNumber: number;\r\n  pageCount: number;\r\n  total: number;\r\n}\r\n\r\n/**\r\n * A tree node with paging information, used in NodeBrowserStore.\r\n */\r\nexport interface PagedTreeNode<F extends TreeNodeFilter> extends TreeNode {\r\n  paging: PagingInfo;\r\n  expanded?: boolean;\r\n  filter?: F;\r\n}\r\n\r\n/**\r\n * The interface to be implemented by the service used by NodeBrowserStore\r\n * to load nodes.\r\n */\r\nexport interface PagedTreeStoreService<F extends TreeNodeFilter> {\r\n  /**\r\n   * Get all the root nodes, or just the ones having one of the specified\r\n   * tags.\r\n   * @param tags The optional tags to filter the root nodes.\r\n   */\r\n  getRootNodes(tags?: string[]): Observable<TreeNode[]>;\r\n\r\n  /**\r\n   * Get the specified page of nodes.\r\n   * @param filter The filter.\r\n   * @param pageNumber The page number.\r\n   * @param pageSize The page size.\r\n   */\r\n  getNodes(\r\n    filter: F,\r\n    pageNumber: number,\r\n    pageSize: number\r\n  ): Observable<DataPage<TreeNode>>;\r\n\r\n  /**\r\n   * Get the list of unique node tags. Each tag corresponds to a tree,\r\n   * as nodes are virtually grouped by their tag.\r\n   */\r\n  getTags(): Observable<string[]>;\r\n}\r\n\r\n/**\r\n * Options for the NodeBrowserStore.\r\n */\r\nexport interface PagedTreeStoreOptions {\r\n  /**\r\n   * The size of pages in the store.\r\n   */\r\n  pageSize: number;\r\n  /**\r\n   * The size of the cache for pages in the store.\r\n   */\r\n  cacheSize: number;\r\n\r\n  /**\r\n   * A custom function for building the cache key for the given page number\r\n   * and filter.\r\n   * @param pageNumber The page number.\r\n   * @param filter The filter.\r\n   * @returns A string to be used as cache key.\r\n   */\r\n  buildCacheKey?: (pageNumber: number, filter: any) => string;\r\n}\r\n\r\n/**\r\n * A store for the node browser component. This store is used to keep a\r\n * list of nodes, and to load them from the API. It also keeps the root\r\n * node. Every tree node in the list is extended with page number,\r\n * page count and total items, plus expansion-related metadata.\r\n * The store keeps a flat list of these tree nodes, allowing users to\r\n * expand and collapse them.\r\n * F is the type of the filter object, E is the type of the paged tree nodes.\r\n */\r\nexport class PagedTreeStore<\r\n  E extends PagedTreeNode<F>,\r\n  F extends TreeNodeFilter\r\n> {\r\n  private _radix?: E;\r\n  private _radixLabel: string;\r\n  private _roots: E[];\r\n  private _nodes$: BehaviorSubject<E[]>;\r\n  private _tags$: BehaviorSubject<string[]>;\r\n  private _filter$: BehaviorSubject<F>;\r\n  private readonly _customCacheKeyBuilder?: (\r\n    pageNumber: number,\r\n    filter: any\r\n  ) => string;\r\n  private readonly _cache: LRUCache<DataPage<TreeNode>>;\r\n\r\n  private _pageSize: number;\r\n  // dirty state: this is reset when the store is reset, and set to true\r\n  // when the store is changed\r\n  private _dirty?: boolean;\r\n\r\n  /**\r\n   * The flat list of paged nodes in this store.\r\n   */\r\n  public nodes$: Observable<Readonly<E[]>>;\r\n\r\n  /**\r\n   * The list of tree tags in this store.\r\n   */\r\n  public tags$: Observable<Readonly<string[]>>;\r\n\r\n  /**\r\n   * The global nodes filter.\r\n   */\r\n  public filter$: Observable<Readonly<F>>;\r\n\r\n  /**\r\n   * The size of nodes pages in this store. If you change it, the store\r\n   * is reset. The default value is 20.\r\n   */\r\n  public get pageSize(): number {\r\n    return this._pageSize;\r\n  }\r\n  public set pageSize(value: number) {\r\n    if (this._pageSize === value) {\r\n      return;\r\n    }\r\n    this._pageSize = value;\r\n    this.reset(this._radix?.label || this._radixLabel);\r\n  }\r\n\r\n  /**\r\n   * Create an instance of the store.\r\n   * @param _service The service used to load nodes.\r\n   * @param options The options to configure this store.\r\n   */\r\n  constructor(\r\n    private _service: PagedTreeStoreService<F>,\r\n    options: PagedTreeStoreOptions = DEFAULT_PAGED_LIST_STORE_OPTIONS\r\n  ) {\r\n    this._pageSize = options.pageSize;\r\n    this._cache = new LRUCache<DataPage<TreeNode>>(options.cacheSize);\r\n    this._customCacheKeyBuilder = options.buildCacheKey;\r\n    this._radixLabel = '(root)';\r\n    this._roots = [];\r\n    this._nodes$ = new BehaviorSubject<E[]>([]);\r\n    this.nodes$ = this._nodes$.asObservable();\r\n    this._tags$ = new BehaviorSubject<string[]>([]);\r\n    this.tags$ = this._tags$.asObservable();\r\n    this._filter$ = new BehaviorSubject<F>({} as F);\r\n    this.filter$ = this._filter$.asObservable();\r\n    this._dirty = true;\r\n    this.updateTags();\r\n  }\r\n\r\n  private updateTags(): void {\r\n    this._service.getTags().subscribe((tags) => {\r\n      this._tags$.next(tags);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Gets the global filter eventually overridden with values\r\n   * from the specified node's filter.\r\n   * @param node The optional node.\r\n   * @returns The filter.\r\n   */\r\n  private getFilter(node?: PagedTreeNode<F>): F {\r\n    return node?.filter\r\n      ? {\r\n          ...this._filter$.value,\r\n          ...node.filter,\r\n        }\r\n      : this._filter$.value;\r\n  }\r\n\r\n  /**\r\n   * Gets all the nodes in the store.\r\n   * @returns The nodes.\r\n   */\r\n  public getNodes(): Readonly<PagedTreeNode<F>[]> {\r\n    return this._nodes$.value;\r\n  }\r\n\r\n  /**\r\n   * Gets the list of nodes tags.\r\n   * @returns The tags.\r\n   */\r\n  public getTags(): Readonly<string[]> {\r\n    return this._tags$.value;\r\n  }\r\n\r\n  /**\r\n   * Build the cache key for the given page number and filter.\r\n   * The default implementation just returns a stringified object\r\n   * containing the page number and the filter. You may override\r\n   * this method to provide a custom cache key.\r\n   * @param pageNumber The page number.\r\n   * @param filter The filter.\r\n   * @returns A string to be used as cache key.\r\n   */\r\n  private buildCacheKey(pageNumber: number, filter: F): string {\r\n    if (this._customCacheKeyBuilder) {\r\n      return this._customCacheKeyBuilder(pageNumber, filter);\r\n    }\r\n    return JSON.stringify({ pageNumber, ...filter });\r\n  }\r\n\r\n  private getPageFromCacheOrServer(\r\n    filter: F,\r\n    pageNumber: number\r\n  ): Observable<DataPage<TreeNode>> {\r\n    const key = this.buildCacheKey(pageNumber, filter);\r\n    const pageInCache = this._cache.get(key);\r\n\r\n    if (pageInCache) {\r\n      return of(pageInCache);\r\n    } else {\r\n      return this._service.getNodes(filter, pageNumber, this._pageSize).pipe(\r\n        tap((page) => {\r\n          this._cache.put(key, page, 0);\r\n        })\r\n      );\r\n    }\r\n  }\r\n\r\n  private createPageNodes(page: DataPage<TreeNode>): PagedTreeNode<F>[] {\r\n    return page.items.map((n) => {\r\n      return {\r\n        ...n,\r\n        hasChildren: n.hasChildren,\r\n        paging: {\r\n          pageNumber: page.pageNumber,\r\n          pageCount: page.pageCount,\r\n          total: page.total,\r\n        },\r\n      };\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Applies the filter for this store. Whenever the filter is set,\r\n   * the store is reset.\r\n   * @param filter The filter.\r\n   * @param radixLabel The label of the radix node, if this needs to be set.\r\n   * @returns true if tree was changed, false otherwise.\r\n   */\r\n  public applyFilter(filter: F, radixLabel?: string): Promise<boolean> {\r\n    if (this._filter$.value === filter) {\r\n      return Promise.resolve(false);\r\n    }\r\n    this._filter$.next(filter);\r\n    this._dirty = true;\r\n    return this.reset(this._radix?.label || radixLabel || this._radixLabel);\r\n  }\r\n\r\n  /**\r\n   * Reset the store, loading the root nodes and their children.\r\n   * @param label The label of the radix node.\r\n   * @returns true if tree was changed, false otherwise.\r\n   */\r\n  public reset(label: string): Promise<boolean> {\r\n    if (!this._dirty) {\r\n      return Promise.resolve(false);\r\n    }\r\n    this._cache.clear();\r\n    const filter = this._filter$.value;\r\n    this._radix = {\r\n      id: 0,\r\n      y: 0,\r\n      x: 1,\r\n      label: label,\r\n      paging: {\r\n        pageNumber: 0,\r\n        pageCount: 0,\r\n        total: 0,\r\n      },\r\n    } as E;\r\n\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      this._service\r\n        .getRootNodes(filter.tags)\r\n        .pipe(\r\n          switchMap((nodes) => {\r\n            // no roots, clear and return empty set\r\n            if (!nodes || nodes.length === 0) {\r\n              this._roots = [];\r\n              return of([]);\r\n            } else {\r\n              // got roots, set them and get their children\r\n              this._roots = nodes.map(\r\n                (node) =>\r\n                  ({\r\n                    ...node,\r\n                    paging: {\r\n                      pageNumber: 1,\r\n                      pageCount: 1,\r\n                      total: 1,\r\n                    },\r\n                  } as E)\r\n              );\r\n              // fetch children for each root node\r\n              return forkJoin(\r\n                this._roots.map((root) =>\r\n                  this.getPageFromCacheOrServer(\r\n                    { ...filter, parentId: root.id },\r\n                    1\r\n                  )\r\n                )\r\n              );\r\n            }\r\n          })\r\n        )\r\n        .subscribe({\r\n          next: (pages) => {\r\n            this._dirty = false;\r\n            if (pages.some((page) => page.total)) {\r\n              // radix\r\n              this._radix!.hasChildren = true;\r\n              this._radix!.expanded = true;\r\n              this._radix!.paging = {\r\n                pageNumber: 1,\r\n                pageCount: 1,\r\n                total: pages.length,\r\n              };\r\n              // roots\r\n              this._roots.forEach((root, i) => {\r\n                root.hasChildren = !!pages[i].total;\r\n                root.expanded = !!pages[i].total;\r\n              });\r\n              const nodes = this._roots.flatMap((root, i) => [\r\n                root,\r\n                ...this.createPageNodes(pages[i]),\r\n              ]);\r\n              this._nodes$.next([this._radix!, ...(nodes as E[])]);\r\n              resolve(true);\r\n            } else {\r\n              this._roots.forEach((root) => {\r\n                root.hasChildren = false;\r\n                root.expanded = false;\r\n              });\r\n              this._nodes$.next([this._radix!, ...this._roots]);\r\n              resolve(true);\r\n            }\r\n          },\r\n          error: (error) => {\r\n            reject(error);\r\n          },\r\n        });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Set the node filter for the node with the specified ID.\r\n   * @param id The node ID.\r\n   * @param filter The filter to set.\r\n   * @returns Promise with true if filter was set, false otherwise.\r\n   */\r\n  public setNodeFilter(id: number, filter?: F | null): Promise<boolean> {\r\n    if (!id) {\r\n      return Promise.resolve(false);\r\n    }\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      const node = this._nodes$.value.find((n) => n.id === id);\r\n      if (!node) {\r\n        reject(`Node ID ${id} not found in store`);\r\n      }\r\n      node!.filter = filter || undefined;\r\n      return this.changePage(id, 1);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Expand the node with the specified ID. If the node is not expandable,\r\n   * or it is already expanded, this method does nothing.\r\n   * @param node The ID of the node to expand.\r\n   * @returns Promise with true if the node was expanded, false otherwise.\r\n   */\r\n  public expand(id: number): Promise<boolean> {\r\n    if (!id) {\r\n      return Promise.resolve(false);\r\n    }\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      const node = this._nodes$.value.find((n) => n.id === id);\r\n      if (!node || node.hasChildren === false || node.expanded) {\r\n        resolve(false);\r\n      }\r\n\r\n      this.getPageFromCacheOrServer(\r\n        { ...this.getFilter(node), parentId: id },\r\n        1\r\n      ).subscribe((page) => {\r\n        // no children, set hasChildren to false\r\n        if (!page.total) {\r\n          node!.hasChildren = false;\r\n          resolve(false);\r\n        } else {\r\n          this._dirty = true;\r\n          // insert page nodes after the current node\r\n          const nodes = this._nodes$.value;\r\n          const index = nodes.indexOf(node!);\r\n          if (index === -1) {\r\n            reject(`Node ID ${id} not found in store`);\r\n          } else {\r\n            const pageNodes = this.createPageNodes(page);\r\n            nodes.splice(index + 1, 0, ...(pageNodes as E[]));\r\n            this._nodes$.next(nodes);\r\n            node!.hasChildren = true;\r\n            node!.expanded = true;\r\n            resolve(true);\r\n          }\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  public expandAll(id: number): Promise<boolean> {\r\n    if (!id) {\r\n      return Promise.resolve(false);\r\n    }\r\n    // get the parent node to start from\r\n    const nodes = this._nodes$.value;\r\n    const nodeIndex = nodes.findIndex((n) => n.id === id);\r\n    if (nodeIndex === -1) {\r\n      return Promise.resolve(false);\r\n    }\r\n\r\n    // collect all the descendant nodes IDs\r\n    let i = nodeIndex + 1;\r\n    while (i < nodes.length && nodes[i].y > nodes[nodeIndex].y) {\r\n      i++;\r\n    }\r\n    const nodesToExpand = nodes.slice(nodeIndex, i).map((n) => n.id);\r\n\r\n    // expand all the descendant nodes\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      nodesToExpand.forEach((id) => {\r\n        this.expand(id);\r\n        this.expandAll(id);\r\n      });\r\n      resolve(true);\r\n    });\r\n  }\r\n\r\n  public getChildren(id: number): E[] {\r\n    const node = this._nodes$.value.find((n) => n.id === id);\r\n    if (!node || node.hasChildren === false) {\r\n      return [];\r\n    }\r\n    const nodes = this._nodes$.value;\r\n    const index = nodes.indexOf(node);\r\n    if (index === -1) {\r\n      return [];\r\n    }\r\n    const children: E[] = [];\r\n    let i = index + 1;\r\n    while (i < nodes.length && nodes[i].y > node.y) {\r\n      children.push(nodes[i]);\r\n      i++;\r\n    }\r\n    return children;\r\n  }\r\n\r\n  private removeDescendants(\r\n    nodes: PagedTreeNode<F>[],\r\n    nodeIndex: number\r\n  ): void {\r\n    let i = nodeIndex + 1;\r\n    while (i < nodes.length && nodes[i].y > nodes[nodeIndex].y) {\r\n      i++;\r\n    }\r\n    nodes.splice(nodeIndex + 1, i - nodeIndex - 1);\r\n  }\r\n\r\n  /**\r\n   * Collapse the node with the specified ID. If the node is not expandable,\r\n   * or it is already collapsed, this method does nothing.\r\n   * @param node The node to collapse.\r\n   * @returns Promise with true if the node was collapsed, false otherwise.\r\n   */\r\n  public collapse(id: number): Promise<boolean> {\r\n    if (!id) {\r\n      return Promise.resolve(false);\r\n    }\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      const node = this._nodes$.value.find((n) => n.id === id);\r\n      if (!node || node.hasChildren === false || !node.expanded) {\r\n        resolve(false);\r\n      }\r\n\r\n      // remove all the descendant nodes after the current node\r\n      const nodes = this._nodes$.value;\r\n      const nodeIndex = nodes.indexOf(node!);\r\n      if (nodeIndex === -1) {\r\n        reject(`Node ID ${id} not found in store`);\r\n      } else {\r\n        this._dirty = true;\r\n        this.removeDescendants(nodes, nodeIndex);\r\n        this._nodes$.next(nodes);\r\n        node!.expanded = false;\r\n        resolve(true);\r\n      }\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Change the page including the node with the specified ID.\r\n   * @param node The parent node whose children are inside the page you want to change.\r\n   * @param pageNumber The new page number.\r\n   * @returns Promise with true if the page was changed, false otherwise.\r\n   */\r\n  public changePage(parentId: number, pageNumber: number): Promise<boolean> {\r\n    return new Promise<boolean>((resolve, reject) => {\r\n      const parentNode = this._nodes$.value.find((n) => n.id === parentId);\r\n      if (!parentNode) {\r\n        resolve(false);\r\n      }\r\n      this.getPageFromCacheOrServer(\r\n        { ...this.getFilter(parentNode), parentId },\r\n        pageNumber\r\n      ).subscribe((page) => {\r\n        // if page is empty do nothing\r\n        if (!page.total) {\r\n          resolve(false);\r\n        } else {\r\n          this._dirty = true;\r\n          // remove all the nodes in the same page of node\r\n          // with all their descendants\r\n          const nodes = this._nodes$.value;\r\n          const nodeIndex = nodes.indexOf(parentNode!) + 1;\r\n          const pageNodes = this.createPageNodes(page);\r\n          // find the first node of the node's page\r\n          let start = nodeIndex;\r\n          const oldPageNr = nodes[start].paging.pageNumber;\r\n          while (\r\n            start > 0 &&\r\n            nodes[start - 1].parentId === parentId &&\r\n            nodes[start - 1].paging.pageNumber === oldPageNr\r\n          ) {\r\n            start--;\r\n          }\r\n          // find the last node of the node's page,\r\n          // including all their descendants\r\n          let end = nodeIndex + 1;\r\n          while (\r\n            end < nodes.length &&\r\n            nodes[end].parentId === parentId &&\r\n            nodes[end].paging.pageNumber === oldPageNr\r\n          ) {\r\n            end++;\r\n          }\r\n          // replace all these nodes with the new ones\r\n          nodes.splice(start, end - start);\r\n          nodes.splice(start, 0, ...(pageNodes as E[]));\r\n          // update the parent node paging info\r\n          parentNode!.paging.pageNumber = page.pageNumber;\r\n          this._nodes$.next(nodes);\r\n          resolve(true);\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Collapse all the nodes in the store.\r\n   */\r\n  public collapseAll(): void {\r\n    this._nodes$.next([this._radix!, ...this._roots]);\r\n  }\r\n}\r\n"]}

package/esm2022/myrmidon-paged-data-browsers.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXlybWlkb24tcGFnZWQtZGF0YS1icm93c2Vycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL215cm1pZG9uL3BhZ2VkLWRhdGEtYnJvd3NlcnMvc3JjL215cm1pZG9uLXBhZ2VkLWRhdGEtYnJvd3NlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/public-api.mjs

@@ -0,0 +1,11 @@
+/*
+ * Public API Surface of paged-data-browsers
+ */
+export * from './lib/components/compact-pager/compact-pager.component';
+export * from './lib/components/range-view/range-view.component';
+export * from './lib/components/browser-tree-node/browser-tree-node.component';
+export * from './lib/services/paged-list.store';
+export * from './lib/services/paged-tree.store';
+export * from './lib/services/lru-cache';
+export * from './lib/paged-data-browsers.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL215cm1pZG9uL3BhZ2VkLWRhdGEtYnJvd3NlcnMvc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLHdEQUF3RCxDQUFDO0FBQ3ZFLGNBQWMsa0RBQWtELENBQUM7QUFDakUsY0FBYyxnRUFBZ0UsQ0FBQztBQUUvRSxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYywwQkFBMEIsQ0FBQztBQUV6QyxjQUFjLGtDQUFrQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBwYWdlZC1kYXRhLWJyb3dzZXJzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvY29tcG9uZW50cy9jb21wYWN0LXBhZ2VyL2NvbXBhY3QtcGFnZXIuY29tcG9uZW50JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NvbXBvbmVudHMvcmFuZ2Utdmlldy9yYW5nZS12aWV3LmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb21wb25lbnRzL2Jyb3dzZXItdHJlZS1ub2RlL2Jyb3dzZXItdHJlZS1ub2RlLmNvbXBvbmVudCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3NlcnZpY2VzL3BhZ2VkLWxpc3Quc3RvcmUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMvcGFnZWQtdHJlZS5zdG9yZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9scnUtY2FjaGUnO1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9wYWdlZC1kYXRhLWJyb3dzZXJzLm1vZHVsZSc7XG4iXX0=