@ptsecurity/mosaic 12.0.2 → 12.2.2

package/tabs/tab.component.d.ts

@@ -1,6 +1,6 @@
 import { TemplatePortal } from '@angular/cdk/portal';
 import { OnChanges, OnDestroy, OnInit, SimpleChanges, TemplateRef, ViewContainerRef } from '@angular/core';
-import { CanDisable, CanDisableCtor } from '@ptsecurity/mosaic/core';
+import { CanDisable, CanDisableCtor, PopUpPlacements } from '@ptsecurity/mosaic/core';
 import { Subject } from 'rxjs';
 import { McTabLabel } from './tab-label.directive';
 import * as i0 from "@angular/core";
@@ -20,11 +20,13 @@ export declare class McTab extends McTabMixinBase implements OnInit, CanDisable,
     explicitContent: TemplateRef<any>;
     /** Template inside the McTab view that contains an `<ng-content>`. */
     implicitContent: TemplateRef<any>;
+    get tooltipTitle(): string;
+    set tooltipTitle(value: string);
+    private _tooltipTitle;
+    tooltipPlacement: PopUpPlacements;
     /** Plain text label for the tab, used when there is no template label. */
     textLabel: string;
     empty: boolean;
-    tooltipTitle: string;
-    tooltipPlacement: string;
     tabId: string;
     /** Emits whenever the internal state of the tab changes. */
     readonly stateChanges: Subject<void>;
@@ -42,6 +44,10 @@ export declare class McTab extends McTabMixinBase implements OnInit, CanDisable,
      * Whether the tab is currently active.
      */
     isActive: boolean;
+    get isOverflown(): boolean;
+    get overflowTooltipTitle(): string;
+    set overflowTooltipTitle(value: string);
+    private _overflowTooltipTitle;
     /** Portal that will be the hosted content of the tab */
     private contentPortal;
     constructor(viewContainerRef: ViewContainerRef);
@@ -56,5 +62,5 @@ export declare class McTab extends McTabMixinBase implements OnInit, CanDisable,
      */
     protected setTemplateLabelInput(value: McTabLabel): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<McTab, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<McTab, "mc-tab", ["mcTab"], { "disabled": "disabled"; "textLabel": "label"; "empty": "empty"; "tooltipTitle": "tooltipTitle"; "tooltipPlacement": "tooltipPlacement"; "tabId": "tabId"; }, {}, ["templateLabel", "explicitContent"], ["*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTab, "mc-tab", ["mcTab"], { "disabled": "disabled"; "tooltipTitle": "tooltipTitle"; "tooltipPlacement": "tooltipPlacement"; "textLabel": "label"; "empty": "empty"; "tabId": "tabId"; }, {}, ["templateLabel", "explicitContent"], ["*"]>;
 }

package/tooltip/tooltip.component.d.ts

@@ -1,8 +1,8 @@
 import { Directionality } from '@angular/cdk/bidi';
 import { Overlay, ScrollDispatcher, ScrollStrategy } from '@angular/cdk/overlay';
 import { OverlayConfig } from '@angular/cdk/overlay/overlay-config';
-import { ChangeDetectorRef, ElementRef, InjectionToken, NgZone, TemplateRef, Type, ViewContainerRef } from '@angular/core';
-import { McPopUp, McPopUpTrigger } from '@ptsecurity/mosaic/core';
+import { ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, NgZone, TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import { McPopUp, McPopUpTrigger, PopUpPlacements } from '@ptsecurity/mosaic/core';
 import * as i0 from "@angular/core";
 export declare enum TooltipModifier {
     Default = "default",
@@ -39,16 +39,25 @@ export declare const MC_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
     useFactory: typeof mcTooltipScrollStrategyFactory;
 };
 export declare class McTooltipTrigger extends McPopUpTrigger<McTooltipComponent> {
+    get tooltipVisible(): boolean;
+    set tooltipVisible(value: boolean);
+    get tooltipPlacement(): PopUpPlacements;
+    set tooltipPlacement(value: PopUpPlacements);
+    get tooltipPlacementPriority(): string | string[] | null;
+    set tooltipPlacementPriority(value: string | string[] | null);
     get content(): string | TemplateRef<any>;
     set content(content: string | TemplateRef<any>);
     get disabled(): boolean;
     set disabled(value: boolean);
     enterDelay: number;
+    leaveDelay: number;
     get trigger(): string;
     set trigger(value: string);
     private _trigger;
     get customClass(): string;
     set customClass(value: string);
+    placementChange: EventEmitter<any>;
+    visibleChange: EventEmitter<boolean>;
     protected originSelector: string;
     protected overlayConfig: OverlayConfig;
     protected modifier: TooltipModifier;
@@ -58,7 +67,7 @@ export declare class McTooltipTrigger extends McPopUpTrigger<McTooltipComponent>
     getOverlayHandleComponentType(): Type<McTooltipComponent>;
     updateClassMap(newPlacement?: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<McTooltipTrigger, [null, null, null, null, null, null, { optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<McTooltipTrigger, "[mcTooltip]", ["mcTooltip"], { "content": "mcTooltip"; "disabled": "mcTooltipDisabled"; "enterDelay": "mcEnterDelay"; "trigger": "mcTrigger"; "customClass": "mcTooltipClass"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTooltipTrigger, "[mcTooltip]", ["mcTooltip"], { "tooltipVisible": "mcVisible"; "tooltipPlacement": "mcPlacement"; "tooltipPlacementPriority": "mcPlacementPriority"; "content": "mcTooltip"; "disabled": "mcTooltipDisabled"; "enterDelay": "mcEnterDelay"; "leaveDelay": "mcLeaveDelay"; "trigger": "mcTrigger"; "customClass": "mcTooltipClass"; }, { "placementChange": "mcPlacementChange"; "visibleChange": "mcVisibleChange"; }, never>;
 }
 export declare class McWarningTooltipTrigger extends McTooltipTrigger {
     get content(): string | TemplateRef<any>;

package/tree/control/base-tree-control.d.ts

@@ -0,0 +1,40 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { TreeControl } from './tree-control';
+/** Base tree control. It has basic toggle/expand/collapse operations on a single data node. */
+export declare abstract class BaseTreeControl<T> implements TreeControl<T> {
+    dataNodes: T[];
+    /** A selection model with multi-selection to track expansion status. */
+    expansionModel: SelectionModel<T>;
+    filterModel: SelectionModel<T>;
+    filterValue: BehaviorSubject<string>;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    getLevel: (dataNode: T) => number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    isExpandable: (dataNode: T) => boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    getChildren: (dataNode: T) => Observable<T[]>;
+    /** Gets a list of descendent data nodes of a subtree rooted at given data node recursively. */
+    abstract getDescendants(dataNode: T): T[];
+    /** Expands all data nodes in the tree. */
+    abstract expandAll(): void;
+    /** Toggles one single data node's expanded/collapsed state. */
+    toggle(dataNode: T): void;
+    /** Expands one single data node. */
+    expand(dataNode: T): void;
+    /** Collapses one single data node. */
+    collapse(dataNode: T): void;
+    /** Whether a given data node is expanded or not. Returns true if the data node is expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Toggles a subtree rooted at `node` recursively. */
+    toggleDescendants(dataNode: T): void;
+    /** Collapse all dataNodes in the tree. */
+    collapseAll(): void;
+    /** Expands a subtree rooted at given data node recursively. */
+    expandDescendants(dataNode: T): void;
+    /** Collapses a subtree rooted at given data node recursively. */
+    collapseDescendants(dataNode: T): void;
+}

package/tree/control/flat-tree-control.d.ts

@@ -0,0 +1,48 @@
+import { BaseTreeControl } from './base-tree-control';
+export declare function defaultCompareValues(firstValue: any, secondValue: any): boolean;
+export declare function defaultCompareViewValues(firstViewValue: any, secondViewValue: any): boolean;
+/** Flat tree control. Able to expand/collapse a subtree recursively for flattened tree. */
+export declare class FlatTreeControl<T> extends BaseTreeControl<T> {
+    getLevel: (dataNode: T) => number;
+    isExpandable: (dataNode: T) => boolean;
+    /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */
+    getValue: (dataNode: any) => any;
+    /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */
+    getViewValue: (dataNode: any) => string;
+    /** compareValues will be used to comparing values. */
+    compareValues: (firstValue: any, secondValue: any) => boolean;
+    /** compareValues will be used to comparing values. */
+    compareViewValues: (firstViewValue: any, secondViewValue: any) => boolean;
+    expandedItemsBeforeFiltration: T[];
+    /** Construct with flat tree data node functions getLevel, isExpandable, getValue and getViewValue. */
+    constructor(getLevel: (dataNode: T) => number, isExpandable: (dataNode: T) => boolean, 
+    /** getValue will be used to determine if the tree contains value or not. Used in method hasValue */
+    getValue: (dataNode: any) => any, 
+    /** getViewValue will be used for filter nodes. Returned value will be first argument in filterNodesFunction */
+    getViewValue: (dataNode: any) => string, 
+    /** compareValues will be used to comparing values. */
+    compareValues?: (firstValue: any, secondValue: any) => boolean, 
+    /** compareValues will be used to comparing values. */
+    compareViewValues?: (firstViewValue: any, secondViewValue: any) => boolean);
+    /**
+     * 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: T): T[];
+    /**
+     * 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(): void;
+    getParents(node: any, result: T[]): T[];
+    hasValue(value: string): T | undefined;
+    filterNodes(value: string): void;
+    private expandDataNode;
+    private saveExpansionState;
+    private restoreExpansionState;
+    private hasFilteredDescendant;
+}

package/tree/control/nested-tree-control.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { BaseTreeControl } from './base-tree-control';
+/** Nested tree control. Able to expand/collapse a subtree recursively for NestedNode type. */
+export declare class NestedTreeControl<T> extends BaseTreeControl<T> {
+    getChildren: (dataNode: T) => Observable<T[]>;
+    /** Construct with nested tree function getChildren. */
+    constructor(getChildren: (dataNode: T) => Observable<T[]>);
+    /**
+     * 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(): void;
+    /** Gets a list of descendant dataNodes of a subtree rooted at given data node recursively. */
+    getDescendants(dataNode: T): T[];
+    /** A helper function to get descendants recursively. */
+    private _getDescendants;
+}

package/tree/control/tree-control.d.ts

@@ -0,0 +1,44 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { BehaviorSubject, Observable } from 'rxjs';
+/**
+ * Tree control interface. User can implement TreeControl to expand/collapse dataNodes in the tree.
+ * The Tree will use this TreeControl to expand/collapse a node.
+ * User can also use it outside the `<mc-tree>` to control the expansion status of the tree.
+ */
+export interface TreeControl<T> {
+    /** The saved tree nodes data for `expandAll` action. */
+    dataNodes: T[];
+    /** The expansion model */
+    expansionModel: SelectionModel<T>;
+    filterModel: SelectionModel<T>;
+    filterValue: BehaviorSubject<string>;
+    /** Get depth of a given data node, return the level number. This is for flat tree node. */
+    getLevel(dataNode: T): number;
+    /**
+     * Whether the data node is expandable. Returns true if expandable.
+     * This is for flat tree node.
+     */
+    isExpandable(dataNode: T): boolean;
+    /** Gets a stream that emits whenever the given data node's children change. */
+    getChildren(dataNode: T): Observable<T[]>;
+    /** Whether the data node is expanded or collapsed. Return true if it's expanded. */
+    isExpanded(dataNode: T): boolean;
+    /** Get all descendants of a data node */
+    getDescendants(dataNode: T): any[];
+    /** Expand or collapse data node */
+    toggle(dataNode: T): void;
+    /** Expand one data node */
+    expand(dataNode: T): void;
+    /** Collapse one data node */
+    collapse(dataNode: T): void;
+    /** Expand all the dataNodes in the tree */
+    expandAll(): void;
+    /** Collapse all the dataNodes in the tree */
+    collapseAll(): void;
+    /** Toggle a data node by expand/collapse it and all its descendants */
+    toggleDescendants(dataNode: T): void;
+    /** Expand a data node and all its descendants */
+    expandDescendants(dataNode: T): void;
+    /** Collapse a data node and all its descendants */
+    collapseDescendants(dataNode: T): void;
+}

package/tree/data-source/flat-data-source.d.ts

@@ -1,6 +1,7 @@
 import { CollectionViewer, DataSource } from '@angular/cdk/collections';
-import { FlatTreeControl, TreeControl } from '@ptsecurity/cdk/tree';
 import { BehaviorSubject, Observable } from 'rxjs';
+import { FlatTreeControl } from '../control/flat-tree-control';
+import { TreeControl } from '../control/tree-control';
 /**
  * Tree flattener to convert a normal type of node to node with children & level information.
  * Transform nested nodes of type `T` to flattened nodes of type `F`.

package/tree/node.d.ts

@@ -0,0 +1,34 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+/** Context provided to the tree node component. */
+export declare class McTreeNodeOutletContext<T> {
+    /** Data for the node. */
+    $implicit: T;
+    /** Depth of the node. */
+    level: number;
+    /** Index location of the node. */
+    index?: number;
+    /** Length of the number of total dataNodes. */
+    count?: number;
+    constructor(data: T);
+}
+/**
+ * Data node definition for the McTree.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+export declare class McTreeNodeDef<T> {
+    template: TemplateRef<any>;
+    data: T;
+    /**
+     * Function that should return true if this node template should be used for the provided node
+     * data and index. If left undefined, this node will be considered the default node template to
+     * use when no other when functions return true for the data.
+     * For every node, there must be at least one when function that passes or an undefined to
+     * default.
+     */
+    when: (index: number, nodeData: T) => boolean;
+    /** @docs-private */
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeDef<any>, "[mcTreeNodeDef]", never, { "when": "mcTreeNodeDefWhen"; "data": "mcTreeNode"; }, {}, never>;
+}

package/tree/outlet.d.ts

@@ -0,0 +1,9 @@
+import { ChangeDetectorRef, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class McTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    changeDetectorRef: ChangeDetectorRef;
+    constructor(viewContainer: ViewContainerRef, changeDetectorRef: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeOutlet, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeOutlet, "[mcTreeNodeOutlet]", never, {}, {}, never>;
+}

package/tree/padding.directive.d.ts

@@ -1,17 +1,45 @@
-import { OnInit } from '@angular/core';
-import { CdkTreeNodePadding } from '@ptsecurity/cdk/tree';
+import { Directionality } from '@angular/cdk/bidi';
+import { ElementRef, OnDestroy, OnInit, Renderer2 } from '@angular/core';
+import { McTreeBase, McTreeNode } from './tree-base';
 import * as i0 from "@angular/core";
-export declare class McTreeNodePadding<T> extends CdkTreeNodePadding<T> implements OnInit {
+export declare class McTreeNodePadding<T> implements OnInit, OnDestroy {
+    protected treeNode: McTreeNode<T>;
+    protected tree: McTreeBase<T>;
+    private renderer;
+    private element;
+    private dir;
     get level(): number;
     set level(value: number);
+    private _level;
     get indent(): number | string;
     set indent(indent: number | string);
+    private _indent;
+    get leftPadding(): number;
+    /** CSS units used for the indentation value. */
+    indentUnits: string;
     baseLeftPadding: number;
     withIcon: boolean;
     iconWidth: number;
-    get leftPadding(): number;
-    paddingIndent(): string | null;
+    private destroyed;
+    constructor(treeNode: McTreeNode<T>, tree: McTreeBase<T>, renderer: Renderer2, element: ElementRef<HTMLElement>, dir: Directionality);
     ngOnInit(): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodePadding<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodePadding<any>, "[mcTreeNodePadding]", never, { "level": "mcTreeNodePadding"; "indent": "mcTreeNodePaddingIndent"; }, {}, never>;
+    ngOnDestroy(): void;
+    paddingIndent(): string | null;
+    /**
+     * 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
+     */
+    private setLevelInput;
+    /**
+     * 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
+     */
+    private setIndentInput;
+    private setPadding;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodePadding<any>, [null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodePadding<any>, "[mcTreeNodePadding]", ["mcTreeNodePadding"], { "indent": "mcTreeNodePaddingIndent"; }, {}, never>;
 }

package/tree/public-api.d.ts

@@ -1,8 +1,15 @@
 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';

package/tree/toggle.d.ts

@@ -1,28 +1,28 @@
-import { CdkTree, CdkTreeNode } from '@ptsecurity/cdk/tree';
+import { CanDisable, CanDisableCtor } from '@ptsecurity/mosaic/core';
+import { McTreeBase, McTreeNode } from './tree-base';
 import * as i0 from "@angular/core";
-export declare class McTreeNodeToggleComponent<T> {
+export declare class McTreeNodeToggleBase {
+}
+export declare const McTreeNodeToggleMixinBase: CanDisableCtor & typeof McTreeNodeToggleBase;
+/** @docs-private */
+export declare class McTreeNodeToggleBaseDirective<T> extends McTreeNodeToggleMixinBase implements CanDisable {
     private tree;
     private treeNode;
-    disabled: boolean;
     node: T;
     get recursive(): boolean;
-    set recursive(value: boolean);
+    set recursive(value: any);
     private _recursive;
-    get iconState(): any;
-    constructor(tree: CdkTree<T>, treeNode: CdkTreeNode<T>);
+    get iconState(): boolean;
+    constructor(tree: McTreeBase<T>, treeNode: McTreeNode<T>);
     toggle(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeToggleBaseDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeToggleBaseDirective<any>, never, never, { "node": "node"; "recursive": "mcTreeNodeToggleRecursive"; }, {}, never>;
+}
+export declare class McTreeNodeToggleComponent<T> extends McTreeNodeToggleBaseDirective<T> {
     static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeToggleComponent<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeNodeToggleComponent<any>, "mc-tree-node-toggle", never, { "node": "node"; "recursive": "cdkTreeNodeToggleRecursive"; }, {}, never, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeNodeToggleComponent<any>, "mc-tree-node-toggle", ["mcTreeNodeToggle"], { "disabled": "disabled"; }, {}, never, never>;
 }
-export declare class McTreeNodeToggleDirective<T> {
-    private tree;
-    private treeNode;
-    disabled: boolean;
-    get recursive(): boolean;
-    set recursive(value: boolean);
-    private _recursive;
-    constructor(tree: CdkTree<T>, treeNode: CdkTreeNode<T>);
-    toggle(event: Event): void;
+export declare class McTreeNodeToggleDirective<T> extends McTreeNodeToggleBaseDirective<T> {
     static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeToggleDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeToggleDirective<any>, "[mcTreeNodeToggle]", never, { "recursive": "cdkTreeNodeToggleRecursive"; }, {}, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeToggleDirective<any>, "[mcTreeNodeToggle]", ["mcTreeNodeToggle"], {}, {}, never>;
 }

package/tree/tree-base.d.ts

@@ -0,0 +1,97 @@
+import { CollectionViewer, DataSource } from '@angular/cdk/collections';
+import { AfterContentChecked, ChangeDetectorRef, ElementRef, IterableDiffer, IterableDiffers, OnDestroy, OnInit, QueryList, ViewContainerRef, TrackByFunction } from '@angular/core';
+import { IFocusableOption } from '@ptsecurity/cdk/a11y';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { TreeControl } from './control/tree-control';
+import { McTreeNodeDef } from './node';
+import { McTreeNodeOutlet } from './outlet';
+import * as i0 from "@angular/core";
+export declare class McTreeBase<T> implements AfterContentChecked, CollectionViewer, OnDestroy, OnInit {
+    protected differs: IterableDiffers;
+    protected changeDetectorRef: ChangeDetectorRef;
+    treeControl: TreeControl<T>;
+    /**
+     * Tracking function that will be used to check the differences in data changes. Used similarly
+     * to `ngFor` `trackBy` function. Optimize node operations by identifying a node based on its data
+     * relative to the function to know if a node should be added/removed/moved.
+     * Accepts a function that takes two parameters, `index` and `item`.
+     */
+    trackBy: TrackByFunction<T>;
+    nodeOutlet: McTreeNodeOutlet;
+    /** The tree node template for the tree */
+    nodeDefs: QueryList<McTreeNodeDef<T>>;
+    /**
+     * 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.
+     */
+    viewChange: BehaviorSubject<{
+        start: number;
+        end: number;
+    }>;
+    /** Differ used to find the changes in the data provided by the data source. */
+    protected dataDiffer: IterableDiffer<T>;
+    /** Subject that emits when the component has been destroyed. */
+    private onDestroy;
+    /** Stores the node definition that does not have a when predicate. */
+    private defaultNodeDef;
+    /** Data subscription */
+    private dataSubscription;
+    /** Level of nodes */
+    private levels;
+    /**
+     * 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(): DataSource<T> | Observable<T[]> | T[];
+    set dataSource(dataSource: DataSource<T> | Observable<T[]> | T[]);
+    private _dataSource;
+    constructor(differs: IterableDiffers, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngAfterContentChecked(): void;
+    /** Check for changes made in the data and render each change (node added/removed/moved). */
+    renderNodeChanges(data: T[] | ReadonlyArray<T>, dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /**
+     * 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: T, i: number): McTreeNodeDef<T>;
+    /**
+     * 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: T, index: number, viewContainer?: ViewContainerRef, parentData?: T): void;
+    /** Set up a subscription for the data provided by the data source. */
+    private observeRenderChanges;
+    /**
+     * 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.
+     */
+    private switchDataSource;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeBase<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeBase<any>, never, never, { "treeControl": "treeControl"; "trackBy": "trackBy"; "dataSource": "dataSource"; }, {}, ["nodeDefs"]>;
+}
+export declare class McTreeNode<T> implements IFocusableOption, OnDestroy {
+    protected elementRef: ElementRef;
+    tree: McTreeBase<T>;
+    /**
+     * The most recently created `McTreeNode`. We save it in static variable so we can retrieve it
+     * in `McTree` and set the data to it.
+     */
+    static mostRecentTreeNode: McTreeNode<any> | null;
+    protected destroyed: Subject<void>;
+    get data(): T;
+    set data(value: T);
+    private _data;
+    get isExpanded(): boolean;
+    get level(): number;
+    constructor(elementRef: ElementRef, tree: McTreeBase<T>);
+    ngOnDestroy(): void;
+    focus(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNode<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNode<any>, "mc-tree-node", ["mcTreeNode"], {}, {}, never>;
+}

package/tree/tree-errors.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Returns an error to be thrown when there is no usable data.
+ * @docs-private
+ */
+export declare function getTreeNoValidDataSourceError(): Error;
+/**
+ * Returns an error to be thrown when there are multiple nodes that are missing a when function.
+ * @docs-private
+ */
+export declare function getTreeMultipleDefaultNodeDefsError(): Error;
+/**
+ * Returns an error to be thrown when there are no matching node defs for a particular set of data.
+ * @docs-private
+ */
+export declare function getTreeMissingMatchingNodeDefError(): Error;
+/**
+ * Returns an error to be thrown when there are tree control.
+ * @docs-private
+ */
+export declare function getTreeControlMissingError(): Error;
+/**
+ * Returns an error to be thrown when tree control did not implement functions for flat/nested node.
+ * @docs-private
+ */
+export declare function getTreeControlFunctionsMissingError(): Error;

package/tree/tree-option.component.d.ts

@@ -1,8 +1,11 @@
 import { FocusOrigin } from '@angular/cdk/a11y';
 import { ChangeDetectorRef, EventEmitter, ElementRef, InjectionToken, AfterContentInit, NgZone } from '@angular/core';
-import { CdkTreeNode } from '@ptsecurity/cdk/tree';
-import { CanDisable } from '@ptsecurity/mosaic/core';
+import { McOptionActionComponent } from '@ptsecurity/mosaic/core';
+import { McDropdownTrigger } from '@ptsecurity/mosaic/dropdown';
+import { McTooltipTrigger } from '@ptsecurity/mosaic/tooltip';
 import { Subject } from 'rxjs';
+import { McTreeNodeToggleBaseDirective } from './toggle';
+import { McTreeNode } from './tree-base';
 import * as i0 from "@angular/core";
 export interface McTreeOptionEvent {
     option: McTreeOption;
@@ -16,12 +19,16 @@ export declare class McTreeOptionChange {
     isUserInput: boolean;
     constructor(source: McTreeOption, isUserInput?: boolean);
 }
-export declare class McTreeOption extends CdkTreeNode<McTreeOption> implements CanDisable, AfterContentInit {
+export declare class McTreeOption extends McTreeNode<McTreeOption> implements AfterContentInit {
     private changeDetectorRef;
     private ngZone;
     tree: any;
     readonly onFocus: Subject<McTreeOptionEvent>;
     readonly onBlur: Subject<McTreeOptionEvent>;
+    toggleElement: McTreeNodeToggleBaseDirective<McTreeOption>;
+    actionButton: McOptionActionComponent;
+    tooltipTrigger: McTooltipTrigger;
+    dropdownTrigger: McDropdownTrigger;
     get value(): any;
     set value(value: any);
     private _value;
@@ -37,9 +44,9 @@ export declare class McTreeOption extends CdkTreeNode<McTreeOption> implements C
     private _selected;
     get id(): string;
     private _id;
-    get multiple(): boolean;
     get viewValue(): string;
     hasFocus: boolean;
+    get isExpandable(): boolean;
     constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone, tree: any);
     ngAfterContentInit(): void;
     toggle(): void;
@@ -49,10 +56,11 @@ export declare class McTreeOption extends CdkTreeNode<McTreeOption> implements C
     getHeight(): number;
     select(): void;
     deselect(): void;
+    onKeydown($event: any): void;
     selectViaInteraction($event?: KeyboardEvent): void;
     emitSelectionChangeEvent(isUserInput?: boolean): void;
     getHostElement(): HTMLElement;
     markForCheck(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<McTreeOption, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeOption, "mc-tree-option", ["mcTreeOption"], { "disabled": "disabled"; "showCheckbox": "showCheckbox"; }, { "onSelectionChange": "onSelectionChange"; }, never, ["[mc-icon]", "mc-tree-node-toggle", "*"]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeOption, "mc-tree-option", ["mcTreeOption"], { "disabled": "disabled"; "showCheckbox": "showCheckbox"; }, { "onSelectionChange": "onSelectionChange"; }, ["toggleElement", "actionButton", "tooltipTrigger", "dropdownTrigger"], ["mc-tree-node-toggle", "mc-checkbox", "[mc-icon]", "*", "mc-option-action"]>;
 }