@angular/material 13.0.0-next.4 → 13.0.0-next.8

package/esm2020/list/testing/action-list-harness.mjs

@@ -0,0 +1,59 @@
+/**
+ * @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 { HarnessPredicate } from '@angular/cdk/testing';
+import { MatListHarnessBase } from './list-harness-base';
+import { getListItemPredicate, MatListItemHarnessBase } from './list-item-harness-base';
+/** Harness for interacting with a standard mat-action-list in tests. */
+export class MatActionListHarness extends MatListHarnessBase {
+    constructor() {
+        super(...arguments);
+        this._itemHarness = MatActionListItemHarness;
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatActionListHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which action list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatActionListHarness, options);
+    }
+}
+/** The selector for the host element of a `MatActionList` instance. */
+MatActionListHarness.hostSelector = 'mat-action-list.mat-list';
+/** Harness for interacting with an action list item. */
+export class MatActionListItemHarness extends MatListItemHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatActionListItemHarness` that
+     * meets certain criteria.
+     * @param options Options for filtering which action list item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getListItemPredicate(MatActionListItemHarness, options);
+    }
+    /** Clicks on the action list item. */
+    async click() {
+        return (await this.host()).click();
+    }
+    /** Focuses the action list item. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Blurs the action list item. */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the action list item is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+}
+/** The selector for the host element of a `MatListItem` instance. */
+MatActionListItemHarness.hostSelector = `${MatActionListHarness.hostSelector} .mat-list-item`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/list/testing/list-harness-base.mjs

@@ -0,0 +1,88 @@
+/**
+ * @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 { ComponentHarness, parallel } from '@angular/cdk/testing';
+import { MatDividerHarness } from '@angular/material/divider/testing';
+import { MatSubheaderHarness } from './list-item-harness-base';
+/**
+ * Shared behavior among the harnesses for the various `MatList` flavors.
+ * @template T A constructor type for a list item harness type used by this list harness.
+ * @template C The list item harness type that `T` constructs.
+ * @template F The filter type used filter list item harness of type `C`.
+ * @docs-private
+ */
+export class MatListHarnessBase extends ComponentHarness {
+    /**
+     * Gets a list of harnesses representing the items in this list.
+     * @param filters Optional filters used to narrow which harnesses are included
+     * @return The list of items matching the given filters.
+     */
+    async getItems(filters) {
+        return this.locatorForAll(this._itemHarness.with(filters))();
+    }
+    /**
+     * Gets a list of `ListSection` representing the list items grouped by subheaders. If the list has
+     * no subheaders it is represented as a single `ListSection` with an undefined `heading` property.
+     * @param filters Optional filters used to narrow which list item harnesses are included
+     * @return The list of items matching the given filters, grouped into sections by subheader.
+     */
+    async getItemsGroupedBySubheader(filters) {
+        const listSections = [];
+        let currentSection = { items: [] };
+        const itemsAndSubheaders = await this.getItemsWithSubheadersAndDividers({ item: filters, divider: false });
+        for (const itemOrSubheader of itemsAndSubheaders) {
+            if (itemOrSubheader instanceof MatSubheaderHarness) {
+                if (currentSection.heading !== undefined || currentSection.items.length) {
+                    listSections.push(currentSection);
+                }
+                currentSection = { heading: itemOrSubheader.getText(), items: [] };
+            }
+            else {
+                currentSection.items.push(itemOrSubheader);
+            }
+        }
+        if (currentSection.heading !== undefined || currentSection.items.length ||
+            !listSections.length) {
+            listSections.push(currentSection);
+        }
+        // Concurrently wait for all sections to resolve their heading if present.
+        return parallel(() => listSections.map(async (s) => ({ items: s.items, heading: await s.heading })));
+    }
+    /**
+     * Gets a list of sub-lists representing the list items grouped by dividers. If the list has no
+     * dividers it is represented as a list with a single sub-list.
+     * @param filters Optional filters used to narrow which list item harnesses are included
+     * @return The list of items matching the given filters, grouped into sub-lists by divider.
+     */
+    async getItemsGroupedByDividers(filters) {
+        const listSections = [[]];
+        const itemsAndDividers = await this.getItemsWithSubheadersAndDividers({ item: filters, subheader: false });
+        for (const itemOrDivider of itemsAndDividers) {
+            if (itemOrDivider instanceof MatDividerHarness) {
+                listSections.push([]);
+            }
+            else {
+                listSections[listSections.length - 1].push(itemOrDivider);
+            }
+        }
+        return listSections;
+    }
+    async getItemsWithSubheadersAndDividers(filters = {}) {
+        const query = [];
+        if (filters.item !== false) {
+            query.push(this._itemHarness.with(filters.item || {}));
+        }
+        if (filters.subheader !== false) {
+            query.push(MatSubheaderHarness.with(filters.subheader));
+        }
+        if (filters.divider !== false) {
+            query.push(MatDividerHarness.with(filters.divider));
+        }
+        return this.locatorForAll(...query)();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"list-harness-base.js","sourceRoot":"","sources":["../../../../../../../src/material/list/testing/list-harness-base.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {\n  ComponentHarness,\n  ComponentHarnessConstructor,\n  HarnessPredicate,\n  parallel\n} from '@angular/cdk/testing';\nimport {DividerHarnessFilters, MatDividerHarness} from '@angular/material/divider/testing';\nimport {BaseListItemHarnessFilters, SubheaderHarnessFilters} from './list-harness-filters';\nimport {MatSubheaderHarness} from './list-item-harness-base';\n\n/** Represents a section of a list falling under a specific header. */\nexport interface ListSection<I> {\n  /** The heading for this list section. `undefined` if there is no heading. */\n  heading?: string;\n\n  /** The items in this list section. */\n  items: I[];\n}\n\n/**\n * Shared behavior among the harnesses for the various `MatList` flavors.\n * @template T A constructor type for a list item harness type used by this list harness.\n * @template C The list item harness type that `T` constructs.\n * @template F The filter type used filter list item harness of type `C`.\n * @docs-private\n */\nexport abstract class MatListHarnessBase\n    <\n      T extends (ComponentHarnessConstructor<C> & {with: (options?: F) => HarnessPredicate<C>}),\n      C extends ComponentHarness,\n      F extends BaseListItemHarnessFilters\n    > extends ComponentHarness {\n  protected _itemHarness: T;\n\n  /**\n   * Gets a list of harnesses representing the items in this list.\n   * @param filters Optional filters used to narrow which harnesses are included\n   * @return The list of items matching the given filters.\n   */\n  async getItems(filters?: F): Promise<C[]> {\n    return this.locatorForAll(this._itemHarness.with(filters))();\n  }\n\n  /**\n   * Gets a list of `ListSection` representing the list items grouped by subheaders. If the list has\n   * no subheaders it is represented as a single `ListSection` with an undefined `heading` property.\n   * @param filters Optional filters used to narrow which list item harnesses are included\n   * @return The list of items matching the given filters, grouped into sections by subheader.\n   */\n  async getItemsGroupedBySubheader(filters?: F): Promise<ListSection<C>[]> {\n    type Section = {items: C[], heading?: Promise<string>};\n    const listSections: Section[] = [];\n    let currentSection: Section = {items: []};\n    const itemsAndSubheaders =\n        await this.getItemsWithSubheadersAndDividers({item: filters, divider: false});\n    for (const itemOrSubheader of itemsAndSubheaders) {\n      if (itemOrSubheader instanceof MatSubheaderHarness) {\n        if (currentSection.heading !== undefined || currentSection.items.length) {\n          listSections.push(currentSection);\n        }\n        currentSection = {heading: itemOrSubheader.getText(), items: []};\n      } else {\n        currentSection.items.push(itemOrSubheader);\n      }\n    }\n    if (currentSection.heading !== undefined || currentSection.items.length ||\n        !listSections.length) {\n      listSections.push(currentSection);\n    }\n\n    // Concurrently wait for all sections to resolve their heading if present.\n    return parallel(() => listSections.map(async (s) =>\n      ({items: s.items, heading: await s.heading})));\n  }\n\n  /**\n   * Gets a list of sub-lists representing the list items grouped by dividers. If the list has no\n   * dividers it is represented as a list with a single sub-list.\n   * @param filters Optional filters used to narrow which list item harnesses are included\n   * @return The list of items matching the given filters, grouped into sub-lists by divider.\n   */\n  async getItemsGroupedByDividers(filters?: F): Promise<C[][]> {\n    const listSections: C[][] = [[]];\n    const itemsAndDividers =\n        await this.getItemsWithSubheadersAndDividers({item: filters, subheader: false});\n    for (const itemOrDivider of itemsAndDividers) {\n      if (itemOrDivider instanceof MatDividerHarness) {\n        listSections.push([]);\n      } else {\n        listSections[listSections.length - 1].push(itemOrDivider);\n      }\n    }\n    return listSections;\n  }\n\n  /**\n   * Gets a list of harnesses representing all of the items, subheaders, and dividers\n   * (in the order they appear in the list). Use `instanceof` to check which type of harness a given\n   * item is.\n   * @param filters Optional filters used to narrow which list items, subheaders, and dividers are\n   *     included. A value of `false` for the `item`, `subheader`, or `divider` properties indicates\n   *     that the respective harness type should be omitted completely.\n   * @return The list of harnesses representing the items, subheaders, and dividers matching the\n   *     given filters.\n   */\n  getItemsWithSubheadersAndDividers(filters: {\n    item: false,\n    subheader: false,\n    divider: false\n  }): Promise<[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item?: F | false,\n    subheader: false,\n    divider: false\n  }): Promise<C[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item: false,\n    subheader?: SubheaderHarnessFilters | false,\n    divider: false\n  }): Promise<MatSubheaderHarness[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item: false,\n    subheader: false,\n    divider?: DividerHarnessFilters | false\n  }): Promise<MatDividerHarness[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item?: F | false,\n    subheader?: SubheaderHarnessFilters | false,\n    divider: false\n  }): Promise<(C | MatSubheaderHarness)[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item?: F | false,\n    subheader: false,\n    divider?: false | DividerHarnessFilters\n  }): Promise<(C | MatDividerHarness)[]>;\n  getItemsWithSubheadersAndDividers(filters: {\n    item: false,\n    subheader?: false | SubheaderHarnessFilters,\n    divider?: false | DividerHarnessFilters\n  }): Promise<(MatSubheaderHarness | MatDividerHarness)[]>;\n  getItemsWithSubheadersAndDividers(filters?: {\n    item?: F | false,\n    subheader?: SubheaderHarnessFilters | false,\n    divider?: DividerHarnessFilters | false\n  }): Promise<(C | MatSubheaderHarness | MatDividerHarness)[]>;\n  async getItemsWithSubheadersAndDividers(filters: {\n    item?: F | false,\n    subheader?: SubheaderHarnessFilters | false,\n    divider?: DividerHarnessFilters | false\n  } = {}): Promise<(C | MatSubheaderHarness | MatDividerHarness)[]> {\n    const query = [];\n    if (filters.item !== false) {\n      query.push(this._itemHarness.with(filters.item || {} as F));\n    }\n    if (filters.subheader !== false) {\n      query.push(MatSubheaderHarness.with(filters.subheader));\n    }\n    if (filters.divider !== false) {\n      query.push(MatDividerHarness.with(filters.divider));\n    }\n    return this.locatorForAll(...query)();\n  }\n}\n"]}

package/esm2020/list/testing/list-item-harness-base.mjs

@@ -0,0 +1,72 @@
+/**
+ * @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 { ComponentHarness, HarnessPredicate, ContentContainerComponentHarness, parallel, } from '@angular/cdk/testing';
+const iconSelector = '.mat-list-icon';
+const avatarSelector = '.mat-list-avatar';
+/**
+ * Gets a `HarnessPredicate` that applies the given `BaseListItemHarnessFilters` to the given
+ * list item harness.
+ * @template H The type of list item harness to create a predicate for.
+ * @param harnessType A constructor for a list item harness.
+ * @param options An instance of `BaseListItemHarnessFilters` to apply.
+ * @return A `HarnessPredicate` for the given harness type with the given options applied.
+ */
+export function getListItemPredicate(harnessType, options) {
+    return new HarnessPredicate(harnessType, options)
+        .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text));
+}
+/** Harness for interacting with a list subheader. */
+export class MatSubheaderHarness extends ComponentHarness {
+    static with(options = {}) {
+        return new HarnessPredicate(MatSubheaderHarness, options)
+            .addOption('text', options.text, (harness, text) => HarnessPredicate.stringMatches(harness.getText(), text));
+    }
+    /** Gets the full text content of the list item (including text from any font icons). */
+    async getText() {
+        return (await this.host()).text();
+    }
+}
+MatSubheaderHarness.hostSelector = '.mat-subheader';
+/**
+ * Shared behavior among the harnesses for the various `MatListItem` flavors.
+ * @docs-private
+ */
+export class MatListItemHarnessBase extends ContentContainerComponentHarness {
+    constructor() {
+        super(...arguments);
+        this._lines = this.locatorForAll('.mat-line');
+        this._avatar = this.locatorForOptional(avatarSelector);
+        this._icon = this.locatorForOptional(iconSelector);
+    }
+    /** Gets the full text content of the list item. */
+    async getText() {
+        return (await this.host()).text({ exclude: `${iconSelector}, ${avatarSelector}` });
+    }
+    /** Gets the lines of text (`mat-line` elements) in this nav list item. */
+    async getLinesText() {
+        const lines = await this._lines();
+        return parallel(() => lines.map(l => l.text()));
+    }
+    /** Whether this list item has an avatar. */
+    async hasAvatar() {
+        return !!await this._avatar();
+    }
+    /** Whether this list item has an icon. */
+    async hasIcon() {
+        return !!await this._icon();
+    }
+    /**
+     * Gets a `HarnessLoader` used to get harnesses within the list item's content.
+     * @deprecated Use `getChildLoader(MatListItemSection.CONTENT)` or `getHarness` instead.
+     * @breaking-change 12.0.0
+     */
+    async getHarnessLoaderForContent() {
+        return this.getChildLoader(".mat-list-item-content" /* CONTENT */);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/list/testing/nav-list-harness.mjs

@@ -0,0 +1,64 @@
+/**
+ * @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 { HarnessPredicate } from '@angular/cdk/testing';
+import { MatListHarnessBase } from './list-harness-base';
+import { getListItemPredicate, MatListItemHarnessBase } from './list-item-harness-base';
+/** Harness for interacting with a standard mat-nav-list in tests. */
+export class MatNavListHarness extends MatListHarnessBase {
+    constructor() {
+        super(...arguments);
+        this._itemHarness = MatNavListItemHarness;
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatNavListHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which nav list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatNavListHarness, options);
+    }
+}
+/** The selector for the host element of a `MatNavList` instance. */
+MatNavListHarness.hostSelector = '.mat-nav-list';
+/** Harness for interacting with a nav list item. */
+export class MatNavListItemHarness extends MatListItemHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatNavListItemHarness` that
+     * meets certain criteria.
+     * @param options Options for filtering which nav list item instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getListItemPredicate(MatNavListItemHarness, options)
+            .addOption('href', options.href, async (harness, href) => HarnessPredicate.stringMatches(harness.getHref(), href));
+    }
+    /** Gets the href for this nav list item. */
+    async getHref() {
+        return (await this.host()).getAttribute('href');
+    }
+    /** Clicks on the nav list item. */
+    async click() {
+        return (await this.host()).click();
+    }
+    /** Focuses the nav list item. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Blurs the nav list item. */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the nav list item is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+}
+/** The selector for the host element of a `MatListItem` instance. */
+MatNavListItemHarness.hostSelector = `${MatNavListHarness.hostSelector} .mat-list-item`;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/list/testing/selection-list-harness.mjs

@@ -0,0 +1,125 @@
+/**
+ * @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 { HarnessPredicate, parallel } from '@angular/cdk/testing';
+import { MatListHarnessBase } from './list-harness-base';
+import { getListItemPredicate, MatListItemHarnessBase } from './list-item-harness-base';
+/** Harness for interacting with a standard mat-selection-list in tests. */
+export class MatSelectionListHarness extends MatListHarnessBase {
+    constructor() {
+        super(...arguments);
+        this._itemHarness = MatListOptionHarness;
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatSelectionListHarness` that meets
+     * certain criteria.
+     * @param options Options for filtering which selection list instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatSelectionListHarness, options);
+    }
+    /** Whether the selection list is disabled. */
+    async isDisabled() {
+        return await (await this.host()).getAttribute('aria-disabled') === 'true';
+    }
+    /**
+     * Selects all items matching any of the given filters.
+     * @param filters Filters that specify which items should be selected.
+     */
+    async selectItems(...filters) {
+        const items = await this._getItems(filters);
+        await parallel(() => items.map(item => item.select()));
+    }
+    /**
+     * Deselects all items matching any of the given filters.
+     * @param filters Filters that specify which items should be deselected.
+     */
+    async deselectItems(...filters) {
+        const items = await this._getItems(filters);
+        await parallel(() => items.map(item => item.deselect()));
+    }
+    /** Gets all items matching the given list of filters. */
+    async _getItems(filters) {
+        if (!filters.length) {
+            return this.getItems();
+        }
+        const matches = await parallel(() => {
+            return filters.map(filter => this.locatorForAll(MatListOptionHarness.with(filter))());
+        });
+        return matches.reduce((result, current) => [...result, ...current], []);
+    }
+}
+/** The selector for the host element of a `MatSelectionList` instance. */
+MatSelectionListHarness.hostSelector = '.mat-selection-list';
+/** Harness for interacting with a list option. */
+export class MatListOptionHarness extends MatListItemHarnessBase {
+    constructor() {
+        super(...arguments);
+        this._itemContent = this.locatorFor('.mat-list-item-content');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatListOptionHarness` that
+     * meets certain criteria.
+     * @param options Options for filtering which list option instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getListItemPredicate(MatListOptionHarness, options)
+            .addOption('is selected', options.selected, async (harness, selected) => await harness.isSelected() === selected);
+    }
+    /** Gets the position of the checkbox relative to the list option content. */
+    async getCheckboxPosition() {
+        return await (await this._itemContent()).hasClass('mat-list-item-content-reverse') ?
+            'after' : 'before';
+    }
+    /** Whether the list option is selected. */
+    async isSelected() {
+        return await (await this.host()).getAttribute('aria-selected') === 'true';
+    }
+    /** Whether the list option is disabled. */
+    async isDisabled() {
+        return await (await this.host()).getAttribute('aria-disabled') === 'true';
+    }
+    /** Focuses the list option. */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /** Blurs the list option. */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the list option is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /** Toggles the checked state of the checkbox. */
+    async toggle() {
+        return (await this.host()).click();
+    }
+    /**
+     * Puts the list option in a checked state by toggling it if it is currently unchecked, or doing
+     * nothing if it is already checked.
+     */
+    async select() {
+        if (!await this.isSelected()) {
+            return this.toggle();
+        }
+    }
+    /**
+     * Puts the list option in an unchecked state by toggling it if it is currently checked, or doing
+     * nothing if it is already unchecked.
+     */
+    async deselect() {
+        if (await this.isSelected()) {
+            return this.toggle();
+        }
+    }
+}
+/** The selector for the host element of a `MatListOption` instance. */
+MatListOptionHarness.hostSelector = '.mat-list-option';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selection-list-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/list/testing/selection-list-harness.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {MatListOptionCheckboxPosition} from '@angular/material/list';\nimport {MatListHarnessBase} from './list-harness-base';\nimport {\n  ListItemHarnessFilters,\n  ListOptionHarnessFilters,\n  SelectionListHarnessFilters\n} from './list-harness-filters';\nimport {getListItemPredicate, MatListItemHarnessBase} from './list-item-harness-base';\n\n/** Harness for interacting with a standard mat-selection-list in tests. */\nexport class MatSelectionListHarness extends MatListHarnessBase<\n    typeof MatListOptionHarness, MatListOptionHarness, ListOptionHarnessFilters> {\n  /** The selector for the host element of a `MatSelectionList` instance. */\n  static hostSelector = '.mat-selection-list';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatSelectionListHarness` that meets\n   * certain criteria.\n   * @param options Options for filtering which selection list instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: SelectionListHarnessFilters = {}):\n      HarnessPredicate<MatSelectionListHarness> {\n    return new HarnessPredicate(MatSelectionListHarness, options);\n  }\n\n  override _itemHarness = MatListOptionHarness;\n\n  /** Whether the selection list is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return await (await this.host()).getAttribute('aria-disabled') === 'true';\n  }\n\n  /**\n   * Selects all items matching any of the given filters.\n   * @param filters Filters that specify which items should be selected.\n   */\n  async selectItems(...filters: ListOptionHarnessFilters[]): Promise<void> {\n    const items = await this._getItems(filters);\n    await parallel(() => items.map(item => item.select()));\n  }\n\n  /**\n   * Deselects all items matching any of the given filters.\n   * @param filters Filters that specify which items should be deselected.\n   */\n  async deselectItems(...filters: ListItemHarnessFilters[]): Promise<void> {\n    const items = await this._getItems(filters);\n    await parallel(() => items.map(item => item.deselect()));\n  }\n\n  /** Gets all items matching the given list of filters. */\n  private async _getItems(filters: ListOptionHarnessFilters[]): Promise<MatListOptionHarness[]> {\n    if (!filters.length) {\n      return this.getItems();\n    }\n    const matches = await parallel(() => {\n      return filters.map(filter => this.locatorForAll(MatListOptionHarness.with(filter))());\n    });\n    return matches.reduce((result, current) => [...result, ...current], []);\n  }\n}\n\n/** Harness for interacting with a list option. */\nexport class MatListOptionHarness extends MatListItemHarnessBase {\n  /** The selector for the host element of a `MatListOption` instance. */\n  static hostSelector = '.mat-list-option';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatListOptionHarness` that\n   * meets certain criteria.\n   * @param options Options for filtering which list option instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: ListOptionHarnessFilters = {}): HarnessPredicate<MatListOptionHarness> {\n    return getListItemPredicate(MatListOptionHarness, options)\n        .addOption('is selected', options.selected,\n            async (harness, selected) => await harness.isSelected() === selected);\n  }\n\n  private _itemContent = this.locatorFor('.mat-list-item-content');\n\n  /** Gets the position of the checkbox relative to the list option content. */\n  async getCheckboxPosition(): Promise<MatListOptionCheckboxPosition> {\n    return await (await this._itemContent()).hasClass('mat-list-item-content-reverse') ?\n        'after' : 'before';\n  }\n\n  /** Whether the list option is selected. */\n  async isSelected(): Promise<boolean> {\n    return await (await this.host()).getAttribute('aria-selected') === 'true';\n  }\n\n  /** Whether the list option is disabled. */\n  async isDisabled(): Promise<boolean> {\n    return await (await this.host()).getAttribute('aria-disabled') === 'true';\n  }\n\n  /** Focuses the list option. */\n  async focus(): Promise<void> {\n    return (await this.host()).focus();\n  }\n\n  /** Blurs the list option. */\n  async blur(): Promise<void> {\n    return (await this.host()).blur();\n  }\n\n  /** Whether the list option is focused. */\n  async isFocused(): Promise<boolean> {\n    return (await this.host()).isFocused();\n  }\n\n  /** Toggles the checked state of the checkbox. */\n  async toggle() {\n    return (await this.host()).click();\n  }\n\n  /**\n   * Puts the list option in a checked state by toggling it if it is currently unchecked, or doing\n   * nothing if it is already checked.\n   */\n  async select() {\n    if (!await this.isSelected()) {\n      return this.toggle();\n    }\n  }\n\n  /**\n   * Puts the list option in an unchecked state by toggling it if it is currently checked, or doing\n   * nothing if it is already unchecked.\n   */\n  async deselect() {\n    if (await this.isSelected()) {\n      return this.toggle();\n    }\n  }\n}\n"]}

package/esm2020/menu/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvbWF0ZXJpYWwvbWVudS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2020/menu/menu-content.mjs

@@ -0,0 +1,97 @@
+/**
+ * @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 { DomPortalOutlet, TemplatePortal } from '@angular/cdk/portal';
+import { DOCUMENT } from '@angular/common';
+import { ApplicationRef, ChangeDetectorRef, ComponentFactoryResolver, Directive, Inject, InjectionToken, Injector, TemplateRef, ViewContainerRef, } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+/**
+ * Injection token that can be used to reference instances of `MatMenuContent`. It serves
+ * as alternative token to the actual `MatMenuContent` class which could cause unnecessary
+ * retention of the class and its directive metadata.
+ */
+export const MAT_MENU_CONTENT = new InjectionToken('MatMenuContent');
+export class _MatMenuContentBase {
+    constructor(_template, _componentFactoryResolver, _appRef, _injector, _viewContainerRef, _document, _changeDetectorRef) {
+        this._template = _template;
+        this._componentFactoryResolver = _componentFactoryResolver;
+        this._appRef = _appRef;
+        this._injector = _injector;
+        this._viewContainerRef = _viewContainerRef;
+        this._document = _document;
+        this._changeDetectorRef = _changeDetectorRef;
+        /** Emits when the menu content has been attached. */
+        this._attached = new Subject();
+    }
+    /**
+     * Attaches the content with a particular context.
+     * @docs-private
+     */
+    attach(context = {}) {
+        if (!this._portal) {
+            this._portal = new TemplatePortal(this._template, this._viewContainerRef);
+        }
+        this.detach();
+        if (!this._outlet) {
+            this._outlet = new DomPortalOutlet(this._document.createElement('div'), this._componentFactoryResolver, this._appRef, this._injector);
+        }
+        const element = this._template.elementRef.nativeElement;
+        // Because we support opening the same menu from different triggers (which in turn have their
+        // own `OverlayRef` panel), we have to re-insert the host element every time, otherwise we
+        // risk it staying attached to a pane that's no longer in the DOM.
+        element.parentNode.insertBefore(this._outlet.outletElement, element);
+        // When `MatMenuContent` is used in an `OnPush` component, the insertion of the menu
+        // content via `createEmbeddedView` does not cause the content to be seen as "dirty"
+        // by Angular. This causes the `@ContentChildren` for menu items within the menu to
+        // not be updated by Angular. By explicitly marking for check here, we tell Angular that
+        // it needs to check for new menu items and update the `@ContentChild` in `MatMenu`.
+        // @breaking-change 9.0.0 Make change detector ref required
+        if (this._changeDetectorRef) {
+            this._changeDetectorRef.markForCheck();
+        }
+        this._portal.attach(this._outlet, context);
+        this._attached.next();
+    }
+    /**
+     * Detaches the content.
+     * @docs-private
+     */
+    detach() {
+        if (this._portal.isAttached) {
+            this._portal.detach();
+        }
+    }
+    ngOnDestroy() {
+        if (this._outlet) {
+            this._outlet.dispose();
+        }
+    }
+}
+_MatMenuContentBase.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: _MatMenuContentBase, deps: [{ token: i0.TemplateRef }, { token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }, { token: i0.ViewContainerRef }, { token: DOCUMENT }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+_MatMenuContentBase.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: _MatMenuContentBase, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: _MatMenuContentBase, decorators: [{
+            type: Directive
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }, { type: i0.ViewContainerRef }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: i0.ChangeDetectorRef }]; } });
+/**
+ * Menu content that will be rendered lazily once the menu is opened.
+ */
+export class MatMenuContent extends _MatMenuContentBase {
+}
+MatMenuContent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatMenuContent, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+MatMenuContent.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0-next.15", type: MatMenuContent, selector: "ng-template[matMenuContent]", providers: [{ provide: MAT_MENU_CONTENT, useExisting: MatMenuContent }], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0-next.15", ngImport: i0, type: MatMenuContent, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'ng-template[matMenuContent]',
+                    providers: [{ provide: MAT_MENU_CONTENT, useExisting: MatMenuContent }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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