@ptsecurity/mosaic 11.5.0 → 12.2.0

package/tooltip/tooltip.component.d.ts

@@ -1,61 +1,33 @@
 import { Directionality } from '@angular/cdk/bidi';
-import { ConnectedOverlayPositionChange, ConnectionPositionPair, Overlay, OverlayRef, ScrollDispatcher, ScrollStrategy, OverlayConnectionPosition, OriginConnectionPosition, HorizontalConnectionPos, VerticalConnectionPos } from '@angular/cdk/overlay';
-import { ComponentPortal } from '@angular/cdk/portal';
-import { ChangeDetectorRef, ElementRef, EventEmitter, InjectionToken, NgZone, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
-import { Observable } from 'rxjs';
-export declare type ArrowPlacements = HorizontalConnectionPos | VerticalConnectionPos;
-export declare const ArrowPlacements: {
-    Top: ArrowPlacements;
-    Center: ArrowPlacements;
-    Bottom: ArrowPlacements;
-    Right: ArrowPlacements;
-    Left: ArrowPlacements;
+import { Overlay, ScrollDispatcher, ScrollStrategy } from '@angular/cdk/overlay';
+import { OverlayConfig } from '@angular/cdk/overlay/overlay-config';
+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",
+    Warning = "warning",
+    Extended = "extended"
+}
+export declare const MC_TOOLTIP_OPEN_TIME: InjectionToken<() => ScrollStrategy>;
+/** @docs-private */
+export declare const MC_TOOLTIP_OPEN_TIME_PROVIDER: {
+    provide: InjectionToken<() => ScrollStrategy>;
+    useValue: {
+        value: number;
+    };
 };
-export declare class McTooltipComponent {
-    cdr: ChangeDetectorRef;
+export declare const MIN_TIME_FOR_DELAY = 2000;
+export declare class McTooltipComponent extends McPopUp {
+    private openTime;
     prefix: string;
-    positions: ConnectionPositionPair[];
-    classMap: {};
-    isTitleString: boolean;
-    showTid: any;
-    hideTid: any;
-    availablePositions: any;
-    $visible: Observable<boolean>;
-    mcVisibleChange: EventEmitter<boolean>;
-    mcMouseEnterDelay: number;
-    mcMouseLeaveDelay: number;
-    get mcTitle(): string | TemplateRef<any>;
-    set mcTitle(value: string | TemplateRef<any>);
-    private _mcTitle;
-    get mcTrigger(): string;
-    set mcTrigger(value: string);
-    private _mcTrigger;
-    get mcPlacement(): string;
-    set mcPlacement(value: string);
-    private _mcPlacement;
-    get mcTooltipClass(): string;
-    set mcTooltipClass(value: string);
-    private _mcTooltipClass;
-    get mcVisible(): boolean;
-    set mcVisible(value: boolean);
-    private _mcVisible;
-    get mcArrowPlacement(): ArrowPlacements;
-    set mcArrowPlacement(value: ArrowPlacements);
-    private _mcArrowPlacement;
-    /** Subject for notifying that the tooltip has been hidden from the view */
-    private readonly onHideSubject;
-    private closeOnInteraction;
-    constructor(cdr: ChangeDetectorRef);
-    show(): void;
-    hide(): void;
-    setClassMap(): void;
-    isContentEmpty(): boolean;
-    /** Returns an observable that notifies when the tooltip has been hidden from view. */
-    afterHidden(): Observable<void>;
-    markForCheck(): void;
-    handleBodyInteraction(): void;
-    get isTemplateRef(): boolean;
-    get isNonEmptyString(): boolean;
+    constructor(changeDetectorRef: ChangeDetectorRef, openTime: any);
+    show(delay: number): void;
+    updateClassMap(placement: string, customClass: string, { modifier }: {
+        modifier: any;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTooltipComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTooltipComponent, "mc-tooltip-component", never, {}, {}, never, never>;
 }
 export declare const MC_TOOLTIP_SCROLL_STRATEGY: InjectionToken<() => ScrollStrategy>;
 /** @docs-private */
@@ -66,86 +38,54 @@ export declare const MC_TOOLTIP_SCROLL_STRATEGY_FACTORY_PROVIDER: {
     deps: (typeof Overlay)[];
     useFactory: typeof mcTooltipScrollStrategyFactory;
 };
-/** Creates an error to be thrown if the user supplied an invalid tooltip position. */
-export declare function getMcTooltipInvalidPositionError(position: string): Error;
-export declare class McTooltip implements OnInit, OnDestroy {
-    private overlay;
-    private elementRef;
-    private ngZone;
-    private scrollDispatcher;
-    private hostView;
-    private scrollStrategy;
-    private direction;
-    isTooltipOpen: boolean;
-    isDynamicTooltip: boolean;
-    parentDisabled: boolean;
-    overlayRef: OverlayRef | null;
-    portal: ComponentPortal<McTooltipComponent>;
-    availablePositions: any;
-    tooltip: McTooltipComponent | null;
-    mcVisibleChange: EventEmitter<boolean>;
-    private $unsubscribe;
-    get mcTitle(): string | TemplateRef<any>;
-    set mcTitle(title: string | TemplateRef<any>);
-    private _mcTitle;
-    set setTitle(title: string | TemplateRef<any>);
+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);
-    private _disabled;
-    get mcMouseEnterDelay(): number;
-    set mcMouseEnterDelay(value: number);
-    private _mcMouseEnterDelay;
-    get mcMouseLeaveDelay(): number;
-    set mcMouseLeaveDelay(value: number);
-    private _mcMouseLeaveDelay;
-    get mcTrigger(): string;
-    set mcTrigger(value: string);
-    private _mcTrigger;
-    get mcPlacement(): string;
-    set mcPlacement(value: string);
-    private _mcPlacement;
-    get mcTooltipClass(): string;
-    set mcTooltipClass(value: string);
-    private _mcTooltipClass;
-    get mcVisible(): boolean;
-    set mcVisible(externalValue: boolean);
-    private _mcVisible;
-    get mcArrowPlacement(): ArrowPlacements;
-    set mcArrowPlacement(value: ArrowPlacements);
-    private _mcArrowPlacement;
-    private manualListeners;
-    private readonly destroyed;
+    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;
     constructor(overlay: Overlay, elementRef: ElementRef, ngZone: NgZone, scrollDispatcher: ScrollDispatcher, hostView: ViewContainerRef, scrollStrategy: any, direction: Directionality);
-    ngOnInit(): void;
-    ngOnDestroy(): void;
-    /** Create the overlay config and position strategy */
-    createOverlay(): OverlayRef;
-    detach(): void;
-    onPositionChange($event: ConnectedOverlayPositionChange): void;
-    handlePositioningUpdate(): void;
-    updateCompValue(key: string, value: any): void;
-    handleKeydown(e: KeyboardEvent): void;
-    handleTouchend(): void;
-    initElementRefListeners(): void;
-    clearListeners(): void;
-    show(): void;
-    hide(): void;
-    /** Updates the position of the current tooltip. */
-    updatePosition(): void;
-    /**
-     * Returns the origin position and a fallback position based on the user's position preference.
-     * The fallback position is the inverse of the origin (e.g. `'below' -> 'above'`).
-     */
-    getOrigin(): {
-        main: OriginConnectionPosition;
-        fallback: OriginConnectionPosition;
-    };
-    /** Returns the overlay position and a fallback position based on the user's preference */
-    getOverlayPosition(): {
-        main: OverlayConnectionPosition;
-        fallback: OverlayConnectionPosition;
-    };
-    /** Inverts an overlay position. */
-    private invertPosition;
-    private getTooltipArrowElem;
+    updateData(): void;
+    closingActions(): import("rxjs").Observable<void | MouseEvent>;
+    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"], { "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>;
+    set content(content: string | TemplateRef<any>);
+    protected modifier: TooltipModifier;
+    constructor(overlay: Overlay, elementRef: ElementRef, ngZone: NgZone, scrollDispatcher: ScrollDispatcher, hostView: ViewContainerRef, scrollStrategy: any, direction: Directionality);
+    static ɵfac: i0.ɵɵFactoryDeclaration<McWarningTooltipTrigger, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McWarningTooltipTrigger, "[mcWarningTooltip]", ["mcWarningTooltip"], { "content": "mcWarningTooltip"; }, {}, never>;
+}
+export declare class McExtendedTooltipTrigger extends McTooltipTrigger {
+    get content(): string | TemplateRef<any>;
+    set content(content: string | TemplateRef<any>);
+    get header(): string | TemplateRef<any>;
+    set header(header: string | TemplateRef<any>);
+    private _header;
+    protected modifier: TooltipModifier;
+    constructor(overlay: Overlay, elementRef: ElementRef, ngZone: NgZone, scrollDispatcher: ScrollDispatcher, hostView: ViewContainerRef, scrollStrategy: any, direction: Directionality);
+    updateData(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McExtendedTooltipTrigger, [null, null, null, null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McExtendedTooltipTrigger, "[mcExtendedTooltip]", ["mcExtendedTooltip"], { "content": "mcExtendedTooltip"; "header": "mcTooltipHeader"; }, {}, never>;
 }

package/tooltip/tooltip.module.d.ts

@@ -1,2 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./tooltip.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/cdk/overlay";
 export declare class McToolTipModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<McToolTipModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<McToolTipModule, [typeof i1.McTooltipComponent, typeof i1.McTooltipTrigger, typeof i1.McExtendedTooltipTrigger, typeof i1.McWarningTooltipTrigger], [typeof i2.CommonModule, typeof i3.OverlayModule], [typeof i1.McTooltipComponent, typeof i1.McTooltipTrigger, typeof i1.McExtendedTooltipTrigger, typeof i1.McWarningTooltipTrigger]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<McToolTipModule>;
 }

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/package.json

@@ -5,7 +5,6 @@
   "esm2015": "../esm2015/tree/ptsecurity-mosaic-tree.js",
   "fesm2015": "../fesm2015/ptsecurity-mosaic-tree.js",
   "typings": "ptsecurity-mosaic-tree.d.ts",
-  "metadata": "ptsecurity-mosaic-tree.metadata.json",
   "sideEffects": false,
   "name": "@ptsecurity/mosaic/tree"
 }

package/tree/padding.directive.d.ts

@@ -1,14 +1,45 @@
-import { OnInit } from '@angular/core';
-import { CdkTreeNodePadding } from '@ptsecurity/cdk/tree';
-export declare class McTreeNodePadding<T> extends CdkTreeNodePadding<T> implements OnInit {
+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> 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;
+    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/ptsecurity-mosaic-tree.d.ts

@@ -1,4 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
+/// <amd-module name="@ptsecurity/mosaic/tree" />
 export * from './index';

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,23 +1,28 @@
-import { CdkTree, CdkTreeNode } from '@ptsecurity/cdk/tree';
-export declare class McTreeNodeToggleComponent<T> {
+import { CanDisable, CanDisableCtor } from '@ptsecurity/mosaic/core';
+import { McTreeBase, McTreeNode } from './tree-base';
+import * as i0 from "@angular/core";
+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 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 McTreeNodeToggleComponent<T> extends McTreeNodeToggleBaseDirective<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeToggleComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeNodeToggleComponent<any>, "mc-tree-node-toggle", ["mcTreeNodeToggle"], { "disabled": "disabled"; }, {}, never, never>;
+}
+export declare class McTreeNodeToggleDirective<T> extends McTreeNodeToggleBaseDirective<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeNodeToggleDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<McTreeNodeToggleDirective<any>, "[mcTreeNodeToggle]", ["mcTreeNodeToggle"], {}, {}, never>;
 }