@ptsecurity/mosaic 13.6.0 → 13.7.1

package/esm2020/tree/control/nested-tree-control.mjs

@@ -1,41 +1,41 @@
-import { take } from 'rxjs/operators';
-import { BaseTreeControl } from './base-tree-control';
-/** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
-export class NestedTreeControl extends BaseTreeControl {
-    /** Construct with nested tree function getChildren. */
-    constructor(getChildren) {
-        super();
-        this.getChildren = getChildren;
-    }
-    /**
-     * Expands all dataNodes in the tree.
-     *
-     * To make this working, the `dataNodes` variable of the TreeControl must be set to all root level
-     * data nodes of the tree.
-     */
-    expandAll() {
-        this.expansionModel.clear();
-        const allNodes = this.dataNodes.reduce((accumulator, dataNode) => [...accumulator, ...this.getDescendants(dataNode), dataNode], []);
-        this.expansionModel.select(...allNodes);
-    }
-    /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
-    getDescendants(dataNode) {
-        const descendants = [];
-        this._getDescendants(descendants, dataNode);
-        return descendants.splice(1);
-    }
-    /** A helper function to get descendants recursively. */
-    // todo нужно придумать другое название и понять в чем отличие между getDescendants и _getDescendants
-    /* tslint:disable-next-line:naming-convention */
-    _getDescendants(descendants, dataNode) {
-        descendants.push(dataNode);
-        this.getChildren(dataNode)
-            .pipe(take(1))
-            .subscribe((children) => {
-            if (children && children.length > 0) {
-                children.forEach((child) => this._getDescendants(descendants, child));
-            }
-        });
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+import { take } from 'rxjs/operators';
+import { BaseTreeControl } from './base-tree-control';
+/** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
+export class NestedTreeControl extends BaseTreeControl {
+    /** Construct with nested tree function getChildren. */
+    constructor(getChildren) {
+        super();
+        this.getChildren = getChildren;
+    }
+    /**
+     * Expands all dataNodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all root level
+     * data nodes of the tree.
+     */
+    expandAll() {
+        this.expansionModel.clear();
+        const allNodes = this.dataNodes.reduce((accumulator, dataNode) => [...accumulator, ...this.getDescendants(dataNode), dataNode], []);
+        this.expansionModel.select(...allNodes);
+    }
+    /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
+    getDescendants(dataNode) {
+        const descendants = [];
+        this._getDescendants(descendants, dataNode);
+        return descendants.splice(1);
+    }
+    /** A helper function to get descendants recursively. */
+    // todo нужно придумать другое название и понять в чем отличие между getDescendants и _getDescendants
+    /* tslint:disable-next-line:naming-convention */
+    _getDescendants(descendants, dataNode) {
+        descendants.push(dataNode);
+        this.getChildren(dataNode)
+            .pipe(take(1))
+            .subscribe((children) => {
+            if (children && children.length > 0) {
+                children.forEach((child) => this._getDescendants(descendants, child));
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/control/tree-control.mjs

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=data:application/json;base64,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
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/tree/data-source/flat-data-source.mjs

@@ -1,162 +1,162 @@
-import { DataSource } from '@angular/cdk/collections';
-import { BehaviorSubject, merge } from 'rxjs';
-import { map, take } from 'rxjs/operators';
-/**
- * Tree flattener to convert a normal type of node to node with children & level information.
- * Transform nested nodes of type `T` to flattened nodes of type `F`.
- *
- * For example, the input data of type `T` is nested, and contains its children data:
- *   SomeNode: {
- *     key: 'Fruits',
- *     children: [
- *       NodeOne: {
- *         key: 'Apple',
- *       },
- *       NodeTwo: {
- *        key: 'Pear',
- *      }
- *    ]
- *  }
- *  After flattener flatten the tree, the structure will become
- *  SomeNode: {
- *    key: 'Fruits',
- *    expandable: true,
- *    level: 1
- *  },
- *  NodeOne: {
- *    key: 'Apple',
- *    expandable: false,
- *    level: 2
- *  },
- *  NodeTwo: {
- *   key: 'Pear',
- *   expandable: false,
- *   level: 2
- * }
- * and the output flattened type is `F` with additional information.
- */
-export class McTreeFlattener {
-    constructor(transformFunction, getLevel, isExpandable, getChildren) {
-        this.transformFunction = transformFunction;
-        this.getLevel = getLevel;
-        this.isExpandable = isExpandable;
-        this.getChildren = getChildren;
-    }
-    flattenNode(node, level, resultNodes, parent) {
-        const flatNode = this.transformFunction(node, level, parent);
-        resultNodes.push(flatNode);
-        if (this.isExpandable(flatNode)) {
-            const childrenNodes = this.getChildren(node);
-            if (childrenNodes) {
-                if (Array.isArray(childrenNodes)) {
-                    this.flattenChildren(childrenNodes, level, resultNodes, flatNode);
-                }
-                else {
-                    childrenNodes
-                        .pipe(take(1))
-                        .subscribe((children) => {
-                        this.flattenChildren(children, level, resultNodes, flatNode);
-                    });
-                }
-            }
-        }
-        return resultNodes;
-    }
-    flattenChildren(children, level, resultNodes, parent) {
-        children.forEach((child) => {
-            this.flattenNode(child, level + 1, resultNodes, parent);
-        });
-    }
-    /**
-     * Flatten a list of node type T to flattened version of node F.
-     * Please note that type T may be nested, and the length of `structuredData` may be different
-     * from that of returned list `F[]`.
-     */
-    flattenNodes(structuredData) {
-        const resultNodes = [];
-        structuredData.forEach((node) => this.flattenNode(node, 0, resultNodes, null));
-        return resultNodes;
-    }
-    /**
-     * Expand flattened node with current expansion status.
-     * The returned list may have different length.
-     */
-    expandFlattenedNodes(nodes, treeControl) {
-        const results = [];
-        const currentExpand = [];
-        currentExpand[0] = true;
-        nodes.forEach((node) => {
-            let expand = true;
-            for (let i = 0; i <= this.getLevel(node); i++) {
-                expand = expand && currentExpand[i];
-            }
-            if (expand) {
-                results.push(node);
-            }
-            if (this.isExpandable(node)) {
-                currentExpand[this.getLevel(node) + 1] = treeControl.isExpanded(node);
-            }
-        });
-        return results;
-    }
-}
-var McTreeDataSourceChangeTypes;
-(function (McTreeDataSourceChangeTypes) {
-    McTreeDataSourceChangeTypes["Expansion"] = "expansion";
-    McTreeDataSourceChangeTypes["Filter"] = "filter";
-})(McTreeDataSourceChangeTypes || (McTreeDataSourceChangeTypes = {}));
-/**
- * Data source for flat tree.
- * The data source need to handle expansion/collapsion of the tree node and change the data feed
- * to `McTree`.
- * The nested tree nodes of type `T` are flattened through `MсTreeFlattener`, and converted
- * to type `F` for `McTree` to consume.
- */
-export class McTreeFlatDataSource extends DataSource {
-    constructor(treeControl, treeFlattener, initialData = []) {
-        super();
-        this.treeControl = treeControl;
-        this.treeFlattener = treeFlattener;
-        this.flattenedData = new BehaviorSubject([]);
-        this.expandedData = new BehaviorSubject([]);
-        this.filteredData = new BehaviorSubject([]);
-        this._data = new BehaviorSubject(initialData);
-    }
-    get data() {
-        return this._data.value;
-    }
-    set data(value) {
-        this._data.next(value);
-        this.flattenedData.next(this.treeFlattener.flattenNodes(this.data));
-        this.treeControl.dataNodes = this.flattenedData.value;
-    }
-    connect(collectionViewer) {
-        return merge(collectionViewer.viewChange, this.treeControl.expansionModel.changed
-            .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Expansion, value }))), this.treeControl.filterValue
-            .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Filter, value }))), this.flattenedData)
-            .pipe(map((changeObj) => {
-            if (changeObj.type === McTreeDataSourceChangeTypes.Filter) {
-                if (changeObj.value && changeObj.value.length > 0) {
-                    return this.filterHandler();
-                }
-                else {
-                    return this.expansionHandler(changeObj.value);
-                }
-            }
-            return this.expansionHandler(changeObj.value);
-        }));
-    }
-    filterHandler() {
-        this.filteredData.next(this.treeControl.filterModel.selected);
-        return this.filteredData.value;
-    }
-    expansionHandler(_change) {
-        const expandedNodes = this.treeFlattener.expandFlattenedNodes(this.flattenedData.value, this.treeControl);
-        this.expandedData.next(expandedNodes);
-        return this.expandedData.value;
-    }
-    disconnect() {
-        // no op
-    }
-}
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flat-data-source.js","sourceRoot":"","sources":["../../../../../packages/mosaic/tree/data-source/flat-data-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { CollectionViewer, DataSource, SelectionChange } from '@angular/cdk/collections';\r\nimport { BehaviorSubject, merge, Observable } from 'rxjs';\r\nimport { map, take } from 'rxjs/operators';\r\n\r\nimport { FlatTreeControl } from '../control/flat-tree-control';\r\nimport { TreeControl } from '../control/tree-control';\r\n\r\n\r\n/**\r\n * Tree flattener to convert a normal type of node to node with children & level information.\r\n * Transform nested nodes of type `T` to flattened nodes of type `F`.\r\n *\r\n * For example, the input data of type `T` is nested, and contains its children data:\r\n *   SomeNode: {\r\n *     key: 'Fruits',\r\n *     children: [\r\n *       NodeOne: {\r\n *         key: 'Apple',\r\n *       },\r\n *       NodeTwo: {\r\n *        key: 'Pear',\r\n *      }\r\n *    ]\r\n *  }\r\n *  After flattener flatten the tree, the structure will become\r\n *  SomeNode: {\r\n *    key: 'Fruits',\r\n *    expandable: true,\r\n *    level: 1\r\n *  },\r\n *  NodeOne: {\r\n *    key: 'Apple',\r\n *    expandable: false,\r\n *    level: 2\r\n *  },\r\n *  NodeTwo: {\r\n *   key: 'Pear',\r\n *   expandable: false,\r\n *   level: 2\r\n * }\r\n * and the output flattened type is `F` with additional information.\r\n */\r\nexport class McTreeFlattener<T, F> {\r\n    constructor(\r\n        public transformFunction: (node: T, level: number, parent: F | null) => F,\r\n        public getLevel: (node: F) => number,\r\n        public isExpandable: (node: F) => boolean,\r\n        public getChildren: (node: T) => Observable<T[]> | T[] | undefined | null\r\n    ) {}\r\n\r\n    flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[] {\r\n        const flatNode = this.transformFunction(node, level, parent);\r\n        resultNodes.push(flatNode);\r\n\r\n        if (this.isExpandable(flatNode)) {\r\n            const childrenNodes = this.getChildren(node);\r\n\r\n            if (childrenNodes) {\r\n                if (Array.isArray(childrenNodes)) {\r\n                    this.flattenChildren(childrenNodes, level, resultNodes, flatNode);\r\n                } else {\r\n                    childrenNodes\r\n                        .pipe(take(1))\r\n                        .subscribe((children) => {\r\n                            this.flattenChildren(children, level, resultNodes, flatNode);\r\n                        });\r\n                }\r\n            }\r\n        }\r\n\r\n        return resultNodes;\r\n    }\r\n\r\n    flattenChildren(children: T[], level: number, resultNodes: F[], parent: F | null): void {\r\n        children.forEach((child) => {\r\n            this.flattenNode(child, level + 1, resultNodes, parent);\r\n        });\r\n    }\r\n\r\n    /**\r\n     * Flatten a list of node type T to flattened version of node F.\r\n     * Please note that type T may be nested, and the length of `structuredData` may be different\r\n     * from that of returned list `F[]`.\r\n     */\r\n    flattenNodes(structuredData: T[]): F[] {\r\n        const resultNodes: F[] = [];\r\n        structuredData.forEach((node) => this.flattenNode(node, 0, resultNodes, null));\r\n\r\n        return resultNodes;\r\n    }\r\n\r\n    /**\r\n     * Expand flattened node with current expansion status.\r\n     * The returned list may have different length.\r\n     */\r\n    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F>): F[] {\r\n        const results: F[] = [];\r\n        const currentExpand: boolean[] = [];\r\n        currentExpand[0] = true;\r\n\r\n        nodes.forEach((node) => {\r\n            let expand = true;\r\n            for (let i = 0; i <= this.getLevel(node); i++) {\r\n                expand = expand && currentExpand[i];\r\n            }\r\n\r\n            if (expand) { results.push(node); }\r\n\r\n            if (this.isExpandable(node)) {\r\n                currentExpand[this.getLevel(node) + 1] = treeControl.isExpanded(node);\r\n            }\r\n        });\r\n\r\n        return results;\r\n    }\r\n}\r\n\r\nenum McTreeDataSourceChangeTypes {\r\n    Expansion = 'expansion',\r\n    Filter = 'filter'\r\n}\r\n\r\n/**\r\n * Data source for flat tree.\r\n * The data source need to handle expansion/collapsion of the tree node and change the data feed\r\n * to `McTree`.\r\n * The nested tree nodes of type `T` are flattened through `MсTreeFlattener`, and converted\r\n * to type `F` for `McTree` to consume.\r\n */\r\nexport class McTreeFlatDataSource<T, F> extends DataSource<F> {\r\n    flattenedData = new BehaviorSubject<F[]>([]);\r\n\r\n    expandedData = new BehaviorSubject<F[]>([]);\r\n\r\n    filteredData = new BehaviorSubject<F[]>([]);\r\n\r\n    get data() {\r\n        return this._data.value;\r\n    }\r\n\r\n    set data(value: T[]) {\r\n        this._data.next(value);\r\n\r\n        this.flattenedData.next(this.treeFlattener.flattenNodes(this.data));\r\n        this.treeControl.dataNodes = this.flattenedData.value;\r\n    }\r\n\r\n    private _data: BehaviorSubject<T[]>;\r\n\r\n    constructor(\r\n        private treeControl: FlatTreeControl<F>,\r\n        private treeFlattener: McTreeFlattener<T, F>,\r\n        initialData: T[] = []\r\n    ) {\r\n        super();\r\n\r\n        this._data = new BehaviorSubject<T[]>(initialData);\r\n    }\r\n\r\n    connect(collectionViewer: CollectionViewer): Observable<F[]> {\r\n        return merge(\r\n            collectionViewer.viewChange,\r\n            this.treeControl.expansionModel.changed\r\n                .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Expansion, value }))),\r\n            this.treeControl.filterValue\r\n                .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Filter, value }))),\r\n            this.flattenedData\r\n        )\r\n        .pipe(map((changeObj: any): any => {\r\n            if (changeObj.type === McTreeDataSourceChangeTypes.Filter) {\r\n                if (changeObj.value && changeObj.value.length > 0) {\r\n                    return this.filterHandler();\r\n                } else {\r\n                    return this.expansionHandler(changeObj.value);\r\n                }\r\n            }\r\n\r\n            return this.expansionHandler(changeObj.value);\r\n        }));\r\n    }\r\n\r\n    filterHandler(): F[] {\r\n        this.filteredData.next(this.treeControl.filterModel.selected);\r\n\r\n        return this.filteredData.value;\r\n    }\r\n\r\n    expansionHandler(_change: SelectionChange<F>): F[] {\r\n        const expandedNodes = this.treeFlattener.expandFlattenedNodes(this.flattenedData.value, this.treeControl);\r\n        this.expandedData.next(expandedNodes);\r\n\r\n        return this.expandedData.value;\r\n    }\r\n\r\n    disconnect() {\r\n        // no op\r\n    }\r\n}\r\n\r\n"]}
+import { DataSource } from '@angular/cdk/collections';
+import { BehaviorSubject, merge } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+/**
+ * Tree flattener to convert a normal type of node to node with children & level information.
+ * Transform nested nodes of type `T` to flattened nodes of type `F`.
+ *
+ * For example, the input data of type `T` is nested, and contains its children data:
+ *   SomeNode: {
+ *     key: 'Fruits',
+ *     children: [
+ *       NodeOne: {
+ *         key: 'Apple',
+ *       },
+ *       NodeTwo: {
+ *        key: 'Pear',
+ *      }
+ *    ]
+ *  }
+ *  After flattener flatten the tree, the structure will become
+ *  SomeNode: {
+ *    key: 'Fruits',
+ *    expandable: true,
+ *    level: 1
+ *  },
+ *  NodeOne: {
+ *    key: 'Apple',
+ *    expandable: false,
+ *    level: 2
+ *  },
+ *  NodeTwo: {
+ *   key: 'Pear',
+ *   expandable: false,
+ *   level: 2
+ * }
+ * and the output flattened type is `F` with additional information.
+ */
+export class McTreeFlattener {
+    constructor(transformFunction, getLevel, isExpandable, getChildren) {
+        this.transformFunction = transformFunction;
+        this.getLevel = getLevel;
+        this.isExpandable = isExpandable;
+        this.getChildren = getChildren;
+    }
+    flattenNode(node, level, resultNodes, parent) {
+        const flatNode = this.transformFunction(node, level, parent);
+        resultNodes.push(flatNode);
+        if (this.isExpandable(flatNode)) {
+            const childrenNodes = this.getChildren(node);
+            if (childrenNodes) {
+                if (Array.isArray(childrenNodes)) {
+                    this.flattenChildren(childrenNodes, level, resultNodes, flatNode);
+                }
+                else {
+                    childrenNodes
+                        .pipe(take(1))
+                        .subscribe((children) => {
+                        this.flattenChildren(children, level, resultNodes, flatNode);
+                    });
+                }
+            }
+        }
+        return resultNodes;
+    }
+    flattenChildren(children, level, resultNodes, parent) {
+        children.forEach((child) => {
+            this.flattenNode(child, level + 1, resultNodes, parent);
+        });
+    }
+    /**
+     * Flatten a list of node type T to flattened version of node F.
+     * Please note that type T may be nested, and the length of `structuredData` may be different
+     * from that of returned list `F[]`.
+     */
+    flattenNodes(structuredData) {
+        const resultNodes = [];
+        structuredData.forEach((node) => this.flattenNode(node, 0, resultNodes, null));
+        return resultNodes;
+    }
+    /**
+     * Expand flattened node with current expansion status.
+     * The returned list may have different length.
+     */
+    expandFlattenedNodes(nodes, treeControl) {
+        const results = [];
+        const currentExpand = [];
+        currentExpand[0] = true;
+        nodes.forEach((node) => {
+            let expand = true;
+            for (let i = 0; i <= this.getLevel(node); i++) {
+                expand = expand && currentExpand[i];
+            }
+            if (expand) {
+                results.push(node);
+            }
+            if (this.isExpandable(node)) {
+                currentExpand[this.getLevel(node) + 1] = treeControl.isExpanded(node);
+            }
+        });
+        return results;
+    }
+}
+var McTreeDataSourceChangeTypes;
+(function (McTreeDataSourceChangeTypes) {
+    McTreeDataSourceChangeTypes["Expansion"] = "expansion";
+    McTreeDataSourceChangeTypes["Filter"] = "filter";
+})(McTreeDataSourceChangeTypes || (McTreeDataSourceChangeTypes = {}));
+/**
+ * Data source for flat tree.
+ * The data source need to handle expansion/collapsion of the tree node and change the data feed
+ * to `McTree`.
+ * The nested tree nodes of type `T` are flattened through `MсTreeFlattener`, and converted
+ * to type `F` for `McTree` to consume.
+ */
+export class McTreeFlatDataSource extends DataSource {
+    constructor(treeControl, treeFlattener, initialData = []) {
+        super();
+        this.treeControl = treeControl;
+        this.treeFlattener = treeFlattener;
+        this.flattenedData = new BehaviorSubject([]);
+        this.expandedData = new BehaviorSubject([]);
+        this.filteredData = new BehaviorSubject([]);
+        this._data = new BehaviorSubject(initialData);
+    }
+    get data() {
+        return this._data.value;
+    }
+    set data(value) {
+        this._data.next(value);
+        this.flattenedData.next(this.treeFlattener.flattenNodes(this.data));
+        this.treeControl.dataNodes = this.flattenedData.value;
+    }
+    connect(collectionViewer) {
+        return merge(collectionViewer.viewChange, this.treeControl.expansionModel.changed
+            .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Expansion, value }))), this.treeControl.filterValue
+            .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Filter, value }))), this.flattenedData)
+            .pipe(map((changeObj) => {
+            if (changeObj.type === McTreeDataSourceChangeTypes.Filter) {
+                if (changeObj.value && changeObj.value.length > 0) {
+                    return this.filterHandler();
+                }
+                else {
+                    return this.expansionHandler(changeObj.value);
+                }
+            }
+            return this.expansionHandler(changeObj.value);
+        }));
+    }
+    filterHandler() {
+        this.filteredData.next(this.treeControl.filterModel.selected);
+        return this.filteredData.value;
+    }
+    expansionHandler(_change) {
+        const expandedNodes = this.treeFlattener.expandFlattenedNodes(this.flattenedData.value, this.treeControl);
+        this.expandedData.next(expandedNodes);
+        return this.expandedData.value;
+    }
+    disconnect() {
+        // no op
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flat-data-source.js","sourceRoot":"","sources":["../../../../../packages/mosaic/tree/data-source/flat-data-source.ts"],"names":[],"mappings":"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","sourcesContent":["import { CollectionViewer, DataSource, SelectionChange } from '@angular/cdk/collections';\nimport { BehaviorSubject, merge, Observable } from 'rxjs';\nimport { map, take } from 'rxjs/operators';\n\nimport { FlatTreeControl } from '../control/flat-tree-control';\nimport { TreeControl } from '../control/tree-control';\n\n\n/**\n * Tree flattener to convert a normal type of node to node with children & level information.\n * Transform nested nodes of type `T` to flattened nodes of type `F`.\n *\n * For example, the input data of type `T` is nested, and contains its children data:\n *   SomeNode: {\n *     key: 'Fruits',\n *     children: [\n *       NodeOne: {\n *         key: 'Apple',\n *       },\n *       NodeTwo: {\n *        key: 'Pear',\n *      }\n *    ]\n *  }\n *  After flattener flatten the tree, the structure will become\n *  SomeNode: {\n *    key: 'Fruits',\n *    expandable: true,\n *    level: 1\n *  },\n *  NodeOne: {\n *    key: 'Apple',\n *    expandable: false,\n *    level: 2\n *  },\n *  NodeTwo: {\n *   key: 'Pear',\n *   expandable: false,\n *   level: 2\n * }\n * and the output flattened type is `F` with additional information.\n */\nexport class McTreeFlattener<T, F> {\n    constructor(\n        public transformFunction: (node: T, level: number, parent: F | null) => F,\n        public getLevel: (node: F) => number,\n        public isExpandable: (node: F) => boolean,\n        public getChildren: (node: T) => Observable<T[]> | T[] | undefined | null\n    ) {}\n\n    flattenNode(node: T, level: number, resultNodes: F[], parent: F | null): F[] {\n        const flatNode = this.transformFunction(node, level, parent);\n        resultNodes.push(flatNode);\n\n        if (this.isExpandable(flatNode)) {\n            const childrenNodes = this.getChildren(node);\n\n            if (childrenNodes) {\n                if (Array.isArray(childrenNodes)) {\n                    this.flattenChildren(childrenNodes, level, resultNodes, flatNode);\n                } else {\n                    childrenNodes\n                        .pipe(take(1))\n                        .subscribe((children) => {\n                            this.flattenChildren(children, level, resultNodes, flatNode);\n                        });\n                }\n            }\n        }\n\n        return resultNodes;\n    }\n\n    flattenChildren(children: T[], level: number, resultNodes: F[], parent: F | null): void {\n        children.forEach((child) => {\n            this.flattenNode(child, level + 1, resultNodes, parent);\n        });\n    }\n\n    /**\n     * Flatten a list of node type T to flattened version of node F.\n     * Please note that type T may be nested, and the length of `structuredData` may be different\n     * from that of returned list `F[]`.\n     */\n    flattenNodes(structuredData: T[]): F[] {\n        const resultNodes: F[] = [];\n        structuredData.forEach((node) => this.flattenNode(node, 0, resultNodes, null));\n\n        return resultNodes;\n    }\n\n    /**\n     * Expand flattened node with current expansion status.\n     * The returned list may have different length.\n     */\n    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F>): F[] {\n        const results: F[] = [];\n        const currentExpand: boolean[] = [];\n        currentExpand[0] = true;\n\n        nodes.forEach((node) => {\n            let expand = true;\n            for (let i = 0; i <= this.getLevel(node); i++) {\n                expand = expand && currentExpand[i];\n            }\n\n            if (expand) { results.push(node); }\n\n            if (this.isExpandable(node)) {\n                currentExpand[this.getLevel(node) + 1] = treeControl.isExpanded(node);\n            }\n        });\n\n        return results;\n    }\n}\n\nenum McTreeDataSourceChangeTypes {\n    Expansion = 'expansion',\n    Filter = 'filter'\n}\n\n/**\n * Data source for flat tree.\n * The data source need to handle expansion/collapsion of the tree node and change the data feed\n * to `McTree`.\n * The nested tree nodes of type `T` are flattened through `MсTreeFlattener`, and converted\n * to type `F` for `McTree` to consume.\n */\nexport class McTreeFlatDataSource<T, F> extends DataSource<F> {\n    flattenedData = new BehaviorSubject<F[]>([]);\n\n    expandedData = new BehaviorSubject<F[]>([]);\n\n    filteredData = new BehaviorSubject<F[]>([]);\n\n    get data() {\n        return this._data.value;\n    }\n\n    set data(value: T[]) {\n        this._data.next(value);\n\n        this.flattenedData.next(this.treeFlattener.flattenNodes(this.data));\n        this.treeControl.dataNodes = this.flattenedData.value;\n    }\n\n    private _data: BehaviorSubject<T[]>;\n\n    constructor(\n        private treeControl: FlatTreeControl<F>,\n        private treeFlattener: McTreeFlattener<T, F>,\n        initialData: T[] = []\n    ) {\n        super();\n\n        this._data = new BehaviorSubject<T[]>(initialData);\n    }\n\n    connect(collectionViewer: CollectionViewer): Observable<F[]> {\n        return merge(\n            collectionViewer.viewChange,\n            this.treeControl.expansionModel.changed\n                .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Expansion, value }))),\n            this.treeControl.filterValue\n                .pipe(map((value) => ({ type: McTreeDataSourceChangeTypes.Filter, value }))),\n            this.flattenedData\n        )\n        .pipe(map((changeObj: any): any => {\n            if (changeObj.type === McTreeDataSourceChangeTypes.Filter) {\n                if (changeObj.value && changeObj.value.length > 0) {\n                    return this.filterHandler();\n                } else {\n                    return this.expansionHandler(changeObj.value);\n                }\n            }\n\n            return this.expansionHandler(changeObj.value);\n        }));\n    }\n\n    filterHandler(): F[] {\n        this.filteredData.next(this.treeControl.filterModel.selected);\n\n        return this.filteredData.value;\n    }\n\n    expansionHandler(_change: SelectionChange<F>): F[] {\n        const expandedNodes = this.treeFlattener.expandFlattenedNodes(this.flattenedData.value, this.treeControl);\n        this.expandedData.next(expandedNodes);\n\n        return this.expandedData.value;\n    }\n\n    disconnect() {\n        // no op\n    }\n}\n\n"]}

package/esm2020/tree/data-source/nested-data-source.mjs

@@ -1,30 +1,30 @@
-import { DataSource } from '@angular/cdk/collections';
-import { BehaviorSubject, merge } from 'rxjs';
-import { map } from 'rxjs/operators';
-/**
- * Data source for nested tree.
- *
- * The data source for nested tree doesn't have to consider node flattener, or the way to expand
- * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
- */
-export class McTreeNestedDataSource extends DataSource {
-    constructor() {
-        super(...arguments);
-        /* tslint:disable-next-line:naming-convention */
-        this._data = new BehaviorSubject([]);
-    }
-    get data() {
-        return this._data.value;
-    }
-    set data(value) {
-        this._data.next(value);
-    }
-    connect(collectionViewer) {
-        return merge(...[collectionViewer.viewChange, this._data])
-            .pipe(map(() => this.data));
-    }
-    disconnect() {
-        // no op
-    }
-}
-//# sourceMappingURL=data:application/json;base64,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
+import { DataSource } from '@angular/cdk/collections';
+import { BehaviorSubject, merge } from 'rxjs';
+import { map } from 'rxjs/operators';
+/**
+ * Data source for nested tree.
+ *
+ * The data source for nested tree doesn't have to consider node flattener, or the way to expand
+ * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
+ */
+export class McTreeNestedDataSource extends DataSource {
+    constructor() {
+        super(...arguments);
+        /* tslint:disable-next-line:naming-convention */
+        this._data = new BehaviorSubject([]);
+    }
+    get data() {
+        return this._data.value;
+    }
+    set data(value) {
+        this._data.next(value);
+    }
+    connect(collectionViewer) {
+        return merge(...[collectionViewer.viewChange, this._data])
+            .pipe(map(() => this.data));
+    }
+    disconnect() {
+        // no op
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmVzdGVkLWRhdGEtc291cmNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbW9zYWljL3RyZWUvZGF0YS1zb3VyY2UvbmVzdGVkLWRhdGEtc291cmNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBb0IsVUFBVSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDeEUsT0FBTyxFQUFFLGVBQWUsRUFBRSxLQUFLLEVBQWMsTUFBTSxNQUFNLENBQUM7QUFDMUQsT0FBTyxFQUFFLEdBQUcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBR3JDOzs7OztHQUtHO0FBQ0gsTUFBTSxPQUFPLHNCQUEwQixTQUFRLFVBQWE7SUFBNUQ7O1FBVUksZ0RBQWdEO1FBQ3hDLFVBQUssR0FBRyxJQUFJLGVBQWUsQ0FBTSxFQUFFLENBQUMsQ0FBQztJQVVqRCxDQUFDO0lBbkJHLElBQUksSUFBSTtRQUNKLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUM7SUFDNUIsQ0FBQztJQUVELElBQUksSUFBSSxDQUFDLEtBQVU7UUFDZixJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMzQixDQUFDO0lBS0QsT0FBTyxDQUFDLGdCQUFrQztRQUN0QyxPQUFPLEtBQUssQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsVUFBVSxFQUFFLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQzthQUNyRCxJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7SUFFRCxVQUFVO1FBQ04sUUFBUTtJQUNaLENBQUM7Q0FDSiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbGxlY3Rpb25WaWV3ZXIsIERhdGFTb3VyY2UgfSBmcm9tICdAYW5ndWxhci9jZGsvY29sbGVjdGlvbnMnO1xuaW1wb3J0IHsgQmVoYXZpb3JTdWJqZWN0LCBtZXJnZSwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgbWFwIH0gZnJvbSAncnhqcy9vcGVyYXRvcnMnO1xuXG5cbi8qKlxuICogRGF0YSBzb3VyY2UgZm9yIG5lc3RlZCB0cmVlLlxuICpcbiAqIFRoZSBkYXRhIHNvdXJjZSBmb3IgbmVzdGVkIHRyZWUgZG9lc24ndCBoYXZlIHRvIGNvbnNpZGVyIG5vZGUgZmxhdHRlbmVyLCBvciB0aGUgd2F5IHRvIGV4cGFuZFxuICogb3IgY29sbGFwc2UuIFRoZSBleHBhbnNpb24vY29sbGFwc2lvbiB3aWxsIGJlIGhhbmRsZWQgYnkgVHJlZUNvbnRyb2wgYW5kIGVhY2ggbm9uLWxlYWYgbm9kZS5cbiAqL1xuZXhwb3J0IGNsYXNzIE1jVHJlZU5lc3RlZERhdGFTb3VyY2U8VD4gZXh0ZW5kcyBEYXRhU291cmNlPFQ+IHtcblxuICAgIGdldCBkYXRhKCkge1xuICAgICAgICByZXR1cm4gdGhpcy5fZGF0YS52YWx1ZTtcbiAgICB9XG5cbiAgICBzZXQgZGF0YSh2YWx1ZTogVFtdKSB7XG4gICAgICAgIHRoaXMuX2RhdGEubmV4dCh2YWx1ZSk7XG4gICAgfVxuXG4gICAgLyogdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOm5hbWluZy1jb252ZW50aW9uICovXG4gICAgcHJpdmF0ZSBfZGF0YSA9IG5ldyBCZWhhdmlvclN1YmplY3Q8VFtdPihbXSk7XG5cbiAgICBjb25uZWN0KGNvbGxlY3Rpb25WaWV3ZXI6IENvbGxlY3Rpb25WaWV3ZXIpOiBPYnNlcnZhYmxlPFRbXT4ge1xuICAgICAgICByZXR1cm4gbWVyZ2UoLi4uW2NvbGxlY3Rpb25WaWV3ZXIudmlld0NoYW5nZSwgdGhpcy5fZGF0YV0pXG4gICAgICAgICAgICAucGlwZShtYXAoKCkgPT4gdGhpcy5kYXRhKSk7XG4gICAgfVxuXG4gICAgZGlzY29ubmVjdCgpIHtcbiAgICAgICAgLy8gbm8gb3BcbiAgICB9XG59XG5cbiJdfQ==

package/esm2020/tree/index.mjs

@@ -1,2 +1,2 @@
-export * from './public-api';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9tb3NhaWMvdHJlZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XHJcbiJdfQ==
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9tb3NhaWMvdHJlZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=