@ptsecurity/mosaic 12.0.2 → 12.2.2

package/esm2015/tree/control/flat-tree-control.js

@@ -0,0 +1,123 @@
+import { BaseTreeControl } from './base-tree-control';
+export function defaultCompareValues(firstValue, secondValue) {
+    return firstValue === secondValue;
+}
+export function defaultCompareViewValues(firstViewValue, secondViewValue) {
+    return RegExp(secondViewValue, 'gi').test(firstViewValue);
+}
+/** Flat tree control. Able to expand/collapse a subtree recursively for flattened tree. */
+export class FlatTreeControl extends BaseTreeControl {
+    /** Construct with flat tree data node functions getLevel, isExpandable, getValue and getViewValue. */
+    constructor(getLevel, isExpandable, 
+    /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */
+    getValue, 
+    /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */
+    getViewValue, 
+    /** compareValues will be used to comparing values. */
+    compareValues = defaultCompareValues, 
+    /** compareValues will be used to comparing values. */
+    compareViewValues = defaultCompareViewValues) {
+        super();
+        this.getLevel = getLevel;
+        this.isExpandable = isExpandable;
+        this.getValue = getValue;
+        this.getViewValue = getViewValue;
+        this.compareValues = compareValues;
+        this.compareViewValues = compareViewValues;
+    }
+    /**
+     * Gets a list of the data node's subtree of descendent data nodes.
+     *
+     * To make this working, the `dataNodes` of the TreeControl must be flattened tree nodes
+     * with correct levels.
+     */
+    getDescendants(dataNode) {
+        const startIndex = this.dataNodes.indexOf(dataNode);
+        const results = [];
+        // Goes through flattened tree nodes in the `dataNodes` array, and get all descendants.
+        // The level of descendants of a tree node must be greater than the level of the given
+        // tree node.
+        // If we reach a node whose level is equal to the level of the tree node, we hit a sibling.
+        // If we reach a node whose level is greater than the level of the tree node, we hit a
+        // sibling of an ancestor.
+        for (let i = startIndex + 1; i < this.dataNodes.length && this.getLevel(dataNode) < this.getLevel(this.dataNodes[i]); i++) {
+            results.push(this.dataNodes[i]);
+        }
+        return results;
+    }
+    /**
+     * Expands all data nodes in the tree.
+     *
+     * To make this working, the `dataNodes` variable of the TreeControl must be set to all flattened
+     * data nodes of the tree.
+     */
+    expandAll() {
+        this.expansionModel.select(...this.dataNodes);
+    }
+    getParents(node, result) {
+        if (node.parent) {
+            result.unshift(node.parent);
+            return this.getParents(node.parent, result);
+        }
+        else {
+            return result;
+        }
+    }
+    hasValue(value) {
+        return this.dataNodes.find((node) => this.compareValues(this.getValue(node), value));
+    }
+    filterNodes(value) {
+        this.saveExpansionState();
+        this.filterModel.clear();
+        this.expansionModel.clear();
+        const filteredNodes = this.dataNodes
+            .filter((node) => this.compareViewValues(this.getViewValue(node), value));
+        const filteredNodesWithTheirParents = new Set();
+        filteredNodes.forEach((filteredNode) => {
+            this.getParents(filteredNode, [])
+                .forEach((node) => {
+                filteredNodesWithTheirParents.add(node);
+                this.expandDataNode(node);
+            });
+            filteredNodesWithTheirParents.add(filteredNode);
+            this.expandDataNode(filteredNode);
+            if (this.isExpandable(filteredNode)) {
+                const childNodeLevel = this.getLevel(filteredNode) + 1;
+                this.getDescendants(filteredNode)
+                    .filter((childNode) => this.getLevel(childNode) === childNodeLevel)
+                    .filter((childNode) => !this.isExpandable(childNode) || !this.hasFilteredDescendant(childNode, filteredNodes))
+                    .forEach((childNode) => {
+                    filteredNodesWithTheirParents.add(childNode);
+                    this.expandDataNode(childNode);
+                });
+            }
+        });
+        this.filterModel.select(...Array.from(filteredNodesWithTheirParents));
+        this.filterValue.next(value);
+        this.restoreExpansionState();
+    }
+    expandDataNode(dataNode) {
+        if (this.isExpandable(dataNode)) {
+            this.expansionModel.select(dataNode);
+        }
+    }
+    saveExpansionState() {
+        if (this.filterValue.value === '') {
+            this.expandedItemsBeforeFiltration = this.expansionModel.selected;
+        }
+    }
+    restoreExpansionState() {
+        if (this.filterValue.value === '') {
+            this.expansionModel.clear();
+            this.expansionModel.select(...this.expandedItemsBeforeFiltration);
+        }
+    }
+    hasFilteredDescendant(dataNode, filteredNodes) {
+        const filteredViewValues = filteredNodes
+            .map((node) => this.getViewValue(node));
+        return this.getDescendants(dataNode)
+            .filter((node) => filteredViewValues.includes(this.getViewValue(node)))
+            .length > 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flat-tree-control.js","sourceRoot":"","sources":["../../../../../packages/mosaic/tree/control/flat-tree-control.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGtD,MAAM,UAAU,oBAAoB,CAAC,UAAU,EAAE,WAAW;IACxD,OAAO,UAAU,KAAK,WAAW,CAAC;AACtC,CAAC;AAED,MAAM,UAAU,wBAAwB,CAAC,cAAc,EAAE,eAAe;IACpE,OAAO,MAAM,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;AAC9D,CAAC;AAED,2FAA2F;AAC3F,MAAM,OAAO,eAAmB,SAAQ,eAAkB;IAGtD,sGAAsG;IACtG,YACW,QAAiC,EACjC,YAAsC;IAC7C,oGAAoG;IAC7F,QAA2B;IAClC,+GAA+G;IACxG,YAAkC;IACzC,sDAAsD;IAC/C,gBAAsD,oBAAoB;IACjF,sDAAsD;IAC/C,oBAAkE,wBAAwB;QAEjG,KAAK,EAAE,CAAC;QAXD,aAAQ,GAAR,QAAQ,CAAyB;QACjC,iBAAY,GAAZ,YAAY,CAA0B;QAEtC,aAAQ,GAAR,QAAQ,CAAmB;QAE3B,iBAAY,GAAZ,YAAY,CAAsB;QAElC,kBAAa,GAAb,aAAa,CAA6D;QAE1E,sBAAiB,GAAjB,iBAAiB,CAAyE;IAGrG,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,QAAW;QACtB,MAAM,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACpD,MAAM,OAAO,GAAQ,EAAE,CAAC;QAExB,uFAAuF;QACvF,sFAAsF;QACtF,aAAa;QACb,2FAA2F;QAC3F,sFAAsF;QACtF,0BAA0B;QAC1B,KAAK,IAAI,CAAC,GAAG,UAAU,GAAG,CAAC,EACtB,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,IAAI,IAAI,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EACvF,CAAC,EAAE,EACN;YACE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;SACnC;QAED,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;;;;OAKG;IACH,SAAS;QACL,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED,UAAU,CAAC,IAAS,EAAE,MAAW;QAC7B,IAAI,IAAI,CAAC,MAAM,EAAE;YACb,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YAE5B,OAAO,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;SAC/C;aAAM;YACH,OAAO,MAAM,CAAC;SACjB;IACL,CAAC;IAED,QAAQ,CAAC,KAAa;QAClB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;IAC9F,CAAC;IAED,WAAW,CAAC,KAAa;QACrB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;QAE5B,MAAM,aAAa,GAAG,IAAI,CAAC,SAAS;aAC/B,MAAM,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC;QAEnF,MAAM,6BAA6B,GAAG,IAAI,GAAG,EAAE,CAAC;QAEhD,aAAa,CAAC,OAAO,CAAC,CAAC,YAAY,EAAE,EAAE;YAEnC,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE,EAAE,CAAC;iBAC5B,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBACd,6BAA6B,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;gBAExC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;YAC9B,CAAC,CAAC,CAAC;YAEP,6BAA6B,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAChD,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC,CAAC;YAElC,IAAI,IAAI,CAAC,YAAY,CAAC,YAAY,CAAC,EAAE;gBACjC,MAAM,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,YAAY,CAAC,GAAG,CAAC,CAAC;gBAEvD,IAAI,CAAC,cAAc,CAAC,YAAY,CAAC;qBAC5B,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,SAAS,CAAC,KAAK,cAAc,CAAC;qBAClE,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;qBAC7G,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;oBACnB,6BAA6B,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;oBAE7C,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;gBACnC,CAAC,CAAC,CAAC;aACV;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,6BAA6B,CAAO,CAAC,CAAC;QAE5E,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAE7B,IAAI,CAAC,qBAAqB,EAAE,CAAC;IACjC,CAAC;IAEO,cAAc,CAAC,QAAW;QAC9B,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;YAC7B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;SACxC;IACL,CAAC;IAEO,kBAAkB;QACtB,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,KAAK,EAAE,EAAE;YAC/B,IAAI,CAAC,6BAA6B,GAAG,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC;SACrE;IACL,CAAC;IAEO,qBAAqB;QACzB,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,KAAK,EAAE,EAAE;YAC/B,IAAI,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC;YAC5B,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC,6BAA6B,CAAC,CAAC;SACrE;IACL,CAAC;IAEO,qBAAqB,CAAC,QAAW,EAAE,aAAkB;QACzD,MAAM,kBAAkB,GAAG,aAAa;aACnC,GAAG,CAAC,CAAC,IAAS,EAAE,EAAE,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;QAEjD,OAAO,IAAI,CAAC,cAAc,CAAC,QAAQ,CAAC;aAC/B,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,kBAAkB,CAAC,QAAQ,CAAC,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC;aACtE,MAAM,GAAG,CAAC,CAAC;IACpB,CAAC;CACJ","sourcesContent":["import { BaseTreeControl } from './base-tree-control';\n\n\nexport function defaultCompareValues(firstValue, secondValue): boolean {\n    return firstValue === secondValue;\n}\n\nexport function defaultCompareViewValues(firstViewValue, secondViewValue): boolean {\n    return RegExp(secondViewValue, 'gi').test(firstViewValue);\n}\n\n/** Flat tree control. Able to expand/collapse a subtree recursively for flattened tree. */\nexport class FlatTreeControl<T> extends BaseTreeControl<T> {\n    expandedItemsBeforeFiltration: T[];\n\n    /** Construct with flat tree data node functions getLevel, isExpandable, getValue and getViewValue. */\n    constructor(\n        public getLevel: (dataNode: T) => number,\n        public isExpandable: (dataNode: T) => boolean,\n        /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */\n        public getValue: (dataNode) => any,\n        /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */\n        public getViewValue: (dataNode) => string,\n        /** compareValues will be used to comparing values. */\n        public compareValues: (firstValue, secondValue) => boolean = defaultCompareValues,\n        /** compareValues will be used to comparing values. */\n        public compareViewValues: (firstViewValue, secondViewValue) => boolean = defaultCompareViewValues\n    ) {\n        super();\n    }\n\n    /**\n     * Gets a list of the data node's subtree of descendent data nodes.\n     *\n     * To make this working, the `dataNodes` of the TreeControl must be flattened tree nodes\n     * with correct levels.\n     */\n    getDescendants(dataNode: T): T[] {\n        const startIndex = this.dataNodes.indexOf(dataNode);\n        const results: T[] = [];\n\n        // Goes through flattened tree nodes in the `dataNodes` array, and get all descendants.\n        // The level of descendants of a tree node must be greater than the level of the given\n        // tree node.\n        // If we reach a node whose level is equal to the level of the tree node, we hit a sibling.\n        // If we reach a node whose level is greater than the level of the tree node, we hit a\n        // sibling of an ancestor.\n        for (let i = startIndex + 1;\n             i < this.dataNodes.length && this.getLevel(dataNode) < this.getLevel(this.dataNodes[i]);\n             i++\n        ) {\n            results.push(this.dataNodes[i]);\n        }\n\n        return results;\n    }\n\n    /**\n     * Expands all data nodes in the tree.\n     *\n     * To make this working, the `dataNodes` variable of the TreeControl must be set to all flattened\n     * data nodes of the tree.\n     */\n    expandAll(): void {\n        this.expansionModel.select(...this.dataNodes);\n    }\n\n    getParents(node: any, result: T[]): T[] {\n        if (node.parent) {\n            result.unshift(node.parent);\n\n            return this.getParents(node.parent, result);\n        } else {\n            return result;\n        }\n    }\n\n    hasValue(value: string): T | undefined {\n        return this.dataNodes.find((node: any) => this.compareValues(this.getValue(node), value));\n    }\n\n    filterNodes(value: string): void {\n        this.saveExpansionState();\n\n        this.filterModel.clear();\n        this.expansionModel.clear();\n\n        const filteredNodes = this.dataNodes\n            .filter((node: any) => this.compareViewValues(this.getViewValue(node), value));\n\n        const filteredNodesWithTheirParents = new Set();\n\n        filteredNodes.forEach((filteredNode) => {\n\n            this.getParents(filteredNode, [])\n                .forEach((node) => {\n                    filteredNodesWithTheirParents.add(node);\n\n                    this.expandDataNode(node);\n                });\n\n            filteredNodesWithTheirParents.add(filteredNode);\n            this.expandDataNode(filteredNode);\n\n            if (this.isExpandable(filteredNode)) {\n                const childNodeLevel = this.getLevel(filteredNode) + 1;\n\n                this.getDescendants(filteredNode)\n                    .filter((childNode) => this.getLevel(childNode) === childNodeLevel)\n                    .filter((childNode) => !this.isExpandable(childNode) || !this.hasFilteredDescendant(childNode, filteredNodes))\n                    .forEach((childNode) => {\n                        filteredNodesWithTheirParents.add(childNode);\n\n                        this.expandDataNode(childNode);\n                    });\n            }\n        });\n\n        this.filterModel.select(...Array.from(filteredNodesWithTheirParents) as []);\n\n        this.filterValue.next(value);\n\n        this.restoreExpansionState();\n    }\n\n    private expandDataNode(dataNode: T) {\n        if (this.isExpandable(dataNode)) {\n            this.expansionModel.select(dataNode);\n        }\n    }\n\n    private saveExpansionState() {\n        if (this.filterValue.value === '') {\n            this.expandedItemsBeforeFiltration = this.expansionModel.selected;\n        }\n    }\n\n    private restoreExpansionState() {\n        if (this.filterValue.value === '') {\n            this.expansionModel.clear();\n            this.expansionModel.select(...this.expandedItemsBeforeFiltration);\n        }\n    }\n\n    private hasFilteredDescendant(dataNode: T, filteredNodes: T[]) {\n        const filteredViewValues = filteredNodes\n            .map((node: any) => this.getViewValue(node));\n\n        return this.getDescendants(dataNode)\n            .filter((node) => filteredViewValues.includes(this.getViewValue(node)))\n            .length > 0;\n    }\n}\n"]}

package/esm2015/tree/control/nested-tree-control.js

@@ -0,0 +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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

package/esm2015/tree/control/tree-control.js

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

package/esm2015/tree/data-source/flat-data-source.js

@@ -159,4 +159,4 @@ export class McTreeFlatDataSource extends DataSource {
         // 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 } from '@angular/cdk/collections';\nimport { FlatTreeControl, TreeControl } from '@ptsecurity/cdk/tree';\nimport { BehaviorSubject, merge, Observable } from 'rxjs';\nimport { map, take } from 'rxjs/operators';\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();\n                }\n            }\n\n            return this.expansionHandler();\n        }));\n    }\n\n    filterHandler(): F[] {\n        this.filteredData.next(this.treeControl.filterModel.selected);\n\n        return this.filteredData.value;\n    }\n\n    expansionHandler(): 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"]}
+//# 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":"AAAA,OAAO,EAAoB,UAAU,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EAAE,eAAe,EAAE,KAAK,EAAc,MAAM,MAAM,CAAC;AAC1D,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAM3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,MAAM,OAAO,eAAe;IACxB,YACW,iBAAkE,EAClE,QAA6B,EAC7B,YAAkC,EAClC,WAAkE;QAHlE,sBAAiB,GAAjB,iBAAiB,CAAiD;QAClE,aAAQ,GAAR,QAAQ,CAAqB;QAC7B,iBAAY,GAAZ,YAAY,CAAsB;QAClC,gBAAW,GAAX,WAAW,CAAuD;IAC1E,CAAC;IAEJ,WAAW,CAAC,IAAO,EAAE,KAAa,EAAE,WAAgB,EAAE,MAAgB;QAClE,MAAM,QAAQ,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;QAC7D,WAAW,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAE3B,IAAI,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE;YAC7B,MAAM,aAAa,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;YAE7C,IAAI,aAAa,EAAE;gBACf,IAAI,KAAK,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;oBAC9B,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;iBACrE;qBAAM;oBACH,aAAa;yBACR,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;yBACb,SAAS,CAAC,CAAC,QAAQ,EAAE,EAAE;wBACpB,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;oBACjE,CAAC,CAAC,CAAC;iBACV;aACJ;SACJ;QAED,OAAO,WAAW,CAAC;IACvB,CAAC;IAED,eAAe,CAAC,QAAa,EAAE,KAAa,EAAE,WAAgB,EAAE,MAAgB;QAC5E,QAAQ,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE;YACvB,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,KAAK,GAAG,CAAC,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;QAC5D,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;OAIG;IACH,YAAY,CAAC,cAAmB;QAC5B,MAAM,WAAW,GAAQ,EAAE,CAAC;QAC5B,cAAc,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,CAAC,EAAE,WAAW,EAAE,IAAI,CAAC,CAAC,CAAC;QAE/E,OAAO,WAAW,CAAC;IACvB,CAAC;IAED;;;OAGG;IACH,oBAAoB,CAAC,KAAU,EAAE,WAA2B;QACxD,MAAM,OAAO,GAAQ,EAAE,CAAC;QACxB,MAAM,aAAa,GAAc,EAAE,CAAC;QACpC,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;QAExB,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;YACnB,IAAI,MAAM,GAAG,IAAI,CAAC;YAClB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE;gBAC3C,MAAM,GAAG,MAAM,IAAI,aAAa,CAAC,CAAC,CAAC,CAAC;aACvC;YAED,IAAI,MAAM,EAAE;gBAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aAAE;YAEnC,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,EAAE;gBACzB,aAAa,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;aACzE;QACL,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACnB,CAAC;CACJ;AAED,IAAK,2BAGJ;AAHD,WAAK,2BAA2B;IAC5B,sDAAuB,CAAA;IACvB,gDAAiB,CAAA;AACrB,CAAC,EAHI,2BAA2B,KAA3B,2BAA2B,QAG/B;AAED;;;;;;GAMG;AACH,MAAM,OAAO,oBAA2B,SAAQ,UAAa;IAoBzD,YACY,WAA+B,EAC/B,aAAoC,EAC5C,cAAmB,EAAE;QAErB,KAAK,EAAE,CAAC;QAJA,gBAAW,GAAX,WAAW,CAAoB;QAC/B,kBAAa,GAAb,aAAa,CAAuB;QArBhD,kBAAa,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;QAE7C,iBAAY,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;QAE5C,iBAAY,GAAG,IAAI,eAAe,CAAM,EAAE,CAAC,CAAC;QAsBxC,IAAI,CAAC,KAAK,GAAG,IAAI,eAAe,CAAM,WAAW,CAAC,CAAC;IACvD,CAAC;IArBD,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC;IAC5B,CAAC;IAED,IAAI,IAAI,CAAC,KAAU;QACf,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QAEvB,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;QACpE,IAAI,CAAC,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC;IAC1D,CAAC;IAcD,OAAO,CAAC,gBAAkC;QACtC,OAAO,KAAK,CACR,gBAAgB,CAAC,UAAU,EAC3B,IAAI,CAAC,WAAW,CAAC,cAAc,CAAC,OAAO;aAClC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,2BAA2B,CAAC,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EACnF,IAAI,CAAC,WAAW,CAAC,WAAW;aACvB,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,2BAA2B,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,EAChF,IAAI,CAAC,aAAa,CACrB;aACA,IAAI,CAAC,GAAG,CAAC,CAAC,SAAc,EAAO,EAAE;YAC9B,IAAI,SAAS,CAAC,IAAI,KAAK,2BAA2B,CAAC,MAAM,EAAE;gBACvD,IAAI,SAAS,CAAC,KAAK,IAAI,SAAS,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;oBAC/C,OAAO,IAAI,CAAC,aAAa,EAAE,CAAC;iBAC/B;qBAAM;oBACH,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;iBAClC;aACJ;YAED,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACnC,CAAC,CAAC,CAAC,CAAC;IACR,CAAC;IAED,aAAa;QACT,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAE9D,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACnC,CAAC;IAED,gBAAgB;QACZ,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1G,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEtC,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACnC,CAAC;IAED,UAAU;QACN,QAAQ;IACZ,CAAC;CACJ","sourcesContent":["import { CollectionViewer, DataSource } 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();\n                }\n            }\n\n            return this.expansionHandler();\n        }));\n    }\n\n    filterHandler(): F[] {\n        this.filteredData.next(this.treeControl.filterModel.selected);\n\n        return this.filteredData.value;\n    }\n\n    expansionHandler(): 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/esm2015/tree/node.js

@@ -0,0 +1,31 @@
+import { Directive, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Context provided to the tree node component. */
+export class McTreeNodeOutletContext {
+    constructor(data) {
+        this.$implicit = data;
+    }
+}
+/**
+ * Data node definition for the McTree.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+export class McTreeNodeDef {
+    /** @docs-private */
+    constructor(template) {
+        this.template = template;
+    }
+}
+/** @nocollapse */ McTreeNodeDef.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeDef, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNodeDef.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodeDef, selector: "[mcTreeNodeDef]", inputs: { when: ["mcTreeNodeDefWhen", "when"], data: ["mcTreeNode", "data"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeDef, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[mcTreeNodeDef]',
+                    inputs: ['when: mcTreeNodeDefWhen']
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { data: [{
+                type: Input,
+                args: ['mcTreeNode']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/tree/outlet.js

@@ -0,0 +1,15 @@
+import { ChangeDetectorRef, Directive, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class McTreeNodeOutlet {
+    constructor(viewContainer, changeDetectorRef) {
+        this.viewContainer = viewContainer;
+        this.changeDetectorRef = changeDetectorRef;
+    }
+}
+/** @nocollapse */ McTreeNodeOutlet.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeOutlet, deps: [{ token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNodeOutlet.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodeOutlet, selector: "[mcTreeNodeOutlet]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeOutlet, decorators: [{
+            type: Directive,
+            args: [{ selector: '[mcTreeNodeOutlet]' }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3V0bGV0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcGFja2FnZXMvbW9zYWljL3RyZWUvb3V0bGV0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBSS9FLE1BQU0sT0FBTyxnQkFBZ0I7SUFDekIsWUFBbUIsYUFBK0IsRUFBUyxpQkFBb0M7UUFBNUUsa0JBQWEsR0FBYixhQUFhLENBQWtCO1FBQVMsc0JBQWlCLEdBQWpCLGlCQUFpQixDQUFtQjtJQUFHLENBQUM7O2lJQUQxRixnQkFBZ0I7cUhBQWhCLGdCQUFnQjs0RkFBaEIsZ0JBQWdCO2tCQUQ1QixTQUFTO21CQUFDLEVBQUUsUUFBUSxFQUFFLG9CQUFvQixFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ2hhbmdlRGV0ZWN0b3JSZWYsIERpcmVjdGl2ZSwgVmlld0NvbnRhaW5lclJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5cbkBEaXJlY3RpdmUoeyBzZWxlY3RvcjogJ1ttY1RyZWVOb2RlT3V0bGV0XScgfSlcbmV4cG9ydCBjbGFzcyBNY1RyZWVOb2RlT3V0bGV0IHtcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgdmlld0NvbnRhaW5lcjogVmlld0NvbnRhaW5lclJlZiwgcHVibGljIGNoYW5nZURldGVjdG9yUmVmOiBDaGFuZ2VEZXRlY3RvclJlZikge31cbn1cbiJdfQ==

package/esm2015/tree/padding.directive.js

@@ -1,19 +1,54 @@
-import { Directive, Input } from '@angular/core';
-import { CdkTreeNodePadding } from '@ptsecurity/cdk/tree';
+import { Directionality } from '@angular/cdk/bidi';
+import { coerceNumberProperty } from '@angular/cdk/coercion';
+import { Directive, ElementRef, Input, Optional, Renderer2 } from '@angular/core';
+import { TreeSizePaddingLeft } from '@ptsecurity/mosaic/design-tokens';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { McTreeBase, McTreeNode } from './tree-base';
 import * as i0 from "@angular/core";
-export class McTreeNodePadding extends CdkTreeNodePadding {
-    constructor() {
-        super(...arguments);
-        this.baseLeftPadding = 12;
-        this.iconWidth = 20;
-    }
-    get level() { return this._level; }
-    set level(value) { this.setLevelInput(value); }
-    get indent() { return this._indent; }
-    set indent(indent) { this.setIndentInput(indent); }
+import * as i1 from "./tree-base";
+import * as i2 from "@angular/cdk/bidi";
+/** Regex used to split a string on its CSS units. */
+const cssUnitPattern = /([A-Za-z%]+)$/;
+export class McTreeNodePadding {
+    constructor(treeNode, tree, renderer, element, dir) {
+        var _a, _b;
+        this.treeNode = treeNode;
+        this.tree = tree;
+        this.renderer = renderer;
+        this.element = element;
+        this.dir = dir;
+        this._indent = 20;
+        /** CSS units used for the indentation value. */
+        this.indentUnits = 'px';
+        this.baseLeftPadding = parseInt(TreeSizePaddingLeft);
+        this.iconWidth = 24;
+        this.destroyed = new Subject();
+        (_b = (_a = this.dir) === null || _a === void 0 ? void 0 : _a.change) === null || _b === void 0 ? void 0 : _b.pipe(takeUntil(this.destroyed)).subscribe(() => this.setPadding());
+    }
+    get level() {
+        return this._level;
+    }
+    set level(value) {
+        this.setLevelInput(value);
+    }
+    get indent() {
+        return this._indent;
+    }
+    set indent(indent) {
+        this.setIndentInput(indent);
+    }
     get leftPadding() {
         return (this.withIcon ? 0 : this.iconWidth) + this.baseLeftPadding;
     }
+    ngOnInit() {
+        this.withIcon = this.tree.treeControl.isExpandable(this.treeNode.data);
+        this.setPadding();
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
     paddingIndent() {
         const nodeLevel = (this.treeNode.data && this.tree.treeControl.getLevel)
             ? this.tree.treeControl.getLevel(this.treeNode.data)
@@ -21,24 +56,56 @@ export class McTreeNodePadding extends CdkTreeNodePadding {
         const level = this.level || nodeLevel;
         return level > 0 ? `${(level * this._indent) + this.leftPadding}px` : `${this.leftPadding}px`;
     }
-    ngOnInit() {
-        this.withIcon = this.tree.treeControl.isExpandable(this.treeNode.data);
+    /**
+     * This has been extracted to a util because of TS 4 and VE.
+     * View Engine doesn't support property rename inheritance.
+     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+     * @docs-private
+     */
+    setLevelInput(value) {
+        // Set to null as the fallback value so that _setPadding can fall back to the node level if the
+        // consumer set the directive as `mcTreeNodePadding=""`. We still want to take this value if
+        // they set 0 explicitly.
+        this._level = coerceNumberProperty(value, null);
         this.setPadding();
     }
+    /**
+     * This has been extracted to a util because of TS 4 and VE.
+     * View Engine doesn't support property rename inheritance.
+     * TS 4.0 doesn't allow properties to override accessors or vice-versa.
+     * @docs-private
+     */
+    setIndentInput(indent) {
+        let value = indent;
+        let units = 'px';
+        if (typeof indent === 'string') {
+            const parts = indent.split(cssUnitPattern);
+            value = parts[0];
+            units = parts[1] || units;
+        }
+        this.indentUnits = units;
+        this._indent = coerceNumberProperty(value);
+        this.setPadding();
+    }
+    setPadding() {
+        var _a;
+        const padding = this.paddingIndent();
+        const paddingProp = ((_a = this.dir) === null || _a === void 0 ? void 0 : _a.value) === 'rtl' ? 'paddingRight' : 'paddingLeft';
+        this.renderer.setStyle(this.element.nativeElement, paddingProp, padding);
+    }
 }
-/** @nocollapse */ McTreeNodePadding.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodePadding, deps: null, target: i0.ɵɵFactoryTarget.Directive });
-/** @nocollapse */ McTreeNodePadding.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: McTreeNodePadding, selector: "[mcTreeNodePadding]", inputs: { level: ["mcTreeNodePadding", "level"], indent: ["mcTreeNodePaddingIndent", "indent"] }, providers: [{ provide: CdkTreeNodePadding, useExisting: McTreeNodePadding }], usesInheritance: true, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodePadding, decorators: [{
+/** @nocollapse */ McTreeNodePadding.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodePadding, deps: [{ token: i1.McTreeNode }, { token: i1.McTreeBase }, { token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i2.Directionality, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNodePadding.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodePadding, selector: "[mcTreeNodePadding]", inputs: { indent: ["mcTreeNodePaddingIndent", "indent"] }, exportAs: ["mcTreeNodePadding"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodePadding, decorators: [{
             type: Directive,
             args: [{
                     selector: '[mcTreeNodePadding]',
-                    providers: [{ provide: CdkTreeNodePadding, useExisting: McTreeNodePadding }]
+                    exportAs: 'mcTreeNodePadding'
                 }]
-        }], propDecorators: { level: [{
-                type: Input,
-                args: ['mcTreeNodePadding']
-            }], indent: [{
+        }], ctorParameters: function () { return [{ type: i1.McTreeNode }, { type: i1.McTreeBase }, { type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i2.Directionality, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { indent: [{
                 type: Input,
                 args: ['mcTreeNodePaddingIndent']
             }] } });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"padding.directive.js","sourceRoot":"","sources":["../../../../packages/mosaic/tree/padding.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directionality } from '@angular/cdk/bidi';\nimport { coerceNumberProperty } from '@angular/cdk/coercion';\nimport {\n    Directive,\n    ElementRef,\n    Input,\n    OnDestroy,\n    OnInit,\n    Optional,\n    Renderer2\n} from '@angular/core';\nimport { TreeSizePaddingLeft } from '@ptsecurity/mosaic/design-tokens';\nimport { Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { McTreeBase, McTreeNode } from './tree-base';\n\n\n/** Regex used to split a string on its CSS units. */\nconst cssUnitPattern = /([A-Za-z%]+)$/;\n\n\n@Directive({\n    selector: '[mcTreeNodePadding]',\n    exportAs: 'mcTreeNodePadding'\n})\nexport class McTreeNodePadding<T> implements OnInit, OnDestroy {\n    get level(): number {\n        return this._level;\n    }\n\n    set level(value: number) {\n        this.setLevelInput(value);\n    }\n\n    private _level: number;\n\n    @Input('mcTreeNodePaddingIndent')\n    get indent(): number | string {\n        return this._indent;\n    }\n\n    set indent(indent: number | string) {\n        this.setIndentInput(indent);\n    }\n\n    private _indent: number = 20;\n\n    get leftPadding(): number {\n        return (this.withIcon ? 0 : this.iconWidth) + this.baseLeftPadding;\n    }\n\n    /** CSS units used for the indentation value. */\n    indentUnits = 'px';\n\n    baseLeftPadding: number = parseInt(TreeSizePaddingLeft);\n\n    withIcon: boolean;\n    iconWidth: number = 24;\n\n    private destroyed = new Subject<void>();\n\n    constructor(\n        protected treeNode: McTreeNode<T>,\n        protected tree: McTreeBase<T>,\n        private renderer: Renderer2,\n        private element: ElementRef<HTMLElement>,\n        @Optional() private dir: Directionality\n    ) {\n        this.dir?.change?.pipe(takeUntil(this.destroyed))\n            .subscribe(() => this.setPadding());\n    }\n\n    ngOnInit(): void {\n        this.withIcon = this.tree.treeControl.isExpandable(this.treeNode.data);\n\n        this.setPadding();\n    }\n\n    ngOnDestroy() {\n        this.destroyed.next();\n        this.destroyed.complete();\n    }\n\n    paddingIndent(): string | null {\n        const nodeLevel = (this.treeNode.data && this.tree.treeControl.getLevel)\n            ? this.tree.treeControl.getLevel(this.treeNode.data)\n            : 0;\n\n        const level = this.level || nodeLevel;\n\n        return level > 0 ? `${(level * this._indent) + this.leftPadding}px` : `${this.leftPadding}px`;\n    }\n\n    /**\n     * This has been extracted to a util because of TS 4 and VE.\n     * View Engine doesn't support property rename inheritance.\n     * TS 4.0 doesn't allow properties to override accessors or vice-versa.\n     * @docs-private\n     */\n    private setLevelInput(value: number) {\n        // Set to null as the fallback value so that _setPadding can fall back to the node level if the\n        // consumer set the directive as `mcTreeNodePadding=\"\"`. We still want to take this value if\n        // they set 0 explicitly.\n        this._level = coerceNumberProperty(value, null)!;\n        this.setPadding();\n    }\n\n    /**\n     * This has been extracted to a util because of TS 4 and VE.\n     * View Engine doesn't support property rename inheritance.\n     * TS 4.0 doesn't allow properties to override accessors or vice-versa.\n     * @docs-private\n     */\n    private setIndentInput(indent: number | string) {\n        let value = indent;\n        let units = 'px';\n\n        if (typeof indent === 'string') {\n            const parts = indent.split(cssUnitPattern);\n            value = parts[0];\n            units = parts[1] || units;\n        }\n\n        this.indentUnits = units;\n        this._indent = coerceNumberProperty(value);\n        this.setPadding();\n    }\n\n    private setPadding() {\n        const padding = this.paddingIndent();\n        const paddingProp = this.dir?.value === 'rtl' ? 'paddingRight' : 'paddingLeft';\n\n        this.renderer.setStyle(this.element.nativeElement, paddingProp, padding);\n    }\n}\n"]}

package/esm2015/tree/public-api.js

@@ -1,9 +1,16 @@
 export * from './tree.module';
-export * from './node.directive';
+export * from './tree-base';
+export * from './outlet';
+export * from './tree';
+export * from './node';
 export * from './padding.directive';
 export * from './toggle';
 export * from './tree-selection.component';
 export * from './tree-option.component';
+export * from './control/base-tree-control';
+export * from './control/tree-control';
+export * from './control/flat-tree-control';
+export * from './control/nested-tree-control';
 export * from './data-source/flat-data-source';
 export * from './data-source/nested-data-source';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21vc2FpYy90cmVlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsVUFBVSxDQUFDO0FBQ3pCLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx5QkFBeUIsQ0FBQztBQUN4QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsa0NBQWtDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZWUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbm9kZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9wYWRkaW5nLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RvZ2dsZSc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUtc2VsZWN0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUtb3B0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGEtc291cmNlL2ZsYXQtZGF0YS1zb3VyY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhLXNvdXJjZS9uZXN0ZWQtZGF0YS1zb3VyY2UnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21vc2FpYy90cmVlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxhQUFhLENBQUM7QUFDNUIsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxRQUFRLENBQUM7QUFDdkIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsa0NBQWtDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3RyZWUubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJlZS1iYXNlJztcbmV4cG9ydCAqIGZyb20gJy4vb3V0bGV0JztcbmV4cG9ydCAqIGZyb20gJy4vdHJlZSc7XG5leHBvcnQgKiBmcm9tICcuL25vZGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wYWRkaW5nLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RvZ2dsZSc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUtc2VsZWN0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL3RyZWUtb3B0aW9uLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRyb2wvYmFzZS10cmVlLWNvbnRyb2wnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250cm9sL3RyZWUtY29udHJvbCc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnRyb2wvZmxhdC10cmVlLWNvbnRyb2wnO1xuZXhwb3J0ICogZnJvbSAnLi9jb250cm9sL25lc3RlZC10cmVlLWNvbnRyb2wnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhLXNvdXJjZS9mbGF0LWRhdGEtc291cmNlJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1zb3VyY2UvbmVzdGVkLWRhdGEtc291cmNlJztcbiJdfQ==