@angular/material 14.0.0-next.7 → 14.0.0-rc.0

package/tooltip/testing/index.d.ts

@@ -1,8 +1,42 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { AsyncFactoryFn } from '@angular/cdk/testing';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { TestElement } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-tooltip in tests. */
+export declare class MatTooltipHarness extends _MatTooltipHarnessBase {
+    protected _optionalPanel: AsyncFactoryFn<TestElement | null>;
+    protected _hiddenClass: string;
+    protected _showAnimationName: string;
+    protected _hideAnimationName: string;
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search
+     * for a tooltip trigger with specific attributes.
+     * @param options Options for narrowing the search.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TooltipHarnessFilters): HarnessPredicate<MatTooltipHarness>;
+}
+
+export declare abstract class _MatTooltipHarnessBase extends ComponentHarness {
+    protected abstract _optionalPanel: AsyncFactoryFn<TestElement | null>;
+    protected abstract _hiddenClass: string;
+    protected abstract _showAnimationName: string;
+    protected abstract _hideAnimationName: string;
+    /** Shows the tooltip. */
+    show(): Promise<void>;
+    /** Hides the tooltip. */
+    hide(): Promise<void>;
+    /** Gets whether the tooltip is open. */
+    isOpen(): Promise<boolean>;
+    /** Gets a promise for the tooltip panel's text. */
+    getTooltipText(): Promise<string>;
+}
+
+/** A set of criteria that can be used to filter a list of `MatTooltipHarness` instances. */
+export declare interface TooltipHarnessFilters extends BaseHarnessFilters {
+}
+
+export { }

package/tree/index.d.ts

@@ -1,8 +1,246 @@
+import { _AbstractConstructor } from '@angular/material/core';
+import { AfterContentInit } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import { CanDisable } from '@angular/material/core';
+import { CdkNestedTreeNode } from '@angular/cdk/tree';
+import { CdkTree } from '@angular/cdk/tree';
+import { CdkTreeNode } from '@angular/cdk/tree';
+import { CdkTreeNodeDef } from '@angular/cdk/tree';
+import { CdkTreeNodeOutlet } from '@angular/cdk/tree';
+import { CdkTreeNodePadding } from '@angular/cdk/tree';
+import { CdkTreeNodeToggle } from '@angular/cdk/tree';
+import { CollectionViewer } from '@angular/cdk/collections';
+import { _Constructor } from '@angular/material/core';
+import { DataSource } from '@angular/cdk/collections';
+import { ElementRef } from '@angular/core';
+import { FlatTreeControl } from '@angular/cdk/tree';
+import { HasTabIndex } from '@angular/material/core';
+import * as i0 from '@angular/core';
+import * as i6 from '@angular/cdk/tree';
+import * as i7 from '@angular/material/core';
+import { IterableDiffers } from '@angular/core';
+import { NumberInput } from '@angular/cdk/coercion';
+import { Observable } from 'rxjs';
+import { OnDestroy } from '@angular/core';
+import { OnInit } from '@angular/core';
+import { TreeControl } from '@angular/cdk/tree';
+import { ViewContainerRef } from '@angular/core';
+
+declare namespace i1 {
+    export {
+        MatTreeNode,
+        MatTreeNodeDef,
+        MatNestedTreeNode
+    }
+}
+
+declare namespace i2 {
+    export {
+        MatTreeNodePadding
+    }
+}
+
+declare namespace i3 {
+    export {
+        MatTreeNodeToggle
+    }
+}
+
+declare namespace i4 {
+    export {
+        MatTree
+    }
+}
+
+declare namespace i5 {
+    export {
+        MatTreeNodeOutlet
+    }
+}
+
 /**
- * @license
- * Copyright Google LLC All Rights Reserved.
+ * Wrapper for the CdkTree nested node with Material design styles.
+ */
+export declare class MatNestedTreeNode<T, K = T> extends CdkNestedTreeNode<T, K> implements AfterContentInit, OnDestroy, OnInit {
+    node: T;
+    /** Whether the node is disabled. */
+    get disabled(): boolean;
+    set disabled(value: BooleanInput);
+    private _disabled;
+    /** Tabindex for the node. */
+    get tabIndex(): number;
+    set tabIndex(value: number);
+    private _tabIndex;
+    constructor(elementRef: ElementRef<HTMLElement>, tree: CdkTree<T, K>, differs: IterableDiffers, tabIndex: string);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatNestedTreeNode<any, any>, [null, null, null, { attribute: "tabindex"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatNestedTreeNode<any, any>, "mat-nested-tree-node", ["matNestedTreeNode"], { "role": "role"; "disabled": "disabled"; "tabIndex": "tabIndex"; "node": "matNestedTreeNode"; }, {}, never, never, false>;
+}
+
+/**
+ * Wrapper for the CdkTable with Material design styles.
+ */
+export declare class MatTree<T, K = T> extends CdkTree<T, K> {
+    _nodeOutlet: MatTreeNodeOutlet;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTree<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MatTree<any, any>, "mat-tree", ["matTree"], {}, {}, never, never, false>;
+}
+
+/**
+ * Data source for flat tree.
+ * The data source need to handle expansion/collapsion of the tree node and change the data feed
+ * to `MatTree`.
+ * The nested tree nodes of type `T` are flattened through `MatTreeFlattener`, and converted
+ * to type `F` for `MatTree` to consume.
+ */
+export declare class MatTreeFlatDataSource<T, F, K = F> extends DataSource<F> {
+    private _treeControl;
+    private _treeFlattener;
+    private readonly _flattenedData;
+    private readonly _expandedData;
+    get data(): T[];
+    set data(value: T[]);
+    private readonly _data;
+    constructor(_treeControl: FlatTreeControl<F, K>, _treeFlattener: MatTreeFlattener<T, F, K>, initialData?: T[]);
+    connect(collectionViewer: CollectionViewer): Observable<F[]>;
+    disconnect(): void;
+}
+
+/**
+ * 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`.
  *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
+ * For example, the input data of type `T` is nested, and contains its children data:
+ *   SomeNode: {
+ *     key: 'Fruits',
+ *     children: [
+ *       NodeOne: {
+ *         key: 'Apple',
+ *       },
+ *       NodeTwo: {
+ *        key: 'Pear',
+ *      }
+ *    ]
+ *  }
+ *  After flattener flatten the tree, the structure will become
+ *  SomeNode: {
+ *    key: 'Fruits',
+ *    expandable: true,
+ *    level: 1
+ *  },
+ *  NodeOne: {
+ *    key: 'Apple',
+ *    expandable: false,
+ *    level: 2
+ *  },
+ *  NodeTwo: {
+ *   key: 'Pear',
+ *   expandable: false,
+ *   level: 2
+ * }
+ * and the output flattened type is `F` with additional information.
+ */
+export declare class MatTreeFlattener<T, F, K = F> {
+    transformFunction: (node: T, level: number) => F;
+    getLevel: (node: F) => number;
+    isExpandable: (node: F) => boolean;
+    getChildren: (node: T) => Observable<T[]> | T[] | undefined | null;
+    constructor(transformFunction: (node: T, level: number) => F, getLevel: (node: F) => number, isExpandable: (node: F) => boolean, getChildren: (node: T) => Observable<T[]> | T[] | undefined | null);
+    _flattenNode(node: T, level: number, resultNodes: F[], parentMap: boolean[]): F[];
+    _flattenChildren(children: T[], level: number, resultNodes: F[], parentMap: boolean[]): void;
+    /**
+     * Flatten a list of node type T to flattened version of node F.
+     * Please note that type T may be nested, and the length of `structuredData` may be different
+     * from that of returned list `F[]`.
+     */
+    flattenNodes(structuredData: T[]): F[];
+    /**
+     * Expand flattened node with current expansion status.
+     * The returned list may have different length.
+     */
+    expandFlattenedNodes(nodes: F[], treeControl: TreeControl<F, K>): F[];
+}
+
+export declare class MatTreeModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<MatTreeModule, [typeof i1.MatNestedTreeNode, typeof i1.MatTreeNodeDef, typeof i2.MatTreeNodePadding, typeof i3.MatTreeNodeToggle, typeof i4.MatTree, typeof i1.MatTreeNode, typeof i5.MatTreeNodeOutlet], [typeof i6.CdkTreeModule, typeof i7.MatCommonModule], [typeof i7.MatCommonModule, typeof i1.MatNestedTreeNode, typeof i1.MatTreeNodeDef, typeof i2.MatTreeNodePadding, typeof i3.MatTreeNodeToggle, typeof i4.MatTree, typeof i1.MatTreeNode, typeof i5.MatTreeNodeOutlet]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<MatTreeModule>;
+}
+
+/**
+ * Data source for nested tree.
+ *
+ * The data source for nested tree doesn't have to consider node flattener, or the way to expand
+ * or collapse. The expansion/collapsion will be handled by TreeControl and each non-leaf node.
+ */
+export declare class MatTreeNestedDataSource<T> extends DataSource<T> {
+    /**
+     * Data for the nested tree
+     */
+    get data(): T[];
+    set data(value: T[]);
+    private readonly _data;
+    connect(collectionViewer: CollectionViewer): Observable<T[]>;
+    disconnect(): void;
+}
+
+/**
+ * Wrapper for the CdkTree node with Material design styles.
+ */
+export declare class MatTreeNode<T, K = T> extends _MatTreeNodeBase<T, K> implements CanDisable, HasTabIndex, OnInit, OnDestroy {
+    constructor(elementRef: ElementRef<HTMLElement>, tree: CdkTree<T, K>, tabIndex: string);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNode<any, any>, [null, null, { attribute: "tabindex"; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTreeNode<any, any>, "mat-tree-node", ["matTreeNode"], { "role": "role"; "disabled": "disabled"; "tabIndex": "tabIndex"; }, {}, never, never, false>;
+}
+
+declare const _MatTreeNodeBase: _Constructor<HasTabIndex> & _AbstractConstructor<HasTabIndex> & _Constructor<CanDisable> & _AbstractConstructor<CanDisable> & typeof CdkTreeNode;
+
+/**
+ * Wrapper for the CdkTree node definition with Material design styles.
+ * Captures the node's template and a when predicate that describes when this node should be used.
+ */
+export declare class MatTreeNodeDef<T> extends CdkTreeNodeDef<T> {
+    data: T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTreeNodeDef<any>, "[matTreeNodeDef]", never, { "when": "matTreeNodeDefWhen"; "data": "matTreeNode"; }, {}, never, never, false>;
+}
+
+/**
+ * Outlet for nested CdkNode. Put `[matTreeNodeOutlet]` on a tag to place children dataNodes
+ * inside the outlet.
+ */
+export declare class MatTreeNodeOutlet implements CdkTreeNodeOutlet {
+    viewContainer: ViewContainerRef;
+    _node?: any;
+    constructor(viewContainer: ViewContainerRef, _node?: any);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNodeOutlet, [null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTreeNodeOutlet, "[matTreeNodeOutlet]", never, {}, {}, never, never, false>;
+}
+
+/**
+ * Wrapper for the CdkTree padding with Material design styles.
+ */
+export declare class MatTreeNodePadding<T, K = T> extends CdkTreeNodePadding<T, K> {
+    /** The level of depth of the tree node. The padding will be `level * indent` pixels. */
+    get level(): number;
+    set level(value: NumberInput);
+    /** The indent for each level. Default number 40px from material design menu sub-menu spec. */
+    get indent(): number | string;
+    set indent(indent: number | string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNodePadding<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTreeNodePadding<any, any>, "[matTreeNodePadding]", never, { "level": "matTreeNodePadding"; "indent": "matTreeNodePaddingIndent"; }, {}, never, never, false>;
+}
+
+/**
+ * Wrapper for the CdkTree's toggle with Material design styles.
  */
-export * from './public-api';
+export declare class MatTreeNodeToggle<T, K = T> extends CdkTreeNodeToggle<T, K> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<MatTreeNodeToggle<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MatTreeNodeToggle<any, any>, "[matTreeNodeToggle]", never, { "recursive": "matTreeNodeToggleRecursive"; }, {}, never, never, false>;
+}
+
+export { }

package/tree/testing/index.d.ts

@@ -1,8 +1,122 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-export * from './public-api';
+import { AsyncFactoryFn } from '@angular/cdk/testing';
+import { BaseHarnessFilters } from '@angular/cdk/testing';
+import { ComponentHarness } from '@angular/cdk/testing';
+import { ContentContainerComponentHarness } from '@angular/cdk/testing';
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { TestElement } from '@angular/cdk/testing';
+
+/** Harness for interacting with a standard mat-tree in tests. */
+export declare class MatTreeHarness extends ComponentHarness {
+    /** The selector for the host element of a `MatTableHarness` instance. */
+    static hostSelector: string;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TreeHarnessFilters): HarnessPredicate<MatTreeHarness>;
+    /** Gets all of the nodes in the tree. */
+    getNodes(filter?: TreeNodeHarnessFilters): Promise<MatTreeNodeHarness[]>;
+    /**
+     * Gets an object representation for the visible tree structure
+     * If a node is under an unexpanded node it will not be included.
+     * Eg.
+     * Tree (all nodes expanded):
+     * `
+     * <mat-tree>
+     *   <mat-tree-node>Node 1<mat-tree-node>
+     *   <mat-nested-tree-node>
+     *     Node 2
+     *     <mat-nested-tree-node>
+     *       Node 2.1
+     *       <mat-tree-node>
+     *         Node 2.1.1
+     *       <mat-tree-node>
+     *     <mat-nested-tree-node>
+     *     <mat-tree-node>
+     *       Node 2.2
+     *     <mat-tree-node>
+     *   <mat-nested-tree-node>
+     * </mat-tree>`
+     *
+     * Tree structure:
+     * {
+     *  children: [
+     *    {
+     *      text: 'Node 1',
+     *      children: [
+     *        {
+     *          text: 'Node 2',
+     *          children: [
+     *            {
+     *              text: 'Node 2.1',
+     *              children: [{text: 'Node 2.1.1'}]
+     *            },
+     *            {text: 'Node 2.2'}
+     *          ]
+     *        }
+     *      ]
+     *    }
+     *  ]
+     * };
+     */
+    getTreeStructure(): Promise<TextTree>;
+    /**
+     * Recursively collect the structured text of the tree nodes.
+     * @param nodes A list of tree nodes
+     * @param level The level of nodes that are being accounted for during this iteration
+     * @param parentExpanded Whether the parent of the first node in param nodes is expanded
+     */
+    private _getTreeStructure;
+    private _addChildToNode;
+}
+
+/** Harness for interacting with a standard Angular Material tree node. */
+export declare class MatTreeNodeHarness extends ContentContainerComponentHarness<string> {
+    /** The selector of the host element of a `MatTreeNode` instance. */
+    static hostSelector: string;
+    _toggle: AsyncFactoryFn<TestElement | null>;
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a tree node with specific attributes.
+     * @param options Options for narrowing the search
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options?: TreeNodeHarnessFilters): HarnessPredicate<MatTreeNodeHarness>;
+    /** Whether the tree node is expanded. */
+    isExpanded(): Promise<boolean>;
+    /** Whether the tree node is disabled. */
+    isDisabled(): Promise<boolean>;
+    /** Gets the level of the tree node. Note that this gets the aria-level and is 1 indexed. */
+    getLevel(): Promise<number>;
+    /** Gets the tree node's text. */
+    getText(): Promise<string>;
+    /** Toggles node between expanded/collapsed. Only works when node is not disabled. */
+    toggle(): Promise<void>;
+    /** Expands the node if it is collapsed. Only works when node is not disabled. */
+    expand(): Promise<void>;
+    /** Collapses the node if it is expanded. Only works when node is not disabled. */
+    collapse(): Promise<void>;
+}
+
+export declare type TextTree = {
+    text?: string;
+    children?: TextTree[];
+};
+
+/** A set of criteria that can be used to filter a list of tree harness instances */
+export declare interface TreeHarnessFilters extends BaseHarnessFilters {
+}
+
+/** A set of criteria that can be used to filter a list of node harness instances. */
+export declare interface TreeNodeHarnessFilters extends BaseHarnessFilters {
+    /** Only find instances whose text matches the given value. */
+    text?: string | RegExp;
+    /** Only find instances whose disabled state matches the given value. */
+    disabled?: boolean;
+    /** Only find instances whose expansion state matches the given value. */
+    expanded?: boolean;
+    /** Only find instances whose level matches the given value. */
+    level?: number;
+}
+
+export { }

package/autocomplete/autocomplete-module.d.ts

@@ -1,13 +0,0 @@
-import * as i0 from "@angular/core";
-import * as i1 from "./autocomplete";
-import * as i2 from "./autocomplete-trigger";
-import * as i3 from "./autocomplete-origin";
-import * as i4 from "@angular/cdk/overlay";
-import * as i5 from "@angular/material/core";
-import * as i6 from "@angular/common";
-import * as i7 from "@angular/cdk/scrolling";
-export declare class MatAutocompleteModule {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatAutocompleteModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<MatAutocompleteModule, [typeof i1.MatAutocomplete, typeof i2.MatAutocompleteTrigger, typeof i3.MatAutocompleteOrigin], [typeof i4.OverlayModule, typeof i5.MatOptionModule, typeof i5.MatCommonModule, typeof i6.CommonModule], [typeof i1.MatAutocomplete, typeof i2.MatAutocompleteTrigger, typeof i3.MatAutocompleteOrigin, typeof i7.CdkScrollableModule, typeof i5.MatOptionModule, typeof i5.MatCommonModule]>;
-    static ɵinj: i0.ɵɵInjectorDeclaration<MatAutocompleteModule>;
-}

package/autocomplete/autocomplete-origin.d.ts

@@ -1,27 +0,0 @@
-/**
- * @license
- * Copyright Google LLC All Rights Reserved.
- *
- * Use of this source code is governed by an MIT-style license that can be
- * found in the LICENSE file at https://angular.io/license
- */
-import { ElementRef } from '@angular/core';
-import * as i0 from "@angular/core";
-/** Base class containing all of the functionality for `MatAutocompleteOrigin`. */
-export declare abstract class _MatAutocompleteOriginBase {
-    /** Reference to the element on which the directive is applied. */
-    elementRef: ElementRef<HTMLElement>;
-    constructor(
-    /** Reference to the element on which the directive is applied. */
-    elementRef: ElementRef<HTMLElement>);
-    static ɵfac: i0.ɵɵFactoryDeclaration<_MatAutocompleteOriginBase, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<_MatAutocompleteOriginBase, never, never, {}, {}, never>;
-}
-/**
- * Directive applied to an element to make it usable
- * as a connection point for an autocomplete panel.
- */
-export declare class MatAutocompleteOrigin extends _MatAutocompleteOriginBase {
-    static ɵfac: i0.ɵɵFactoryDeclaration<MatAutocompleteOrigin, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<MatAutocompleteOrigin, "[matAutocompleteOrigin]", ["matAutocompleteOrigin"], {}, {}, never>;
-}