@ptsecurity/mosaic 11.6.0 → 12.2.1

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>;
 }

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,12 @@
 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;
 }
@@ -15,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;
@@ -36,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;
@@ -48,8 +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"; }, ["toggleElement", "actionButton", "tooltipTrigger", "dropdownTrigger"], ["mc-tree-node-toggle", "mc-checkbox", "[mc-icon]", "*", "mc-option-action"]>;
 }

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

@@ -1,39 +1,56 @@
+import { Clipboard } from '@angular/cdk/clipboard';
 import { SelectionModel } from '@angular/cdk/collections';
 import { AfterContentInit, ChangeDetectorRef, ElementRef, EventEmitter, IterableDiffer, IterableDiffers, QueryList, ViewContainerRef } from '@angular/core';
 import { ControlValueAccessor } from '@angular/forms';
 import { FocusKeyManager } from '@ptsecurity/cdk/a11y';
-import { CdkTree, CdkTreeNodeOutlet, FlatTreeControl } from '@ptsecurity/cdk/tree';
 import { CanDisable, HasTabIndex, MultipleMode } from '@ptsecurity/mosaic/core';
 import { Observable } from 'rxjs';
+import { FlatTreeControl } from './control/flat-tree-control';
+import { McTreeNodeOutlet } from './outlet';
+import { McTreeBase } from './tree-base';
 import { McTreeOption, McTreeOptionEvent } from './tree-option.component';
+import * as i0 from "@angular/core";
 export declare const MC_SELECTION_TREE_VALUE_ACCESSOR: any;
+export declare class McTreeSelectAllEvent<T> {
+    source: McTreeSelection;
+    options: T[];
+    constructor(source: McTreeSelection, options: T[]);
+}
+export declare class McTreeCopyEvent<T> {
+    source: McTreeSelection;
+    option: T;
+    constructor(source: McTreeSelection, option: T);
+}
 export declare class McTreeNavigationChange<T> {
-    source: McTreeSelection<any>;
+    source: McTreeSelection;
     option: T;
-    constructor(source: McTreeSelection<any>, option: T);
+    constructor(source: McTreeSelection, option: T);
 }
 export declare class McTreeSelectionChange<T> {
-    source: McTreeSelection<any>;
+    source: McTreeSelection;
     option: T;
-    constructor(source: McTreeSelection<any>, option: T);
+    constructor(source: McTreeSelection, option: T);
 }
 interface SelectionModelOption {
     id: number | string;
     value: string;
 }
-export declare class McTreeSelection<T extends McTreeOption> extends CdkTree<T> implements ControlValueAccessor, AfterContentInit, CanDisable, HasTabIndex {
+export declare class McTreeSelection extends McTreeBase<any> implements ControlValueAccessor, AfterContentInit, CanDisable, HasTabIndex {
     private elementRef;
-    nodeOutlet: CdkTreeNodeOutlet;
-    unorderedOptions: QueryList<T>;
-    renderedOptions: QueryList<T>;
-    keyManager: FocusKeyManager<T>;
+    private clipboard;
+    renderedOptions: QueryList<McTreeOption>;
+    keyManager: FocusKeyManager<McTreeOption>;
     selectionModel: SelectionModel<SelectionModelOption>;
     resetFocusedItemOnBlur: boolean;
-    treeControl: FlatTreeControl<T>;
-    readonly navigationChange: EventEmitter<McTreeNavigationChange<T>>;
-    readonly selectionChange: EventEmitter<McTreeSelectionChange<T>>;
     multipleMode: MultipleMode | null;
     userTabIndex: number | null;
+    nodeOutlet: McTreeNodeOutlet;
+    unorderedOptions: QueryList<McTreeOption>;
+    treeControl: FlatTreeControl<any>;
+    readonly navigationChange: EventEmitter<McTreeNavigationChange<McTreeOption>>;
+    readonly selectionChange: EventEmitter<McTreeSelectionChange<McTreeOption>>;
+    readonly onSelectAll: EventEmitter<McTreeSelectAllEvent<McTreeOption>>;
+    readonly onCopy: EventEmitter<McTreeCopyEvent<McTreeOption>>;
     private sortedNodes;
     get autoSelect(): boolean;
     set autoSelect(value: boolean);
@@ -54,23 +71,23 @@ export declare class McTreeSelection<T extends McTreeOption> extends CdkTree<T>
     private readonly destroy;
     private optionFocusSubscription;
     private optionBlurSubscription;
-    constructor(elementRef: ElementRef, differs: IterableDiffers, changeDetectorRef: ChangeDetectorRef, multiple: MultipleMode);
+    constructor(elementRef: ElementRef, differs: IterableDiffers, changeDetectorRef: ChangeDetectorRef, multiple: MultipleMode, clipboard: Clipboard);
     ngAfterContentInit(): void;
     ngOnDestroy(): void;
     focus($event: any): void;
     blur(): void;
     onKeyDown(event: KeyboardEvent): void;
     updateScrollSize(): void;
-    setSelectedOptionsByKey(option: T, shiftKey: boolean, ctrlKey: boolean): void;
-    setSelectedOptionsByClick(option: T, shiftKey: boolean, ctrlKey: boolean): void;
-    setSelectedOptions(option: T): void;
-    setFocusedOption(option: T): void;
+    setSelectedOptionsByKey(option: McTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+    setSelectedOptionsByClick(option: McTreeOption, shiftKey: boolean, ctrlKey: boolean): void;
+    setSelectedOptions(option: McTreeOption): void;
+    setFocusedOption(option: McTreeOption): void;
     toggleFocusedOption(): void;
-    renderNodeChanges(data: T[], dataDiffer?: IterableDiffer<T>, viewContainer?: ViewContainerRef, parentData?: T): void;
-    getHeight(): number;
-    getItemHeight(): number;
-    emitNavigationEvent(option: T): void;
-    emitChangeEvent(option: T): void;
+    renderNodeChanges(data: McTreeOption[], dataDiffer?: IterableDiffer<McTreeOption>, viewContainer?: ViewContainerRef, parentData?: McTreeOption): void;
+    emitNavigationEvent(option: McTreeOption): void;
+    emitChangeEvent(option: McTreeOption): void;
+    selectAllOptions(): void;
+    copyActiveOption(): void;
     writeValue(value: any): void;
     /** `View -> model callback called when value changes` */
     onChange: (value: any) => void;
@@ -84,7 +101,10 @@ export declare class McTreeSelection<T extends McTreeOption> extends CdkTree<T>
     setDisabledState(isDisabled: boolean): void;
     setOptionsFromValues(values: any[]): void;
     getSelectedValues(): any[];
-    protected updateTabIndex(): void;
+    getItemHeight(): number;
+    private onCopyDefaultHandler;
+    private getHeight;
+    private updateTabIndex;
     private updateRenderedOptions;
     private getSortedNodes;
     private allowFocusEscape;
@@ -103,5 +123,7 @@ export declare class McTreeSelection<T extends McTreeOption> extends CdkTree<T>
     private updateOptionsFocus;
     private canDeselectLast;
     private isFocusReceivedFromNestedOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeSelection, [null, null, null, { attribute: "multiple"; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTreeSelection, "mc-tree-selection", ["mcTreeSelection"], { "treeControl": "treeControl"; "autoSelect": "autoSelect"; "noUnselectLast": "noUnselectLast"; "disabled": "disabled"; "tabIndex": "tabIndex"; }, { "navigationChange": "navigationChange"; "selectionChange": "selectionChange"; "onSelectAll": "onSelectAll"; "onCopy": "onCopy"; }, ["unorderedOptions"], never>;
 }
 export {};

package/tree/tree.d.ts

@@ -0,0 +1,6 @@
+import { McTreeBase } from './tree-base';
+import * as i0 from "@angular/core";
+export declare class McTree extends McTreeBase<any> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTree, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<McTree, "mc-tree", ["mcTree"], {}, {}, never, never>;
+}

package/tree/tree.module.d.ts

@@ -1,2 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./outlet";
+import * as i2 from "./node";
+import * as i3 from "./tree-base";
+import * as i4 from "./padding.directive";
+import * as i5 from "./tree";
+import * as i6 from "./tree-selection.component";
+import * as i7 from "./tree-option.component";
+import * as i8 from "./toggle";
+import * as i9 from "@angular/common";
+import * as i10 from "@ptsecurity/mosaic/core";
 export declare class McTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<McTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<McTreeModule, [typeof i1.McTreeNodeOutlet, typeof i2.McTreeNodeDef, typeof i3.McTreeNode, typeof i4.McTreeNodePadding, typeof i5.McTree, typeof i6.McTreeSelection, typeof i7.McTreeOption, typeof i8.McTreeNodeToggleComponent, typeof i8.McTreeNodeToggleDirective], [typeof i9.CommonModule, typeof i10.McPseudoCheckboxModule], [typeof i1.McTreeNodeOutlet, typeof i2.McTreeNodeDef, typeof i3.McTreeNode, typeof i4.McTreeNodePadding, typeof i5.McTree, typeof i6.McTreeSelection, typeof i7.McTreeOption, typeof i8.McTreeNodeToggleComponent, typeof i8.McTreeNodeToggleDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<McTreeModule>;
 }

package/tree-select/package.json

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

package/tree-select/ptsecurity-mosaic-tree-select.d.ts

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