@alfresco/adf-content-services 8.1.0-16120632321 → 8.1.0-16121703802

package/esm2022/lib/tree/services/tree.service.mjs

@@ -0,0 +1,134 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { DataSource } from '@angular/cdk/collections';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { BehaviorSubject } from 'rxjs';
+import * as i0 from "@angular/core";
+export class TreeService extends DataSource {
+    get treeNodes() {
+        return this.treeControl.dataNodes;
+    }
+    set treeNodes(nodes) {
+        this.treeControl.dataNodes = nodes;
+        this.treeNodesSource.next(nodes);
+    }
+    constructor() {
+        super();
+        this.treeNodesSource = new BehaviorSubject([]);
+        this.treeControl = new FlatTreeControl((node) => node.level, (node) => node.hasChildren);
+        this.treeNodes = [];
+    }
+    /**
+     * Expands node applying subnodes to it.
+     *
+     * @param nodeToExpand Node to be expanded
+     * @param subNodes List of nodes that will be added as children of expanded node
+     */
+    expandNode(nodeToExpand, subNodes) {
+        if (nodeToExpand != null && subNodes != null && nodeToExpand.hasChildren) {
+            this.treeControl.expand(nodeToExpand);
+            const index = this.treeNodes.indexOf(nodeToExpand);
+            this.treeNodes.splice(index + 1, 0, ...subNodes);
+            nodeToExpand.isLoading = false;
+            this.treeNodesSource.next(this.treeNodes);
+        }
+    }
+    /**
+     * Collapses a node removing all children from it.
+     *
+     * @param nodeToCollapse Node to be collapsed
+     */
+    collapseNode(nodeToCollapse) {
+        if (nodeToCollapse?.hasChildren) {
+            this.treeControl.collapse(nodeToCollapse);
+            const children = this.treeNodes.filter((node) => nodeToCollapse.id === node.parentId);
+            children.forEach((child) => {
+                this.collapseInnerNode(child);
+            });
+            this.treeNodesSource.next(this.treeNodes);
+        }
+    }
+    /**
+     * Append more child nodes to already expanded parent node
+     *
+     * @param nodeToAppend Expanded parent node
+     * @param subNodes List of nodes that will be added as children of expanded node
+     */
+    appendNodes(nodeToAppend, subNodes) {
+        if (nodeToAppend != null && subNodes != null) {
+            const lastChild = this.treeNodes.filter((treeNode) => nodeToAppend.id === treeNode.parentId).pop();
+            const index = this.treeNodes.indexOf(lastChild);
+            const children = this.treeControl.getDescendants(lastChild).length;
+            this.treeNodes.splice(index + children + 1, 0, ...subNodes);
+            nodeToAppend.isLoading = false;
+            this.treeNodesSource.next(this.treeNodes);
+        }
+    }
+    /**
+     * Removes provided node from the tree
+     *
+     * @param node Node to be removed
+     */
+    removeNode(node) {
+        this.treeNodes.splice(this.treeNodes.indexOf(node), 1);
+    }
+    /**
+     * Gets children of the node
+     *
+     * @param parentNode Parent node
+     * @returns children of parent node
+     */
+    getChildren(parentNode) {
+        return this.treeNodes.filter((treeNode) => treeNode.parentId === parentNode.id);
+    }
+    /**
+     * Checks if tree is empty
+     *
+     * @returns boolean
+     */
+    isEmpty() {
+        return !this.treeNodes.length;
+    }
+    /**
+     * Gets parent node of given node. If node with parentNodeId is not found it returns undefined.
+     *
+     * @param parentNodeId Id of a parent node to be found
+     * @returns parent node or undefined when not found
+     */
+    getParentNode(parentNodeId) {
+        return this.treeNodes.find((treeNode) => treeNode.id === parentNodeId);
+    }
+    connect() {
+        return this.treeNodesSource.asObservable();
+    }
+    disconnect() { }
+    collapseInnerNode(nodeToCollapse) {
+        const index = this.treeNodes.indexOf(nodeToCollapse);
+        this.treeNodes.splice(index, 1);
+        if (nodeToCollapse.hasChildren) {
+            this.treeNodes.filter((node) => nodeToCollapse.id === node.parentId).forEach((child) => this.collapseInnerNode(child));
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.service.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tree/services/tree.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACtD,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,eAAe,EAAc,MAAM,MAAM,CAAC;;AAKnD,MAAM,OAAgB,WAAgC,SAAQ,UAAa;IAIvE,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC;IACtC,CAAC;IAED,IAAI,SAAS,CAAC,KAAU;QACpB,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,KAAK,CAAC;QACnC,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAED;QACI,KAAK,EAAE,CAAC;QAZL,oBAAe,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;QAalD,IAAI,CAAC,WAAW,GAAG,IAAI,eAAe,CAClC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,EACpB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAC7B,CAAC;QACF,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACxB,CAAC;IAID;;;;;OAKG;IACI,UAAU,CAAC,YAAe,EAAE,QAAa;QAC5C,IAAI,YAAY,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,IAAI,YAAY,CAAC,WAAW,EAAE,CAAC;YACvE,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;YACtC,MAAM,KAAK,GAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;YAC3D,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC;YACjD,YAAY,CAAC,SAAS,GAAG,KAAK,CAAC;YAC/B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,cAAiB;QACjC,IAAI,cAAc,EAAE,WAAW,EAAE,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;YAC1C,MAAM,QAAQ,GAAQ,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAO,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC9F,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAQ,EAAE,EAAE;gBAC1B,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC;YAClC,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;IACL,CAAC;IAED;;;;;OAKG;IACI,WAAW,CAAC,YAAe,EAAE,QAAa;QAC7C,IAAI,YAAY,IAAI,IAAI,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;YAC3C,MAAM,SAAS,GAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,QAAW,EAAE,EAAE,CAAC,YAAY,CAAC,EAAE,KAAK,QAAQ,CAAC,QAAQ,CAAC,CAAC,GAAG,EAAE,CAAC;YACzG,MAAM,KAAK,GAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YACxD,MAAM,QAAQ,GAAW,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC;YAC3E,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,GAAG,QAAQ,GAAG,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC;YAC5D,YAAY,CAAC,SAAS,GAAG,KAAK,CAAC;YAC/B,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC9C,CAAC;IACL,CAAC;IAED;;;;OAIG;IACI,UAAU,CAAC,IAAO;QACrB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACI,WAAW,CAAC,UAAa;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,QAAW,EAAE,EAAE,CAAC,QAAQ,CAAC,QAAQ,KAAK,UAAU,CAAC,EAAE,CAAC,CAAC;IACvF,CAAC;IAED;;;;OAIG;IACI,OAAO;QACV,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;IAClC,CAAC;IAED;;;;;OAKG;IACI,aAAa,CAAC,YAAoB;QACrC,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,QAAW,EAAE,EAAE,CAAC,QAAQ,CAAC,EAAE,KAAK,YAAY,CAAC,CAAC;IAC9E,CAAC;IAEM,OAAO;QACV,OAAO,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;IAC/C,CAAC;IAEM,UAAU,KAAU,CAAC;IAEpB,iBAAiB,CAAC,cAAiB;QACvC,MAAM,KAAK,GAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC;QAC7D,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAChC,IAAI,cAAc,CAAC,WAAW,EAAE,CAAC;YAC7B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,IAAO,EAAE,EAAE,CAAC,cAAc,CAAC,EAAE,KAAK,IAAI,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,KAAQ,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,CAAC,CAAC,CAAC;QACjI,CAAC;IACL,CAAC;+GA3HiB,WAAW;mHAAX,WAAW,cADP,MAAM;;4FACV,WAAW;kBADhC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { DataSource } from '@angular/cdk/collections';\nimport { FlatTreeControl } from '@angular/cdk/tree';\nimport { BehaviorSubject, Observable } from 'rxjs';\nimport { TreeNode } from '../models/tree-node.interface';\nimport { TreeResponse } from '../models/tree-response.interface';\n\n@Injectable({ providedIn: 'root' })\nexport abstract class TreeService<T extends TreeNode> extends DataSource<T> {\n    public readonly treeControl: FlatTreeControl<T>;\n    public treeNodesSource = new BehaviorSubject<T[]>([]);\n\n    get treeNodes(): T[] {\n        return this.treeControl.dataNodes;\n    }\n\n    set treeNodes(nodes: T[]) {\n        this.treeControl.dataNodes = nodes;\n        this.treeNodesSource.next(nodes);\n    }\n\n    constructor() {\n        super();\n        this.treeControl = new FlatTreeControl<T>(\n            (node) => node.level,\n            (node) => node.hasChildren\n        );\n        this.treeNodes = [];\n    }\n\n    public abstract getSubNodes(parentNodeId: string, skipCount?: number, maxItems?: number, searchTerm?: string): Observable<TreeResponse<T>>;\n\n    /**\n     * Expands node applying subnodes to it.\n     *\n     * @param nodeToExpand Node to be expanded\n     * @param subNodes List of nodes that will be added as children of expanded node\n     */\n    public expandNode(nodeToExpand: T, subNodes: T[]): void {\n        if (nodeToExpand != null && subNodes != null && nodeToExpand.hasChildren) {\n            this.treeControl.expand(nodeToExpand);\n            const index: number = this.treeNodes.indexOf(nodeToExpand);\n            this.treeNodes.splice(index + 1, 0, ...subNodes);\n            nodeToExpand.isLoading = false;\n            this.treeNodesSource.next(this.treeNodes);\n        }\n    }\n\n    /**\n     * Collapses a node removing all children from it.\n     *\n     * @param nodeToCollapse Node to be collapsed\n     */\n    public collapseNode(nodeToCollapse: T): void {\n        if (nodeToCollapse?.hasChildren) {\n            this.treeControl.collapse(nodeToCollapse);\n            const children: T[] = this.treeNodes.filter((node: T) => nodeToCollapse.id === node.parentId);\n            children.forEach((child: T) => {\n                this.collapseInnerNode(child);\n            });\n            this.treeNodesSource.next(this.treeNodes);\n        }\n    }\n\n    /**\n     * Append more child nodes to already expanded parent node\n     *\n     * @param nodeToAppend Expanded parent node\n     * @param subNodes List of nodes that will be added as children of expanded node\n     */\n    public appendNodes(nodeToAppend: T, subNodes: T[]): void {\n        if (nodeToAppend != null && subNodes != null) {\n            const lastChild: T = this.treeNodes.filter((treeNode: T) => nodeToAppend.id === treeNode.parentId).pop();\n            const index: number = this.treeNodes.indexOf(lastChild);\n            const children: number = this.treeControl.getDescendants(lastChild).length;\n            this.treeNodes.splice(index + children + 1, 0, ...subNodes);\n            nodeToAppend.isLoading = false;\n            this.treeNodesSource.next(this.treeNodes);\n        }\n    }\n\n    /**\n     * Removes provided node from the tree\n     *\n     * @param node Node to be removed\n     */\n    public removeNode(node: T): void {\n        this.treeNodes.splice(this.treeNodes.indexOf(node), 1);\n    }\n\n    /**\n     * Gets children of the node\n     *\n     * @param parentNode Parent node\n     * @returns children of parent node\n     */\n    public getChildren(parentNode: T): T[] {\n        return this.treeNodes.filter((treeNode: T) => treeNode.parentId === parentNode.id);\n    }\n\n    /**\n     * Checks if tree is empty\n     *\n     * @returns boolean\n     */\n    public isEmpty(): boolean {\n        return !this.treeNodes.length;\n    }\n\n    /**\n     * Gets parent node of given node. If node with parentNodeId is not found it returns undefined.\n     *\n     * @param parentNodeId Id of a parent node to be found\n     * @returns parent node or undefined when not found\n     */\n    public getParentNode(parentNodeId: string): T | undefined {\n        return this.treeNodes.find((treeNode: T) => treeNode.id === parentNodeId);\n    }\n\n    public connect(): Observable<T[]> {\n        return this.treeNodesSource.asObservable();\n    }\n\n    public disconnect(): void {}\n\n    private collapseInnerNode(nodeToCollapse: T): void {\n        const index: number = this.treeNodes.indexOf(nodeToCollapse);\n        this.treeNodes.splice(index, 1);\n        if (nodeToCollapse.hasChildren) {\n            this.treeNodes.filter((node: T) => nodeToCollapse.id === node.parentId).forEach((child: T) => this.collapseInnerNode(child));\n        }\n    }\n}\n"]}

package/esm2022/lib/tree/tree.module.mjs

@@ -0,0 +1,33 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { TreeComponent } from './components/tree.component';
+import * as i0 from "@angular/core";
+/** @deprecated use `TreeComponent` standalone component instead */
+export class TreeModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TreeModule, imports: [TreeComponent], exports: [TreeComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeModule, imports: [TreeComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [TreeComponent],
+                    exports: [TreeComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3RyZWUvdHJlZS5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sNkJBQTZCLENBQUM7O0FBRTVELG1FQUFtRTtBQUtuRSxNQUFNLE9BQU8sVUFBVTsrR0FBVixVQUFVO2dIQUFWLFVBQVUsWUFIVCxhQUFhLGFBQ2IsYUFBYTtnSEFFZCxVQUFVLFlBSFQsYUFBYTs7NEZBR2QsVUFBVTtrQkFKdEIsUUFBUTttQkFBQztvQkFDTixPQUFPLEVBQUUsQ0FBQyxhQUFhLENBQUM7b0JBQ3hCLE9BQU8sRUFBRSxDQUFDLGFBQWEsQ0FBQztpQkFDM0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUcmVlQ29tcG9uZW50IH0gZnJvbSAnLi9jb21wb25lbnRzL3RyZWUuY29tcG9uZW50JztcblxuLyoqIEBkZXByZWNhdGVkIHVzZSBgVHJlZUNvbXBvbmVudGAgc3RhbmRhbG9uZSBjb21wb25lbnQgaW5zdGVhZCAqL1xuQE5nTW9kdWxlKHtcbiAgICBpbXBvcnRzOiBbVHJlZUNvbXBvbmVudF0sXG4gICAgZXhwb3J0czogW1RyZWVDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVNb2R1bGUge31cbiJdfQ==

package/esm2022/lib/tree-view/components/tree-view.component.mjs

@@ -0,0 +1,75 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { TreeViewDataSource } from '../data/tree-view-datasource';
+import { TreeViewService } from '../services/tree-view.service';
+import { CommonModule } from '@angular/common';
+import { MatTreeModule } from '@angular/material/tree';
+import { MatButtonModule } from '@angular/material/button';
+import { MatIconModule } from '@angular/material/icon';
+import { TranslatePipe } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/tree-view.service";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/material/tree";
+import * as i4 from "@angular/material/button";
+import * as i5 from "@angular/material/icon";
+export class TreeViewComponent {
+    constructor(treeViewService) {
+        this.treeViewService = treeViewService;
+        /** Emitted when a node in the tree view is clicked. */
+        this.nodeClicked = new EventEmitter();
+        /** Emitted when an invalid node id is given. */
+        this.error = new EventEmitter();
+        this.getLevel = (node) => node.level;
+        this.isExpandable = (node) => node.expandable;
+        this.hasChild = (_, nodeData) => nodeData.expandable;
+        this.treeControl = new FlatTreeControl(this.getLevel, this.isExpandable);
+        this.dataSource = new TreeViewDataSource(this.treeControl, this.treeViewService);
+    }
+    ngOnChanges(changes) {
+        if (changes['nodeId']?.currentValue && changes['nodeId'].currentValue !== changes['nodeId'].previousValue) {
+            this.loadTreeNode();
+        }
+        else {
+            this.dataSource.data = [];
+        }
+    }
+    onNodeClicked(node) {
+        this.nodeClicked.emit(node);
+    }
+    loadTreeNode() {
+        this.treeViewService.getTreeNodes(this.nodeId).subscribe((treeNode) => {
+            this.dataSource.data = treeNode;
+        }, (error) => this.error.emit(error));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewComponent, deps: [{ token: i1.TreeViewService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: TreeViewComponent, isStandalone: true, selector: "adf-tree-view-list", inputs: { nodeId: "nodeId" }, outputs: { nodeClicked: "nodeClicked", error: "error" }, usesOnChanges: true, ngImport: i0, template: "<mat-tree class=\"adf-tree-view-main\" [dataSource]=\"dataSource\" [treeControl]=\"treeControl\" *ngIf=\"nodeId; else missingNodeId\">\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        *matTreeNodeDef=\"let treeNode\"\n        id=\"{{ treeNode.name + '-tree-node' }}\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        {{ treeNode.name }}\n    </mat-tree-node>\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        id=\"{{ treeNode.name + '-tree-child-node' }}\"\n        *matTreeNodeDef=\"let treeNode; when: hasChild\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        <button\n            matTreeNodeToggle\n            id=\"{{ 'button-' + treeNode.name }}\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            mat-icon-button\n            [attr.aria-label]=\"\n                'ADF-TREE-VIEW.ACCESSIBILITY.ARIA_LABEL'\n                    | translate\n                        : {\n                              name: treeNode.name\n                          }\n            \"\n        >\n            <mat-icon class=\"adf-tree-view-icon\">\n                {{ treeControl.isExpanded(treeNode) ? 'folder_open' : 'folder' }}\n            </mat-icon>\n        </button>\n        <span\n            class=\"adf-tree-view-label\"\n            matTreeNodeToggle\n            role=\"button\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            tabindex=\"0\"\n            (keyup.enter)=\"onNodeClicked(treeNode.node)\"\n            >{{ treeNode.name }}</span\n        >\n    </mat-tree-node>\n</mat-tree>\n<ng-template #missingNodeId>\n    <div id=\"adf-tree-view-missing-node\">\n        {{ 'ADF-TREE-VIEW.MISSING-ID' | translate }}\n    </div>\n</ng-template>\n", styles: [".adf-tree-view-icon{color:#d9e022}.adf-tree-view-node.adf-tree-view{min-height:40px;font-size:var(--theme-caption-font-size);align-items:baseline}.adf-tree-view-label{cursor:pointer}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatTreeModule }, { kind: "directive", type: i3.MatTreeNodeDef, selector: "[matTreeNodeDef]", inputs: ["matTreeNodeDefWhen", "matTreeNode"] }, { kind: "directive", type: i3.MatTreeNodePadding, selector: "[matTreeNodePadding]", inputs: ["matTreeNodePadding", "matTreeNodePaddingIndent"] }, { kind: "directive", type: i3.MatTreeNodeToggle, selector: "[matTreeNodeToggle]", inputs: ["matTreeNodeToggleRecursive"] }, { kind: "component", type: i3.MatTree, selector: "mat-tree", exportAs: ["matTree"] }, { kind: "directive", type: i3.MatTreeNode, selector: "mat-tree-node", inputs: ["tabIndex", "disabled"], outputs: ["activation", "expandedChange"], exportAs: ["matTreeNode"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i4.MatIconButton, selector: "button[mat-icon-button]", exportAs: ["matButton"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: TranslatePipe, name: "translate" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'adf-tree-view-list', standalone: true, imports: [CommonModule, MatTreeModule, MatButtonModule, MatIconModule, TranslatePipe], template: "<mat-tree class=\"adf-tree-view-main\" [dataSource]=\"dataSource\" [treeControl]=\"treeControl\" *ngIf=\"nodeId; else missingNodeId\">\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        *matTreeNodeDef=\"let treeNode\"\n        id=\"{{ treeNode.name + '-tree-node' }}\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        {{ treeNode.name }}\n    </mat-tree-node>\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        id=\"{{ treeNode.name + '-tree-child-node' }}\"\n        *matTreeNodeDef=\"let treeNode; when: hasChild\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        <button\n            matTreeNodeToggle\n            id=\"{{ 'button-' + treeNode.name }}\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            mat-icon-button\n            [attr.aria-label]=\"\n                'ADF-TREE-VIEW.ACCESSIBILITY.ARIA_LABEL'\n                    | translate\n                        : {\n                              name: treeNode.name\n                          }\n            \"\n        >\n            <mat-icon class=\"adf-tree-view-icon\">\n                {{ treeControl.isExpanded(treeNode) ? 'folder_open' : 'folder' }}\n            </mat-icon>\n        </button>\n        <span\n            class=\"adf-tree-view-label\"\n            matTreeNodeToggle\n            role=\"button\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            tabindex=\"0\"\n            (keyup.enter)=\"onNodeClicked(treeNode.node)\"\n            >{{ treeNode.name }}</span\n        >\n    </mat-tree-node>\n</mat-tree>\n<ng-template #missingNodeId>\n    <div id=\"adf-tree-view-missing-node\">\n        {{ 'ADF-TREE-VIEW.MISSING-ID' | translate }}\n    </div>\n</ng-template>\n", styles: [".adf-tree-view-icon{color:#d9e022}.adf-tree-view-node.adf-tree-view{min-height:40px;font-size:var(--theme-caption-font-size);align-items:baseline}.adf-tree-view-label{cursor:pointer}\n"] }]
+        }], ctorParameters: () => [{ type: i1.TreeViewService }], propDecorators: { nodeId: [{
+                type: Input,
+                args: [{ required: true }]
+            }], nodeClicked: [{
+                type: Output
+            }], error: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-view.component.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tree-view/components/tree-view.component.ts","../../../../../../../lib/content-services/src/lib/tree-view/components/tree-view.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,KAAK,EAAa,MAAM,EAAiB,MAAM,eAAe,CAAC;AAEjG,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AACvD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;;;;;;;AASpD,MAAM,OAAO,iBAAiB;IAgB1B,YAAoB,eAAgC;QAAhC,oBAAe,GAAf,eAAe,CAAiB;QAXpD,uDAAuD;QAEvD,gBAAW,GAA4B,IAAI,YAAY,EAAE,CAAC;QAE1D,gDAAgD;QAEhD,UAAK,GAAsB,IAAI,YAAY,EAAE,CAAC;QAsB9C,aAAQ,GAAG,CAAC,IAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC;QAE9C,iBAAY,GAAG,CAAC,IAAkB,EAAE,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC;QAEvD,aAAQ,GAAG,CAAC,CAAS,EAAE,QAAsB,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;QApBlE,IAAI,CAAC,WAAW,GAAG,IAAI,eAAe,CAAe,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC;QACvF,IAAI,CAAC,UAAU,GAAG,IAAI,kBAAkB,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,eAAe,CAAC,CAAC;IACrF,CAAC;IAED,WAAW,CAAC,OAAsB;QAC9B,IAAI,OAAO,CAAC,QAAQ,CAAC,EAAE,YAAY,IAAI,OAAO,CAAC,QAAQ,CAAC,CAAC,YAAY,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC,aAAa,EAAE,CAAC;YACxG,IAAI,CAAC,YAAY,EAAE,CAAC;QACxB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,EAAE,CAAC;QAC9B,CAAC;IACL,CAAC;IAED,aAAa,CAAC,IAAe;QACzB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAChC,CAAC;IAQO,YAAY;QAChB,IAAI,CAAC,eAAe,CAAC,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,SAAS,CACpD,CAAC,QAAwB,EAAE,EAAE;YACzB,IAAI,CAAC,UAAU,CAAC,IAAI,GAAG,QAAQ,CAAC;QACpC,CAAC,EACD,CAAC,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CACpC,CAAC;IACN,CAAC;+GA9CQ,iBAAiB;mGAAjB,iBAAiB,0LCpC9B,gyDAkDA,iPDlBc,YAAY,kIAAE,aAAa,+qBAAE,eAAe,2IAAE,aAAa,+KAAE,aAAa;;4FAI3E,iBAAiB;kBAP7B,SAAS;+BACI,oBAAoB,cAClB,IAAI,WACP,CAAC,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,CAAC;oFAOrF,MAAM;sBADL,KAAK;uBAAC,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAKzB,WAAW;sBADV,MAAM;gBAKP,KAAK;sBADJ,MAAM","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FlatTreeControl } from '@angular/cdk/tree';\nimport { Component, EventEmitter, Input, OnChanges, Output, SimpleChanges } from '@angular/core';\nimport { TreeBaseNode } from '../models/tree-view.model';\nimport { TreeViewDataSource } from '../data/tree-view-datasource';\nimport { TreeViewService } from '../services/tree-view.service';\nimport { NodeEntry } from '@alfresco/js-api';\nimport { CommonModule } from '@angular/common';\nimport { MatTreeModule } from '@angular/material/tree';\nimport { MatButtonModule } from '@angular/material/button';\nimport { MatIconModule } from '@angular/material/icon';\nimport { TranslatePipe } from '@ngx-translate/core';\n\n@Component({\n    selector: 'adf-tree-view-list',\n    standalone: true,\n    imports: [CommonModule, MatTreeModule, MatButtonModule, MatIconModule, TranslatePipe],\n    templateUrl: './tree-view.component.html',\n    styleUrls: ['./tree-view.component.scss']\n})\nexport class TreeViewComponent implements OnChanges {\n    /** Identifier of the node to display. */\n    @Input({ required: true })\n    nodeId: string;\n\n    /** Emitted when a node in the tree view is clicked. */\n    @Output()\n    nodeClicked: EventEmitter<NodeEntry> = new EventEmitter();\n\n    /** Emitted when an invalid node id is given. */\n    @Output()\n    error: EventEmitter<any> = new EventEmitter();\n\n    treeControl: FlatTreeControl<TreeBaseNode>;\n    dataSource: TreeViewDataSource;\n\n    constructor(private treeViewService: TreeViewService) {\n        this.treeControl = new FlatTreeControl<TreeBaseNode>(this.getLevel, this.isExpandable);\n        this.dataSource = new TreeViewDataSource(this.treeControl, this.treeViewService);\n    }\n\n    ngOnChanges(changes: SimpleChanges) {\n        if (changes['nodeId']?.currentValue && changes['nodeId'].currentValue !== changes['nodeId'].previousValue) {\n            this.loadTreeNode();\n        } else {\n            this.dataSource.data = [];\n        }\n    }\n\n    onNodeClicked(node: NodeEntry) {\n        this.nodeClicked.emit(node);\n    }\n\n    getLevel = (node: TreeBaseNode) => node.level;\n\n    isExpandable = (node: TreeBaseNode) => node.expandable;\n\n    hasChild = (_: number, nodeData: TreeBaseNode) => nodeData.expandable;\n\n    private loadTreeNode() {\n        this.treeViewService.getTreeNodes(this.nodeId).subscribe(\n            (treeNode: TreeBaseNode[]) => {\n                this.dataSource.data = treeNode;\n            },\n            (error) => this.error.emit(error)\n        );\n    }\n}\n","<mat-tree class=\"adf-tree-view-main\" [dataSource]=\"dataSource\" [treeControl]=\"treeControl\" *ngIf=\"nodeId; else missingNodeId\">\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        *matTreeNodeDef=\"let treeNode\"\n        id=\"{{ treeNode.name + '-tree-node' }}\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        {{ treeNode.name }}\n    </mat-tree-node>\n    <mat-tree-node\n        class=\"adf-tree-view adf-tree-view-node\"\n        id=\"{{ treeNode.name + '-tree-child-node' }}\"\n        *matTreeNodeDef=\"let treeNode; when: hasChild\"\n        matTreeNodePadding\n        [matTreeNodePaddingIndent]=\"15\"\n    >\n        <button\n            matTreeNodeToggle\n            id=\"{{ 'button-' + treeNode.name }}\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            mat-icon-button\n            [attr.aria-label]=\"\n                'ADF-TREE-VIEW.ACCESSIBILITY.ARIA_LABEL'\n                    | translate\n                        : {\n                              name: treeNode.name\n                          }\n            \"\n        >\n            <mat-icon class=\"adf-tree-view-icon\">\n                {{ treeControl.isExpanded(treeNode) ? 'folder_open' : 'folder' }}\n            </mat-icon>\n        </button>\n        <span\n            class=\"adf-tree-view-label\"\n            matTreeNodeToggle\n            role=\"button\"\n            (click)=\"onNodeClicked(treeNode.node)\"\n            tabindex=\"0\"\n            (keyup.enter)=\"onNodeClicked(treeNode.node)\"\n            >{{ treeNode.name }}</span\n        >\n    </mat-tree-node>\n</mat-tree>\n<ng-template #missingNodeId>\n    <div id=\"adf-tree-view-missing-node\">\n        {{ 'ADF-TREE-VIEW.MISSING-ID' | translate }}\n    </div>\n</ng-template>\n"]}

package/esm2022/lib/tree-view/data/tree-view-datasource.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, merge } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { TreeViewService } from '../services/tree-view.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/tree";
+import * as i2 from "../services/tree-view.service";
+export class TreeViewDataSource {
+    get data() {
+        return this.treeNodes;
+    }
+    set data(value) {
+        this.treeControl.dataNodes = value;
+        this.dataChange.next(value);
+    }
+    constructor(treeControl, treeViewService) {
+        this.treeControl = treeControl;
+        this.treeViewService = treeViewService;
+        this.dataChange = new BehaviorSubject([]);
+        this.childrenSubscription = null;
+        this.changeSubscription = null;
+        this.dataChange.subscribe((treeNodes) => (this.treeNodes = treeNodes));
+    }
+    connect(collectionViewer) {
+        this.changeSubscription = this.treeControl.expansionModel.changed.subscribe((change) => {
+            if (change.added && change.added.length > 0) {
+                this.expandTreeNodes(change);
+            }
+            else if (change.removed) {
+                this.reduceTreeNodes(change);
+            }
+        });
+        return merge(collectionViewer.viewChange, this.dataChange).pipe(map(() => this.data));
+    }
+    disconnect() {
+        if (this.childrenSubscription) {
+            this.childrenSubscription.unsubscribe();
+        }
+        if (this.changeSubscription) {
+            this.changeSubscription.unsubscribe();
+        }
+    }
+    expandTreeNodes(change) {
+        change.added.forEach((node) => this.expandNode(node));
+    }
+    reduceTreeNodes(change) {
+        change.removed
+            .slice()
+            .reverse()
+            .forEach((node) => this.toggleNode(node));
+    }
+    expandNode(node) {
+        this.childrenSubscription = this.treeViewService.getTreeNodes(node.nodeId).subscribe((children) => {
+            const index = this.data.indexOf(node);
+            if (!children || index < 0) {
+                node.expandable = false;
+                return;
+            }
+            const nodes = children.map((actualNode) => {
+                actualNode.level = node.level + 1;
+                return actualNode;
+            });
+            this.data.splice(index + 1, 0, ...nodes);
+            this.dataChange.next(this.data);
+        });
+    }
+    toggleNode(node) {
+        const index = this.data.indexOf(node);
+        let count = 0;
+        for (let i = index + 1; i < this.data.length && this.data[i].level > node.level; i++, count++) {
+            /* empty */
+        }
+        this.data.splice(index + 1, count);
+        this.dataChange.next(this.data);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewDataSource, deps: [{ token: i1.FlatTreeControl }, { token: i2.TreeViewService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewDataSource }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewDataSource, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.FlatTreeControl }, { type: i2.TreeViewService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-view-datasource.js","sourceRoot":"","sources":["../../../../../../../lib/content-services/src/lib/tree-view/data/tree-view-datasource.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { CollectionViewer, SelectionChange } from '@angular/cdk/collections';\nimport { BehaviorSubject, merge, Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\nimport { FlatTreeControl } from '@angular/cdk/tree';\nimport { TreeBaseNode } from '../models/tree-view.model';\nimport { TreeViewService } from '../services/tree-view.service';\n\n@Injectable()\nexport class TreeViewDataSource {\n    treeNodes: TreeBaseNode[];\n    dataChange = new BehaviorSubject<TreeBaseNode[]>([]);\n    childrenSubscription = null;\n    changeSubscription = null;\n\n    get data(): TreeBaseNode[] {\n        return this.treeNodes;\n    }\n\n    set data(value: TreeBaseNode[]) {\n        this.treeControl.dataNodes = value;\n        this.dataChange.next(value);\n    }\n\n    constructor(private treeControl: FlatTreeControl<TreeBaseNode>, private treeViewService: TreeViewService) {\n        this.dataChange.subscribe((treeNodes) => (this.treeNodes = treeNodes));\n    }\n\n    connect(collectionViewer: CollectionViewer): Observable<TreeBaseNode[]> {\n        this.changeSubscription = this.treeControl.expansionModel.changed.subscribe((change) => {\n            if ((change as SelectionChange<TreeBaseNode>).added && (change as SelectionChange<TreeBaseNode>).added.length > 0) {\n                this.expandTreeNodes(change as SelectionChange<TreeBaseNode>);\n            } else if ((change as SelectionChange<TreeBaseNode>).removed) {\n                this.reduceTreeNodes(change as SelectionChange<TreeBaseNode>);\n            }\n        });\n        return merge(collectionViewer.viewChange, this.dataChange).pipe(map(() => this.data));\n    }\n\n    disconnect() {\n        if (this.childrenSubscription) {\n            this.childrenSubscription.unsubscribe();\n        }\n        if (this.changeSubscription) {\n            this.changeSubscription.unsubscribe();\n        }\n    }\n\n    private expandTreeNodes(change: SelectionChange<TreeBaseNode>) {\n        change.added.forEach((node) => this.expandNode(node));\n    }\n\n    private reduceTreeNodes(change: SelectionChange<TreeBaseNode>) {\n        change.removed\n            .slice()\n            .reverse()\n            .forEach((node) => this.toggleNode(node));\n    }\n\n    private expandNode(node: TreeBaseNode) {\n        this.childrenSubscription = this.treeViewService.getTreeNodes(node.nodeId).subscribe((children) => {\n            const index = this.data.indexOf(node);\n            if (!children || index < 0) {\n                node.expandable = false;\n                return;\n            }\n            const nodes = children.map((actualNode) => {\n                actualNode.level = node.level + 1;\n                return actualNode;\n            });\n            this.data.splice(index + 1, 0, ...nodes);\n            this.dataChange.next(this.data);\n        });\n    }\n\n    toggleNode(node: TreeBaseNode) {\n        const index = this.data.indexOf(node);\n        let count = 0;\n        for (let i = index + 1; i < this.data.length && this.data[i].level > node.level; i++, count++) {\n            /* empty */\n        }\n        this.data.splice(index + 1, count);\n        this.dataChange.next(this.data);\n    }\n}\n"]}

package/esm2022/lib/tree-view/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWIvY29udGVudC1zZXJ2aWNlcy9zcmMvbGliL3RyZWUtdmlldy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/tree-view/models/tree-view.model.mjs

@@ -0,0 +1,28 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NodeEntry } from '@alfresco/js-api';
+export class TreeBaseNode {
+    constructor(nodeEntry, level, expandable) {
+        this.expandable = true;
+        this.name = nodeEntry.entry.name;
+        this.nodeId = nodeEntry.entry.id;
+        this.level = level ? level : 0;
+        this.expandable = expandable ? expandable : true;
+        this.node = nodeEntry ? new NodeEntry(nodeEntry) : undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tree-view/public-api.mjs

@@ -0,0 +1,22 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './tree-view.module';
+export * from './components/tree-view.component';
+export * from './data/tree-view-datasource';
+export * from './models/tree-view.model';
+export * from './services/tree-view.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvdHJlZS12aWV3L3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLDhCQUE4QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3RyZWUtdmlldy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzL3RyZWUtdmlldy5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhL3RyZWUtdmlldy1kYXRhc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3RyZWUtdmlldy5tb2RlbCc7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2VzL3RyZWUtdmlldy5zZXJ2aWNlJztcbiJdfQ==

package/esm2022/lib/tree-view/services/tree-view.service.mjs

@@ -0,0 +1,38 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NodesApiService } from '../../common/services/nodes-api.service';
+import { inject, Injectable } from '@angular/core';
+import { TreeBaseNode } from '../models/tree-view.model';
+import { map } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class TreeViewService {
+    constructor() {
+        this.nodeApi = inject(NodesApiService);
+    }
+    getTreeNodes(nodeId) {
+        return this.nodeApi.getNodeChildren(nodeId).pipe(map((nodePage) => nodePage.list.entries.filter((node) => (node.entry.isFolder ? node : null))), map((nodes) => nodes.map((node) => new TreeBaseNode(node))));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/tree-view/tree-view.module.mjs

@@ -0,0 +1,33 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { TreeViewComponent } from './components/tree-view.component';
+import * as i0 from "@angular/core";
+/** @deprecated use `TreeViewComponent` instead */
+export class TreeViewModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TreeViewModule, imports: [TreeViewComponent], exports: [TreeViewComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewModule, imports: [TreeViewComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TreeViewModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [TreeViewComponent],
+                    exports: [TreeViewComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJlZS12aWV3Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb250ZW50LXNlcnZpY2VzL3NyYy9saWIvdHJlZS12aWV3L3RyZWUtdmlldy5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxrQ0FBa0MsQ0FBQzs7QUFFckUsa0RBQWtEO0FBS2xELE1BQU0sT0FBTyxjQUFjOytHQUFkLGNBQWM7Z0hBQWQsY0FBYyxZQUhiLGlCQUFpQixhQUNqQixpQkFBaUI7Z0hBRWxCLGNBQWMsWUFIYixpQkFBaUI7OzRGQUdsQixjQUFjO2tCQUoxQixRQUFRO21CQUFDO29CQUNOLE9BQU8sRUFBRSxDQUFDLGlCQUFpQixDQUFDO29CQUM1QixPQUFPLEVBQUUsQ0FBQyxpQkFBaUIsQ0FBQztpQkFDL0IiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBUcmVlVmlld0NvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy90cmVlLXZpZXcuY29tcG9uZW50JztcblxuLyoqIEBkZXByZWNhdGVkIHVzZSBgVHJlZVZpZXdDb21wb25lbnRgIGluc3RlYWQgKi9cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1RyZWVWaWV3Q29tcG9uZW50XSxcbiAgICBleHBvcnRzOiBbVHJlZVZpZXdDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIFRyZWVWaWV3TW9kdWxlIHt9XG4iXX0=