@ptsecurity/mosaic 12.0.2 → 12.2.2

package/esm2015/tree/toggle.js

@@ -1,13 +1,20 @@
-import { Component, Directive, Input, ViewEncapsulation } from '@angular/core';
-import { CdkTree, CdkTreeNode } from '@ptsecurity/cdk/tree';
+import { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { ChangeDetectionStrategy, Component, Directive, Input, ViewEncapsulation } from '@angular/core';
+import { mixinDisabled } from '@ptsecurity/mosaic/core';
 import { map } from 'rxjs/operators';
+import { McTreeBase, McTreeNode } from './tree-base';
 import * as i0 from "@angular/core";
-import * as i1 from "@ptsecurity/cdk/tree";
-export class McTreeNodeToggleComponent {
+import * as i1 from "./tree-base";
+export class McTreeNodeToggleBase {
+}
+// tslint:disable-next-line:naming-convention
+export const McTreeNodeToggleMixinBase = mixinDisabled(McTreeNodeToggleBase);
+/** @docs-private */
+export class McTreeNodeToggleBaseDirective extends McTreeNodeToggleMixinBase {
     constructor(tree, treeNode) {
+        super();
         this.tree = tree;
         this.treeNode = treeNode;
-        this.disabled = false;
         this._recursive = false;
         this.tree.treeControl.filterValue
             .pipe(map((value) => (value === null || value === void 0 ? void 0 : value.length) > 0))
@@ -17,79 +24,66 @@ export class McTreeNodeToggleComponent {
         return this._recursive;
     }
     set recursive(value) {
-        this._recursive = value;
+        this._recursive = coerceBooleanProperty(value);
     }
     get iconState() {
-        return this.disabled || this.tree.treeControl.isExpanded(this.node);
+        return this.tree.treeControl.isExpanded(this.node);
     }
     toggle(event) {
+        if (this.disabled) {
+            return;
+        }
         this.recursive
             ? this.tree.treeControl.toggleDescendants(this.treeNode.data)
             : this.tree.treeControl.toggle(this.treeNode.data);
         event.stopPropagation();
     }
 }
-/** @nocollapse */ McTreeNodeToggleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodeToggleComponent, deps: [{ token: i1.CdkTree }, { token: i1.CdkTreeNode }], target: i0.ɵɵFactoryTarget.Component });
-/** @nocollapse */ McTreeNodeToggleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.5", type: McTreeNodeToggleComponent, selector: "mc-tree-node-toggle", inputs: { node: "node", recursive: ["cdkTreeNodeToggleRecursive", "recursive"] }, host: { listeners: { "click": "toggle($event)" }, properties: { "class.mc-opened": "iconState", "attr.disabled": "disabled || null" }, classAttribute: "mc-tree-node-toggle" }, ngImport: i0, template: `
-        <i class="mc mc-icon mc-angle-down-S_16"></i>
-    `, isInline: true, encapsulation: i0.ViewEncapsulation.None });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodeToggleComponent, decorators: [{
+/** @nocollapse */ McTreeNodeToggleBaseDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleBaseDirective, deps: [{ token: i1.McTreeBase }, { token: i1.McTreeNode }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNodeToggleBaseDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodeToggleBaseDirective, inputs: { node: "node", recursive: ["mcTreeNodeToggleRecursive", "recursive"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleBaseDirective, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i1.McTreeBase }, { type: i1.McTreeNode }]; }, propDecorators: { node: [{
+                type: Input
+            }], recursive: [{
+                type: Input,
+                args: ['mcTreeNodeToggleRecursive']
+            }] } });
+export class McTreeNodeToggleComponent extends McTreeNodeToggleBaseDirective {
+}
+/** @nocollapse */ McTreeNodeToggleComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleComponent, deps: null, target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ McTreeNodeToggleComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodeToggleComponent, selector: "mc-tree-node-toggle", inputs: { disabled: "disabled" }, host: { listeners: { "click": "toggle($event)" }, properties: { "class.mc-opened": "iconState", "attr.disabled": "disabled || null" }, classAttribute: "mc-tree-node-toggle" }, exportAs: ["mcTreeNodeToggle"], usesInheritance: true, ngImport: i0, template: `<i class="mc mc-icon mc-angle-down-S_16"></i>`, isInline: true, styles: [".mc-tree-node-toggle{display:flex;align-items:center;justify-content:center;flex-shrink:0;width:24px;height:100%;cursor:pointer}.mc-tree-node-toggle .mc-icon{transform:rotate(-90deg)}.mc-tree-node-toggle.mc-opened .mc-icon{transform:rotate(0)}.mc-tree-node-toggle[disabled]{cursor:default}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleComponent, decorators: [{
             type: Component,
             args: [{
                     selector: 'mc-tree-node-toggle',
-                    template: `
-        <i class="mc mc-icon mc-angle-down-S_16"></i>
-    `,
+                    exportAs: 'mcTreeNodeToggle',
+                    template: `<i class="mc mc-icon mc-angle-down-S_16"></i>`,
+                    styleUrls: ['./toggle.scss'],
                     host: {
                         class: 'mc-tree-node-toggle',
                         '[class.mc-opened]': 'iconState',
                         '[attr.disabled]': 'disabled || null',
                         '(click)': 'toggle($event)'
                     },
-                    encapsulation: ViewEncapsulation.None
+                    inputs: ['disabled'],
+                    encapsulation: ViewEncapsulation.None,
+                    changeDetection: ChangeDetectionStrategy.OnPush
                 }]
-        }], ctorParameters: function () { return [{ type: i1.CdkTree }, { type: i1.CdkTreeNode }]; }, propDecorators: { node: [{
-                type: Input
-            }], recursive: [{
-                type: Input,
-                args: ['cdkTreeNodeToggleRecursive']
-            }] } });
-export class McTreeNodeToggleDirective {
-    constructor(tree, treeNode) {
-        this.tree = tree;
-        this.treeNode = treeNode;
-        this.disabled = false;
-        this._recursive = false;
-        this.tree.treeControl.filterValue
-            .pipe(map((value) => value.length > 0))
-            .subscribe((state) => this.disabled = state);
-    }
-    get recursive() {
-        return this._recursive;
-    }
-    set recursive(value) {
-        this._recursive = value;
-    }
-    toggle(event) {
-        this.recursive
-            ? this.tree.treeControl.toggleDescendants(this.treeNode.data)
-            : this.tree.treeControl.toggle(this.treeNode.data);
-        event.stopPropagation();
-    }
+        }] });
+export class McTreeNodeToggleDirective extends McTreeNodeToggleBaseDirective {
 }
-/** @nocollapse */ McTreeNodeToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodeToggleDirective, deps: [{ token: i1.CdkTree }, { token: i1.CdkTreeNode }], target: i0.ɵɵFactoryTarget.Directive });
-/** @nocollapse */ McTreeNodeToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.5", type: McTreeNodeToggleDirective, selector: "[mcTreeNodeToggle]", inputs: { recursive: ["cdkTreeNodeToggleRecursive", "recursive"] }, host: { listeners: { "click": "toggle($event)" }, properties: { "attr.disabled": "disabled || null" } }, ngImport: i0 });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.5", ngImport: i0, type: McTreeNodeToggleDirective, decorators: [{
+/** @nocollapse */ McTreeNodeToggleDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleDirective, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNodeToggleDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNodeToggleDirective, selector: "[mcTreeNodeToggle]", host: { listeners: { "click": "toggle($event)" }, properties: { "attr.disabled": "disabled || null" } }, exportAs: ["mcTreeNodeToggle"], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNodeToggleDirective, decorators: [{
             type: Directive,
             args: [{
                     selector: '[mcTreeNodeToggle]',
+                    exportAs: 'mcTreeNodeToggle',
                     host: {
                         '[attr.disabled]': 'disabled || null',
                         '(click)': 'toggle($event)'
                     }
                 }]
-        }], ctorParameters: function () { return [{ type: i1.CdkTree }, { type: i1.CdkTreeNode }]; }, propDecorators: { recursive: [{
-                type: Input,
-                args: ['cdkTreeNodeToggleRecursive']
-            }] } });
-//# sourceMappingURL=data:application/json;base64,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
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/tree/tree-base.js

@@ -0,0 +1,243 @@
+import { ChangeDetectorRef, ContentChildren, ElementRef, Input, IterableDiffers, QueryList, ViewChild, Inject, forwardRef, Directive } from '@angular/core';
+import { BehaviorSubject, Observable, of as observableOf, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { McTreeNodeDef, McTreeNodeOutletContext } from './node';
+import { McTreeNodeOutlet } from './outlet';
+import { getTreeControlMissingError, getTreeMissingMatchingNodeDefError, getTreeMultipleDefaultNodeDefsError, getTreeNoValidDataSourceError } from './tree-errors';
+import * as i0 from "@angular/core";
+export class McTreeBase {
+    constructor(differs, changeDetectorRef) {
+        this.differs = differs;
+        this.changeDetectorRef = changeDetectorRef;
+        // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.
+        //     Remove the MAX_VALUE in viewChange
+        /**
+         * Stream containing the latest information on what rows are being displayed on screen.
+         * Can be used by the data source to as a heuristic of what data should be provided.
+         */
+        this.viewChange = new BehaviorSubject({ start: 0, end: Number.MAX_VALUE });
+        /** Subject that emits when the component has been destroyed. */
+        this.onDestroy = new Subject();
+        /** Level of nodes */
+        this.levels = new Map();
+    }
+    /**
+     * Provides a stream containing the latest data array to render. Influenced by the tree's
+     * stream of view window (what dataNodes are currently on screen).
+     * Data source can be an observable of data array, or a dara array to render.
+     */
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(dataSource) {
+        if (this._dataSource !== dataSource) {
+            this.switchDataSource(dataSource);
+        }
+    }
+    ngOnInit() {
+        this.dataDiffer = this.differs.find([]).create(this.trackBy);
+        if (!this.treeControl) {
+            throw getTreeControlMissingError();
+        }
+    }
+    ngOnDestroy() {
+        this.nodeOutlet.viewContainer.clear();
+        this.onDestroy.next();
+        this.onDestroy.complete();
+        // tslint:disable-next-line:no-unbound-method
+        if (this._dataSource && typeof this.dataSource.disconnect === 'function') {
+            this.dataSource.disconnect(this);
+        }
+        if (this.dataSubscription) {
+            this.dataSubscription.unsubscribe();
+            this.dataSubscription = null;
+        }
+    }
+    ngAfterContentChecked() {
+        const defaultNodeDefs = this.nodeDefs.filter((def) => !def.when);
+        if (defaultNodeDefs.length > 1) {
+            throw getTreeMultipleDefaultNodeDefsError();
+        }
+        this.defaultNodeDef = defaultNodeDefs[0];
+        if (this.dataSource && this.nodeDefs && !this.dataSubscription) {
+            this.observeRenderChanges();
+        }
+    }
+    /** Check for changes made in the data and render each change (node added/removed/moved). */
+    renderNodeChanges(data, dataDiffer = this.dataDiffer, viewContainer = this.nodeOutlet.viewContainer, parentData) {
+        const changes = dataDiffer.diff(data);
+        if (!changes) {
+            return;
+        }
+        changes.forEachOperation((item, adjustedPreviousIndex, currentIndex) => {
+            if (item.previousIndex == null) {
+                this.insertNode(data[currentIndex], currentIndex, viewContainer, parentData);
+            }
+            else if (currentIndex == null) {
+                viewContainer.remove(adjustedPreviousIndex);
+                this.levels.delete(item.item);
+            }
+            else {
+                const view = viewContainer.get(adjustedPreviousIndex);
+                viewContainer.move(view, currentIndex);
+            }
+        });
+        this.changeDetectorRef.detectChanges();
+    }
+    /**
+     * Finds the matching node definition that should be used for this node data. If there is only
+     * one node definition, it is returned. Otherwise, find the node definition that has a when
+     * predicate that returns true with the data. If none return true, return the default node
+     * definition.
+     */
+    getNodeDef(data, i) {
+        if (this.nodeDefs.length === 1) {
+            return this.nodeDefs.first;
+        }
+        const nodeDef = this.nodeDefs.find((def) => def.when && def.when(i, data)) || this.defaultNodeDef;
+        if (!nodeDef) {
+            throw getTreeMissingMatchingNodeDefError();
+        }
+        return nodeDef;
+    }
+    /**
+     * Create the embedded view for the data node template and place it in the correct index location
+     * within the data node view container.
+     */
+    insertNode(nodeData, index, viewContainer, parentData) {
+        const node = this.getNodeDef(nodeData, index);
+        // Node context that will be provided to created embedded view
+        const context = new McTreeNodeOutletContext(nodeData);
+        // If the tree is flat tree, then use the `getLevel` function in flat tree control
+        // Otherwise, use the level of parent node.
+        if (this.treeControl.getLevel) {
+            context.level = this.treeControl.getLevel(nodeData);
+            /* tslint:disable-next-line:no-typeof-undefined */
+        }
+        else if (typeof parentData !== 'undefined' && this.levels.has(parentData)) {
+            context.level = this.levels.get(parentData) + 1;
+        }
+        else {
+            context.level = 0;
+        }
+        this.levels.set(nodeData, context.level);
+        // Use default tree nodeOutlet, or nested node's nodeOutlet
+        const container = viewContainer ? viewContainer : this.nodeOutlet.viewContainer;
+        container.createEmbeddedView(node.template, context, index);
+        // Set the data to just created `McTreeNode`.
+        // The `McTreeNode` created from `createEmbeddedView` will be saved in static variable
+        //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.
+        if (McTreeNode.mostRecentTreeNode) {
+            McTreeNode.mostRecentTreeNode.data = nodeData;
+        }
+    }
+    /** Set up a subscription for the data provided by the data source. */
+    observeRenderChanges() {
+        let dataStream;
+        // Cannot use `instanceof DataSource` since the data source could be a literal with
+        // `connect` function and may not extends DataSource.
+        // tslint:disable-next-line:no-unbound-method
+        if (typeof this._dataSource.connect === 'function') {
+            dataStream = this._dataSource.connect(this);
+        }
+        else if (this._dataSource instanceof Observable) {
+            dataStream = this._dataSource;
+        }
+        else if (Array.isArray(this._dataSource)) {
+            dataStream = observableOf(this._dataSource);
+        }
+        if (dataStream) {
+            this.dataSubscription = dataStream
+                .pipe(takeUntil(this.onDestroy))
+                .subscribe((data) => this.renderNodeChanges(data));
+        }
+        else {
+            throw getTreeNoValidDataSourceError();
+        }
+    }
+    /**
+     * Switch to the provided data source by resetting the data and unsubscribing from the current
+     * render change subscription if one exists. If the data source is null, interpret this by
+     * clearing the node outlet. Otherwise start listening for new data.
+     */
+    switchDataSource(dataSource) {
+        // tslint:disable-next-line:no-unbound-method
+        if (this._dataSource && typeof this._dataSource.disconnect === 'function') {
+            this.dataSource.disconnect(this);
+        }
+        if (this.dataSubscription) {
+            this.dataSubscription.unsubscribe();
+            this.dataSubscription = null;
+        }
+        // Remove the all dataNodes if there is now no data source
+        if (!dataSource) {
+            this.nodeOutlet.viewContainer.clear();
+        }
+        this._dataSource = dataSource;
+        if (this.nodeDefs) {
+            this.observeRenderChanges();
+        }
+    }
+}
+/** @nocollapse */ McTreeBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeBase, deps: [{ token: i0.IterableDiffers }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeBase, inputs: { treeControl: "treeControl", trackBy: "trackBy", dataSource: "dataSource" }, queries: [{ propertyName: "nodeDefs", predicate: McTreeNodeDef }], viewQueries: [{ propertyName: "nodeOutlet", first: true, predicate: McTreeNodeOutlet, descendants: true, static: true }], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.IterableDiffers }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { treeControl: [{
+                type: Input
+            }], trackBy: [{
+                type: Input
+            }], nodeOutlet: [{
+                type: ViewChild,
+                args: [McTreeNodeOutlet, { static: true }]
+            }], nodeDefs: [{
+                type: ContentChildren,
+                args: [McTreeNodeDef]
+            }], dataSource: [{
+                type: Input
+            }] } });
+export class McTreeNode {
+    constructor(elementRef, tree) {
+        this.elementRef = elementRef;
+        this.tree = tree;
+        this.destroyed = new Subject();
+        McTreeNode.mostRecentTreeNode = this;
+    }
+    get data() {
+        return this._data;
+    }
+    set data(value) {
+        this._data = value;
+    }
+    get isExpanded() {
+        return this.tree.treeControl.isExpanded(this.data);
+    }
+    get level() {
+        return this.tree.treeControl.getLevel ? this.tree.treeControl.getLevel(this._data) : 0;
+    }
+    ngOnDestroy() {
+        this.destroyed.next();
+        this.destroyed.complete();
+    }
+    focus() {
+        this.elementRef.nativeElement.focus();
+    }
+}
+/**
+ * The most recently created `McTreeNode`. We save it in static variable so we can retrieve it
+ * in `McTree` and set the data to it.
+ */
+McTreeNode.mostRecentTreeNode = null;
+/** @nocollapse */ McTreeNode.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNode, deps: [{ token: i0.ElementRef }, { token: forwardRef(() => McTreeBase) }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ McTreeNode.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.13", type: McTreeNode, selector: "mc-tree-node", exportAs: ["mcTreeNode"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.13", ngImport: i0, type: McTreeNode, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'mc-tree-node',
+                    exportAs: 'mcTreeNode'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: McTreeBase, decorators: [{
+                    type: Inject,
+                    args: [forwardRef(() => McTreeBase)]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree-base.js","sourceRoot":"","sources":["../../../../packages/mosaic/tree/tree-base.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,iBAAiB,EACjB,eAAe,EACf,UAAU,EACV,KAAK,EAGL,eAAe,EAGf,SAAS,EACT,SAAS,EAGT,MAAM,EACN,UAAU,EAAE,SAAS,EACxB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,EAAE,IAAI,YAAY,EAAE,OAAO,EAAgB,MAAM,MAAM,CAAC;AAC9F,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,aAAa,EAAE,uBAAuB,EAAE,MAAM,QAAQ,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAC5C,OAAO,EACH,0BAA0B,EAC1B,kCAAkC,EAClC,mCAAmC,EACnC,6BAA6B,EAChC,MAAM,eAAe,CAAC;;AAIvB,MAAM,OAAO,UAAU;IA0DnB,YAAsB,OAAwB,EAAY,iBAAoC;QAAxE,YAAO,GAAP,OAAO,CAAiB;QAAY,sBAAiB,GAAjB,iBAAiB,CAAmB;QAzC9F,6FAA6F;QAC7F,yCAAyC;QACzC;;;WAGG;QACH,eAAU,GAAG,IAAI,eAAe,CAAiC,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QAKtG,gEAAgE;QACxD,cAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;QAQxC,qBAAqB;QACb,WAAM,GAAmB,IAAI,GAAG,EAAa,CAAC;IAoB2C,CAAC;IAlBlG;;;;OAIG;IACH,IACI,UAAU;QACV,OAAO,IAAI,CAAC,WAAW,CAAC;IAC5B,CAAC;IAED,IAAI,UAAU,CAAC,UAAiD;QAC5D,IAAI,IAAI,CAAC,WAAW,KAAK,UAAU,EAAE;YACjC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;SACrC;IACL,CAAC;IAMD,QAAQ;QACJ,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAE7D,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE;YACnB,MAAM,0BAA0B,EAAE,CAAC;SACtC;IACL,CAAC;IAED,WAAW;QACP,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAEtC,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;QAE1B,6CAA6C;QAC7C,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,UAA4B,CAAC,UAAU,KAAK,UAAU,EAAE;YACxF,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SACvD;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACvB,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC;YACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAChC;IACL,CAAC;IAED,qBAAqB;QACjB,MAAM,eAAe,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAEjE,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE;YAC5B,MAAM,mCAAmC,EAAE,CAAC;SAC/C;QACD,IAAI,CAAC,cAAc,GAAG,eAAe,CAAC,CAAC,CAAC,CAAC;QAEzC,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE;YAC5D,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAC/B;IACL,CAAC;IAED,4FAA4F;IAC5F,iBAAiB,CACb,IAA4B,EAC5B,aAAgC,IAAI,CAAC,UAAU,EAC/C,gBAAkC,IAAI,CAAC,UAAU,CAAC,aAAa,EAC/D,UAAc;QAEd,MAAM,OAAO,GAAG,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEtC,IAAI,CAAC,OAAO,EAAE;YAAE,OAAO;SAAE;QAEzB,OAAO,CAAC,gBAAgB,CAAC,CACrB,IAA6B,EAC7B,qBAAoC,EACpC,YAA2B,EAC7B,EAAE;YACA,IAAI,IAAI,CAAC,aAAa,IAAI,IAAI,EAAE;gBAC5B,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,YAAa,CAAC,EAAE,YAAa,EAAE,aAAa,EAAE,UAAU,CAAC,CAAC;aAClF;iBAAM,IAAI,YAAY,IAAI,IAAI,EAAE;gBAC7B,aAAa,CAAC,MAAM,CAAC,qBAAsB,CAAC,CAAC;gBAC7C,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACjC;iBAAM;gBACH,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,CAAC,qBAAsB,CAAC,CAAC;gBACvD,aAAa,CAAC,IAAI,CAAC,IAAK,EAAE,YAAY,CAAC,CAAC;aAC3C;QACL,CAAC,CAAC,CAAC;QAEH,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,IAAO,EAAE,CAAS;QACzB,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;YAAE,OAAO,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC;SAAE;QAE/D,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,IAAI,IAAI,CAAC,cAAc,CAAC;QAElG,IAAI,CAAC,OAAO,EAAE;YAAE,MAAM,kCAAkC,EAAE,CAAC;SAAE;QAE7D,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,UAAU,CAAC,QAAW,EAAE,KAAa,EAAE,aAAgC,EAAE,UAAc;QACnF,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;QAE9C,8DAA8D;QAC9D,MAAM,OAAO,GAAG,IAAI,uBAAuB,CAAI,QAAQ,CAAC,CAAC;QAEzD,kFAAkF;QAClF,2CAA2C;QAC3C,IAAI,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE;YAC3B,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;YACpD,kDAAkD;SACrD;aAAM,IAAI,OAAO,UAAU,KAAK,WAAW,IAAI,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE;YACzE,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,UAAU,CAAE,GAAG,CAAC,CAAC;SACpD;aAAM;YACH,OAAO,CAAC,KAAK,GAAG,CAAC,CAAC;SACrB;QAED,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;QAEzC,2DAA2D;QAC3D,MAAM,SAAS,GAAG,aAAa,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QAChF,SAAS,CAAC,kBAAkB,CAAC,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC;QAE5D,6CAA6C;QAC7C,sFAAsF;QACtF,yFAAyF;QACzF,IAAI,UAAU,CAAC,kBAAkB,EAAE;YAC/B,UAAU,CAAC,kBAAkB,CAAC,IAAI,GAAG,QAAQ,CAAC;SACjD;IACL,CAAC;IAED,sEAAsE;IAC9D,oBAAoB;QACxB,IAAI,UAA0D,CAAC;QAE/D,mFAAmF;QACnF,qDAAqD;QACrD,6CAA6C;QAC7C,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,OAAO,KAAK,UAAU,EAAE;YACnE,UAAU,GAAI,IAAI,CAAC,WAA6B,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;SAClE;aAAM,IAAI,IAAI,CAAC,WAAW,YAAY,UAAU,EAAE;YAC/C,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC;SACjC;aAAM,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE;YACxC,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;SAC/C;QAED,IAAI,UAAU,EAAE;YACZ,IAAI,CAAC,gBAAgB,GAAG,UAAU;iBAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBAC/B,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC;SAC1D;aAAM;YACH,MAAM,6BAA6B,EAAE,CAAC;SACzC;IACL,CAAC;IAED;;;;OAIG;IACK,gBAAgB,CAAC,UAAiD;QACtE,6CAA6C;QAC7C,IAAI,IAAI,CAAC,WAAW,IAAI,OAAQ,IAAI,CAAC,WAA6B,CAAC,UAAU,KAAK,UAAU,EAAE;YACzF,IAAI,CAAC,UAA4B,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;SACvD;QAED,IAAI,IAAI,CAAC,gBAAgB,EAAE;YACvB,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,CAAC;YACpC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC;SAChC;QAED,0DAA0D;QAC1D,IAAI,CAAC,UAAU,EAAE;YAAE,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;SAAE;QAE3D,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;QAE9B,IAAI,IAAI,CAAC,QAAQ,EAAE;YAAE,IAAI,CAAC,oBAAoB,EAAE,CAAC;SAAE;IACvD,CAAC;;2HAjOQ,UAAU;+GAAV,UAAU,yIAeF,aAAa,yEAHnB,gBAAgB;4FAZlB,UAAU;kBADtB,SAAS;sIAEG,WAAW;sBAAnB,KAAK;gBAQG,OAAO;sBAAf,KAAK;gBAGyC,UAAU;sBAAxD,SAAS;uBAAC,gBAAgB,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAGb,QAAQ;sBAAvC,eAAe;uBAAC,aAAa;gBA+B1B,UAAU;sBADb,KAAK;;AA4LV,MAAM,OAAO,UAAU;IA2BnB,YACc,UAAsB,EACa,IAAmB;QADtD,eAAU,GAAV,UAAU,CAAY;QACa,SAAI,GAAJ,IAAI,CAAe;QAtB1D,cAAS,GAAG,IAAI,OAAO,EAAQ,CAAC;QAwBtC,UAAU,CAAC,kBAAkB,GAAG,IAAI,CAAC;IACzC,CAAC;IAvBD,IAAI,IAAI;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC;IACtB,CAAC;IAED,IAAI,IAAI,CAAC,KAAQ;QACb,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACvB,CAAC;IAID,IAAI,UAAU;QACV,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,KAAK;QACL,OAAO,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3F,CAAC;IASD,WAAW;QACP,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;QACtB,IAAI,CAAC,SAAS,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;IAED,KAAK;QACD,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC1C,CAAC;;AAxCD;;;GAGG;AACI,6BAAkB,GAA2B,IAAI,CAAC;2HALhD,UAAU,4CA6BP,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC;+GA7B/B,UAAU;4FAAV,UAAU;kBAJtB,SAAS;mBAAC;oBACP,QAAQ,EAAE,cAAc;oBACxB,QAAQ,EAAE,YAAY;iBACzB;mFA8B0D,UAAU;0BAA5D,MAAM;2BAAC,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC","sourcesContent":["import { CollectionViewer, DataSource } from '@angular/cdk/collections';\nimport {\n    AfterContentChecked,\n    ChangeDetectorRef,\n    ContentChildren,\n    ElementRef,\n    Input,\n    IterableChangeRecord,\n    IterableDiffer,\n    IterableDiffers,\n    OnDestroy,\n    OnInit,\n    QueryList,\n    ViewChild,\n    ViewContainerRef,\n    TrackByFunction,\n    Inject,\n    forwardRef, Directive\n} from '@angular/core';\nimport { IFocusableOption } from '@ptsecurity/cdk/a11y';\nimport { BehaviorSubject, Observable, of as observableOf, Subject, Subscription } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport { TreeControl } from './control/tree-control';\nimport { McTreeNodeDef, McTreeNodeOutletContext } from './node';\nimport { McTreeNodeOutlet } from './outlet';\nimport {\n    getTreeControlMissingError,\n    getTreeMissingMatchingNodeDefError,\n    getTreeMultipleDefaultNodeDefsError,\n    getTreeNoValidDataSourceError\n} from './tree-errors';\n\n\n@Directive()\nexport class McTreeBase<T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {\n    @Input() treeControl: TreeControl<T>;\n\n    /**\n     * Tracking function that will be used to check the differences in data changes. Used similarly\n     * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data\n     * relative to the function to know if a node should be added/removed/moved.\n     * Accepts a function that takes two parameters, `index` and `item`.\n     */\n    @Input() trackBy: TrackByFunction<T>;\n\n    // Outlets within the tree's template where the dataNodes will be inserted.\n    @ViewChild(McTreeNodeOutlet, { static: true }) nodeOutlet: McTreeNodeOutlet;\n\n    /** The tree node template for the tree */\n    @ContentChildren(McTreeNodeDef) nodeDefs: QueryList<McTreeNodeDef<T>>;\n\n    // TODO(tinayuangao): Setup a listener for scrolling, emit the calculated view to viewChange.\n    //     Remove the MAX_VALUE in viewChange\n    /**\n     * Stream containing the latest information on what rows are being displayed on screen.\n     * Can be used by the data source to as a heuristic of what data should be provided.\n     */\n    viewChange = new BehaviorSubject<{ start: number; end: number }>({ start: 0, end: Number.MAX_VALUE });\n\n    /** Differ used to find the changes in the data provided by the data source. */\n    protected dataDiffer: IterableDiffer<T>;\n\n    /** Subject that emits when the component has been destroyed. */\n    private onDestroy = new Subject<void>();\n\n    /** Stores the node definition that does not have a when predicate. */\n    private defaultNodeDef: McTreeNodeDef<T> | null;\n\n    /** Data subscription */\n    private dataSubscription: Subscription | null;\n\n    /** Level of nodes */\n    private levels: Map<T, number> = new Map<T, number>();\n\n    /**\n     * Provides a stream containing the latest data array to render. Influenced by the tree's\n     * stream of view window (what dataNodes are currently on screen).\n     * Data source can be an observable of data array, or a dara array to render.\n     */\n    @Input()\n    get dataSource(): DataSource<T> | Observable<T[]> | T[] {\n        return this._dataSource;\n    }\n\n    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n        if (this._dataSource !== dataSource) {\n            this.switchDataSource(dataSource);\n        }\n    }\n\n    private _dataSource: DataSource<T> | Observable<T[]> | T[];\n\n    constructor(protected differs: IterableDiffers, protected changeDetectorRef: ChangeDetectorRef) {}\n\n    ngOnInit() {\n        this.dataDiffer = this.differs.find([]).create(this.trackBy);\n\n        if (!this.treeControl) {\n            throw getTreeControlMissingError();\n        }\n    }\n\n    ngOnDestroy() {\n        this.nodeOutlet.viewContainer.clear();\n\n        this.onDestroy.next();\n        this.onDestroy.complete();\n\n        // tslint:disable-next-line:no-unbound-method\n        if (this._dataSource && typeof (this.dataSource as DataSource<T>).disconnect === 'function') {\n            (this.dataSource as DataSource<T>).disconnect(this);\n        }\n\n        if (this.dataSubscription) {\n            this.dataSubscription.unsubscribe();\n            this.dataSubscription = null;\n        }\n    }\n\n    ngAfterContentChecked() {\n        const defaultNodeDefs = this.nodeDefs.filter((def) => !def.when);\n\n        if (defaultNodeDefs.length > 1) {\n            throw getTreeMultipleDefaultNodeDefsError();\n        }\n        this.defaultNodeDef = defaultNodeDefs[0];\n\n        if (this.dataSource && this.nodeDefs && !this.dataSubscription) {\n            this.observeRenderChanges();\n        }\n    }\n\n    /** Check for changes made in the data and render each change (node added/removed/moved). */\n    renderNodeChanges(\n        data: T[] | ReadonlyArray<T>,\n        dataDiffer: IterableDiffer<T> = this.dataDiffer,\n        viewContainer: ViewContainerRef = this.nodeOutlet.viewContainer,\n        parentData?: T\n    ) {\n        const changes = dataDiffer.diff(data);\n\n        if (!changes) { return; }\n\n        changes.forEachOperation((\n            item: IterableChangeRecord<T>,\n            adjustedPreviousIndex: number | null,\n            currentIndex: number | null\n        ) => {\n            if (item.previousIndex == null) {\n                this.insertNode(data[currentIndex!], currentIndex!, viewContainer, parentData);\n            } else if (currentIndex == null) {\n                viewContainer.remove(adjustedPreviousIndex!);\n                this.levels.delete(item.item);\n            } else {\n                const view = viewContainer.get(adjustedPreviousIndex!);\n                viewContainer.move(view!, currentIndex);\n            }\n        });\n\n        this.changeDetectorRef.detectChanges();\n    }\n\n    /**\n     * Finds the matching node definition that should be used for this node data. If there is only\n     * one node definition, it is returned. Otherwise, find the node definition that has a when\n     * predicate that returns true with the data. If none return true, return the default node\n     * definition.\n     */\n    getNodeDef(data: T, i: number): McTreeNodeDef<T> {\n        if (this.nodeDefs.length === 1) { return this.nodeDefs.first; }\n\n        const nodeDef = this.nodeDefs.find((def) => def.when && def.when(i, data)) || this.defaultNodeDef;\n\n        if (!nodeDef) { throw getTreeMissingMatchingNodeDefError(); }\n\n        return nodeDef;\n    }\n\n    /**\n     * Create the embedded view for the data node template and place it in the correct index location\n     * within the data node view container.\n     */\n    insertNode(nodeData: T, index: number, viewContainer?: ViewContainerRef, parentData?: T) {\n        const node = this.getNodeDef(nodeData, index);\n\n        // Node context that will be provided to created embedded view\n        const context = new McTreeNodeOutletContext<T>(nodeData);\n\n        // If the tree is flat tree, then use the `getLevel` function in flat tree control\n        // Otherwise, use the level of parent node.\n        if (this.treeControl.getLevel) {\n            context.level = this.treeControl.getLevel(nodeData);\n            /* tslint:disable-next-line:no-typeof-undefined */\n        } else if (typeof parentData !== 'undefined' && this.levels.has(parentData)) {\n            context.level = this.levels.get(parentData)! + 1;\n        } else {\n            context.level = 0;\n        }\n\n        this.levels.set(nodeData, context.level);\n\n        // Use default tree nodeOutlet, or nested node's nodeOutlet\n        const container = viewContainer ? viewContainer : this.nodeOutlet.viewContainer;\n        container.createEmbeddedView(node.template, context, index);\n\n        // Set the data to just created `McTreeNode`.\n        // The `McTreeNode` created from `createEmbeddedView` will be saved in static variable\n        //     `mostRecentTreeNode`. We get it from static variable and pass the node data to it.\n        if (McTreeNode.mostRecentTreeNode) {\n            McTreeNode.mostRecentTreeNode.data = nodeData;\n        }\n    }\n\n    /** Set up a subscription for the data provided by the data source. */\n    private observeRenderChanges() {\n        let dataStream: Observable<T[] | ReadonlyArray<T>> | undefined;\n\n        // Cannot use `instanceof DataSource` since the data source could be a literal with\n        // `connect` function and may not extends DataSource.\n        // tslint:disable-next-line:no-unbound-method\n        if (typeof (this._dataSource as DataSource<T>).connect === 'function') {\n            dataStream = (this._dataSource as DataSource<T>).connect(this);\n        } else if (this._dataSource instanceof Observable) {\n            dataStream = this._dataSource;\n        } else if (Array.isArray(this._dataSource)) {\n            dataStream = observableOf(this._dataSource);\n        }\n\n        if (dataStream) {\n            this.dataSubscription = dataStream\n                .pipe(takeUntil(this.onDestroy))\n                .subscribe((data) => this.renderNodeChanges(data));\n        } else {\n            throw getTreeNoValidDataSourceError();\n        }\n    }\n\n    /**\n     * Switch to the provided data source by resetting the data and unsubscribing from the current\n     * render change subscription if one exists. If the data source is null, interpret this by\n     * clearing the node outlet. Otherwise start listening for new data.\n     */\n    private switchDataSource(dataSource: DataSource<T> | Observable<T[]> | T[]) {\n        // tslint:disable-next-line:no-unbound-method\n        if (this._dataSource && typeof (this._dataSource as DataSource<T>).disconnect === 'function') {\n            (this.dataSource as DataSource<T>).disconnect(this);\n        }\n\n        if (this.dataSubscription) {\n            this.dataSubscription.unsubscribe();\n            this.dataSubscription = null;\n        }\n\n        // Remove the all dataNodes if there is now no data source\n        if (!dataSource) { this.nodeOutlet.viewContainer.clear(); }\n\n        this._dataSource = dataSource;\n\n        if (this.nodeDefs) { this.observeRenderChanges(); }\n    }\n}\n\n\n@Directive({\n    selector: 'mc-tree-node',\n    exportAs: 'mcTreeNode'\n})\nexport class McTreeNode<T> implements IFocusableOption, OnDestroy {\n    /**\n     * The most recently created `McTreeNode`. We save it in static variable so we can retrieve it\n     * in `McTree` and set the data to it.\n     */\n    static mostRecentTreeNode: McTreeNode<any> | null = null;\n\n    protected destroyed = new Subject<void>();\n\n    get data(): T {\n        return this._data;\n    }\n\n    set data(value: T) {\n        this._data = value;\n    }\n\n    private _data: T;\n\n    get isExpanded(): boolean {\n        return this.tree.treeControl.isExpanded(this.data);\n    }\n\n    get level(): number {\n        return this.tree.treeControl.getLevel ? this.tree.treeControl.getLevel(this._data) : 0;\n    }\n\n    constructor(\n        protected elementRef: ElementRef,\n        @Inject(forwardRef(() => McTreeBase)) public tree: McTreeBase<T>\n    ) {\n        McTreeNode.mostRecentTreeNode = this;\n    }\n\n    ngOnDestroy() {\n        this.destroyed.next();\n        this.destroyed.complete();\n    }\n\n    focus(): void {\n        this.elementRef.nativeElement.focus();\n    }\n}\n"]}

package/esm2015/tree/tree-errors.js

@@ -0,0 +1,36 @@
+/**
+ * Returns an error to be thrown when there is no usable data.
+ * @docs-private
+ */
+export function getTreeNoValidDataSourceError() {
+    return Error(`A valid data source must be provided.`);
+}
+/**
+ * Returns an error to be thrown when there are multiple nodes that are missing a when function.
+ * @docs-private
+ */
+export function getTreeMultipleDefaultNodeDefsError() {
+    return Error(`There can only be one default row without a when predicate function.`);
+}
+/**
+ * Returns an error to be thrown when there are no matching node defs for a particular set of data.
+ * @docs-private
+ */
+export function getTreeMissingMatchingNodeDefError() {
+    return Error(`Could not find a matching node definition for the provided node data.`);
+}
+/**
+ * Returns an error to be thrown when there are tree control.
+ * @docs-private
+ */
+export function getTreeControlMissingError() {
+    return Error(`Could not find a tree control for the tree.`);
+}
+/**
+ * Returns an error to be thrown when tree control did not implement functions for flat/nested node.
+ * @docs-private
+ */
+export function getTreeControlFunctionsMissingError() {
+    return Error(`Could not find functions for nested/flat tree in tree control.`);
+}
+//# sourceMappingURL=data:application/json;base64,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