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

package/esm2020/datepicker/testing/date-range-input-harness.mjs

@@ -0,0 +1,99 @@
+/**
+ * @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, TestKey } from '@angular/cdk/testing';
+import { MatDatepickerInputHarnessBase, getInputPredicate } from './datepicker-input-harness-base';
+import { DatepickerTriggerHarnessBase } from './datepicker-trigger-harness-base';
+/** Harness for interacting with a standard Material date range start input in tests. */
+export class MatStartDateHarness extends MatDatepickerInputHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatStartDateHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getInputPredicate(MatStartDateHarness, options);
+    }
+}
+MatStartDateHarness.hostSelector = '.mat-start-date';
+/** Harness for interacting with a standard Material date range end input in tests. */
+export class MatEndDateHarness extends MatDatepickerInputHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatEndDateHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getInputPredicate(MatEndDateHarness, options);
+    }
+}
+MatEndDateHarness.hostSelector = '.mat-end-date';
+/** Harness for interacting with a standard Material date range input in tests. */
+export class MatDateRangeInputHarness extends DatepickerTriggerHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatDateRangeInputHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatDateRangeInputHarness, options)
+            .addOption('value', options.value, (harness, value) => HarnessPredicate.stringMatches(harness.getValue(), value));
+    }
+    /** Gets the combined value of the start and end inputs, including the separator. */
+    async getValue() {
+        const [start, end, separator] = await parallel(() => [
+            this.getStartInput().then(input => input.getValue()),
+            this.getEndInput().then(input => input.getValue()),
+            this.getSeparator()
+        ]);
+        return start + `${end ? ` ${separator} ${end}` : ''}`;
+    }
+    /** Gets the inner start date input inside the range input. */
+    async getStartInput() {
+        // Don't pass in filters here since the start input is required and there can only be one.
+        return this.locatorFor(MatStartDateHarness)();
+    }
+    /** Gets the inner start date input inside the range input. */
+    async getEndInput() {
+        // Don't pass in filters here since the end input is required and there can only be one.
+        return this.locatorFor(MatEndDateHarness)();
+    }
+    /** Gets the separator text between the values of the two inputs. */
+    async getSeparator() {
+        return (await this.locatorFor('.mat-date-range-input-separator')()).text();
+    }
+    /** Gets whether the range input is disabled. */
+    async isDisabled() {
+        // We consider the input as disabled if both of the sub-inputs are disabled.
+        const [startDisabled, endDisabled] = await parallel(() => [
+            this.getStartInput().then(input => input.isDisabled()),
+            this.getEndInput().then(input => input.isDisabled())
+        ]);
+        return startDisabled && endDisabled;
+    }
+    /** Gets whether the range input is required. */
+    async isRequired() {
+        return (await this.host()).hasClass('mat-date-range-input-required');
+    }
+    /** Opens the calendar associated with the input. */
+    async isCalendarOpen() {
+        // `aria-owns` is set on both inputs only if there's an
+        // open range picker so we can use it as an indicator.
+        const startHost = await (await this.getStartInput()).host();
+        return (await startHost.getAttribute('aria-owns')) != null;
+    }
+    async _openCalendar() {
+        // Alt + down arrow is the combination for opening the calendar with the keyboard.
+        const startHost = await (await this.getStartInput()).host();
+        return startHost.sendKeys({ alt: true }, TestKey.DOWN_ARROW);
+    }
+}
+MatDateRangeInputHarness.hostSelector = '.mat-date-range-input';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-range-input-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/datepicker/testing/date-range-input-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, TestKey} from '@angular/cdk/testing';\nimport {MatDatepickerInputHarnessBase, getInputPredicate} from './datepicker-input-harness-base';\nimport {DatepickerTriggerHarnessBase} from './datepicker-trigger-harness-base';\nimport {\n  DatepickerInputHarnessFilters,\n  DateRangeInputHarnessFilters,\n} from './datepicker-harness-filters';\n\n/** Harness for interacting with a standard Material date range start input in tests. */\nexport class MatStartDateHarness extends MatDatepickerInputHarnessBase {\n  static hostSelector = '.mat-start-date';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatStartDateHarness`\n   * that meets certain criteria.\n   * @param options Options for filtering which input instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: DatepickerInputHarnessFilters = {}):\n    HarnessPredicate<MatStartDateHarness> {\n    return getInputPredicate(MatStartDateHarness, options);\n  }\n}\n\n/** Harness for interacting with a standard Material date range end input in tests. */\nexport class MatEndDateHarness extends MatDatepickerInputHarnessBase {\n  static hostSelector = '.mat-end-date';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatEndDateHarness`\n   * that meets certain criteria.\n   * @param options Options for filtering which input instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: DatepickerInputHarnessFilters = {}):\n    HarnessPredicate<MatEndDateHarness> {\n    return getInputPredicate(MatEndDateHarness, options);\n  }\n}\n\n\n/** Harness for interacting with a standard Material date range input in tests. */\nexport class MatDateRangeInputHarness extends DatepickerTriggerHarnessBase {\n  static hostSelector = '.mat-date-range-input';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatDateRangeInputHarness`\n   * that meets certain criteria.\n   * @param options Options for filtering which input instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: DateRangeInputHarnessFilters = {}):\n    HarnessPredicate<MatDateRangeInputHarness> {\n      return new HarnessPredicate(MatDateRangeInputHarness, options)\n        .addOption('value', options.value,\n            (harness, value) => HarnessPredicate.stringMatches(harness.getValue(), value));\n  }\n\n  /** Gets the combined value of the start and end inputs, including the separator. */\n  async getValue(): Promise<string> {\n    const [start, end, separator] = await parallel(() => [\n      this.getStartInput().then(input => input.getValue()),\n      this.getEndInput().then(input => input.getValue()),\n      this.getSeparator()\n    ]);\n\n    return start + `${end ? ` ${separator} ${end}` : ''}`;\n  }\n\n  /** Gets the inner start date input inside the range input. */\n  async getStartInput(): Promise<MatStartDateHarness> {\n    // Don't pass in filters here since the start input is required and there can only be one.\n    return this.locatorFor(MatStartDateHarness)();\n  }\n\n  /** Gets the inner start date input inside the range input. */\n  async getEndInput(): Promise<MatEndDateHarness> {\n    // Don't pass in filters here since the end input is required and there can only be one.\n    return this.locatorFor(MatEndDateHarness)();\n  }\n\n  /** Gets the separator text between the values of the two inputs. */\n  async getSeparator(): Promise<string> {\n    return (await this.locatorFor('.mat-date-range-input-separator')()).text();\n  }\n\n  /** Gets whether the range input is disabled. */\n  async isDisabled(): Promise<boolean> {\n    // We consider the input as disabled if both of the sub-inputs are disabled.\n    const [startDisabled, endDisabled] = await parallel(() => [\n      this.getStartInput().then(input => input.isDisabled()),\n      this.getEndInput().then(input => input.isDisabled())\n    ]);\n\n    return startDisabled && endDisabled;\n  }\n\n  /** Gets whether the range input is required. */\n  async isRequired(): Promise<boolean> {\n    return (await this.host()).hasClass('mat-date-range-input-required');\n  }\n\n  /** Opens the calendar associated with the input. */\n  async isCalendarOpen(): Promise<boolean> {\n    // `aria-owns` is set on both inputs only if there's an\n    // open range picker so we can use it as an indicator.\n    const startHost = await (await this.getStartInput()).host();\n    return (await startHost.getAttribute('aria-owns')) != null;\n  }\n\n  protected async _openCalendar(): Promise<void> {\n    // Alt + down arrow is the combination for opening the calendar with the keyboard.\n    const startHost = await (await this.getStartInput()).host();\n    return startHost.sendKeys({alt: true}, TestKey.DOWN_ARROW);\n  }\n}\n"]}

package/esm2020/datepicker/testing/datepicker-input-harness-base.mjs

@@ -0,0 +1,81 @@
+/**
+ * @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 { MatFormFieldControlHarness } from '@angular/material/form-field/testing/control';
+/** Sets up the filter predicates for a datepicker input harness. */
+export function getInputPredicate(type, options) {
+    return new HarnessPredicate(type, options)
+        .addOption('value', options.value, (harness, value) => {
+        return HarnessPredicate.stringMatches(harness.getValue(), value);
+    })
+        .addOption('placeholder', options.placeholder, (harness, placeholder) => {
+        return HarnessPredicate.stringMatches(harness.getPlaceholder(), placeholder);
+    });
+}
+/** Base class for datepicker input harnesses. */
+export class MatDatepickerInputHarnessBase extends MatFormFieldControlHarness {
+    /** Whether the input is disabled. */
+    async isDisabled() {
+        return (await this.host()).getProperty('disabled');
+    }
+    /** Whether the input is required. */
+    async isRequired() {
+        return (await this.host()).getProperty('required');
+    }
+    /** Gets the value of the input. */
+    async getValue() {
+        // The "value" property of the native input is always defined.
+        return (await (await this.host()).getProperty('value'));
+    }
+    /**
+     * Sets the value of the input. The value will be set by simulating
+     * keypresses that correspond to the given value.
+     */
+    async setValue(newValue) {
+        const inputEl = await this.host();
+        await inputEl.clear();
+        // We don't want to send keys for the value if the value is an empty
+        // string in order to clear the value. Sending keys with an empty string
+        // still results in unnecessary focus events.
+        if (newValue) {
+            await inputEl.sendKeys(newValue);
+        }
+        await inputEl.dispatchEvent('change');
+    }
+    /** Gets the placeholder of the input. */
+    async getPlaceholder() {
+        return (await (await this.host()).getProperty('placeholder'));
+    }
+    /**
+     * Focuses the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    async focus() {
+        return (await this.host()).focus();
+    }
+    /**
+     * Blurs the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    async blur() {
+        return (await this.host()).blur();
+    }
+    /** Whether the input is focused. */
+    async isFocused() {
+        return (await this.host()).isFocused();
+    }
+    /** Gets the formatted minimum date for the input's value. */
+    async getMin() {
+        return (await this.host()).getAttribute('min');
+    }
+    /** Gets the formatted maximum date for the input's value. */
+    async getMax() {
+        return (await this.host()).getAttribute('max');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/datepicker/testing/datepicker-input-harness.mjs

@@ -0,0 +1,58 @@
+/**
+ * @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 { parallel, TestKey } from '@angular/cdk/testing';
+import { MatDatepickerInputHarnessBase, getInputPredicate } from './datepicker-input-harness-base';
+import { closeCalendar, getCalendarId, getCalendar, } from './datepicker-trigger-harness-base';
+/** Harness for interacting with a standard Material datepicker inputs in tests. */
+export class MatDatepickerInputHarness extends MatDatepickerInputHarnessBase {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatDatepickerInputHarness`
+     * that meets certain criteria.
+     * @param options Options for filtering which input instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return getInputPredicate(MatDatepickerInputHarness, options);
+    }
+    /** Gets whether the calendar associated with the input is open. */
+    async isCalendarOpen() {
+        // `aria-owns` is set only if there's an open datepicker so we can use it as an indicator.
+        const host = await this.host();
+        return (await host.getAttribute('aria-owns')) != null;
+    }
+    /** Opens the calendar associated with the input. */
+    async openCalendar() {
+        const [isDisabled, hasCalendar] = await parallel(() => [this.isDisabled(), this.hasCalendar()]);
+        if (!isDisabled && hasCalendar) {
+            // Alt + down arrow is the combination for opening the calendar with the keyboard.
+            const host = await this.host();
+            return host.sendKeys({ alt: true }, TestKey.DOWN_ARROW);
+        }
+    }
+    /** Closes the calendar associated with the input. */
+    async closeCalendar() {
+        if (await this.isCalendarOpen()) {
+            await closeCalendar(getCalendarId(this.host()), this.documentRootLocatorFactory());
+            // This is necessary so that we wait for the closing animation to finish in touch UI mode.
+            await this.forceStabilize();
+        }
+    }
+    /** Whether a calendar is associated with the input. */
+    async hasCalendar() {
+        return (await getCalendarId(this.host())) != null;
+    }
+    /**
+     * Gets the `MatCalendarHarness` that is associated with the trigger.
+     * @param filter Optionally filters which calendar is included.
+     */
+    async getCalendar(filter = {}) {
+        return getCalendar(filter, this.host(), this.documentRootLocatorFactory());
+    }
+}
+MatDatepickerInputHarness.hostSelector = '.mat-datepicker-input';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/datepicker/testing/datepicker-toggle-harness.mjs

@@ -0,0 +1,41 @@
+/**
+ * @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 { coerceBooleanProperty } from '@angular/cdk/coercion';
+import { DatepickerTriggerHarnessBase } from './datepicker-trigger-harness-base';
+/** Harness for interacting with a standard Material datepicker toggle in tests. */
+export class MatDatepickerToggleHarness extends DatepickerTriggerHarnessBase {
+    constructor() {
+        super(...arguments);
+        /** The clickable button inside the toggle. */
+        this._button = this.locatorFor('button');
+    }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a `MatDatepickerToggleHarness` that
+     * meets certain criteria.
+     * @param options Options for filtering which datepicker toggle instances are considered a match.
+     * @return a `HarnessPredicate` configured with the given options.
+     */
+    static with(options = {}) {
+        return new HarnessPredicate(MatDatepickerToggleHarness, options);
+    }
+    /** Gets whether the calendar associated with the toggle is open. */
+    async isCalendarOpen() {
+        return (await this.host()).hasClass('mat-datepicker-toggle-active');
+    }
+    /** Whether the toggle is disabled. */
+    async isDisabled() {
+        const button = await this._button();
+        return coerceBooleanProperty(await button.getAttribute('disabled'));
+    }
+    async _openCalendar() {
+        return (await this._button()).click();
+    }
+}
+MatDatepickerToggleHarness.hostSelector = '.mat-datepicker-toggle';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/datepicker/testing/datepicker-trigger-harness-base.mjs

@@ -0,0 +1,65 @@
+/**
+ * @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 { MatCalendarHarness } from './calendar-harness';
+/** Base class for harnesses that can trigger a calendar. */
+export class DatepickerTriggerHarnessBase extends ComponentHarness {
+    /** Opens the calendar if the trigger is enabled and it has a calendar. */
+    async openCalendar() {
+        const [isDisabled, hasCalendar] = await parallel(() => [this.isDisabled(), this.hasCalendar()]);
+        if (!isDisabled && hasCalendar) {
+            return this._openCalendar();
+        }
+    }
+    /** Closes the calendar if it is open. */
+    async closeCalendar() {
+        if (await this.isCalendarOpen()) {
+            await closeCalendar(getCalendarId(this.host()), this.documentRootLocatorFactory());
+            // This is necessary so that we wait for the closing animation to finish in touch UI mode.
+            await this.forceStabilize();
+        }
+    }
+    /** Gets whether there is a calendar associated with the trigger. */
+    async hasCalendar() {
+        return (await getCalendarId(this.host())) != null;
+    }
+    /**
+     * Gets the `MatCalendarHarness` that is associated with the trigger.
+     * @param filter Optionally filters which calendar is included.
+     */
+    async getCalendar(filter = {}) {
+        return getCalendar(filter, this.host(), this.documentRootLocatorFactory());
+    }
+}
+/** Gets the ID of the calendar that a particular test element can trigger. */
+export async function getCalendarId(host) {
+    return (await host).getAttribute('data-mat-calendar');
+}
+/** Closes the calendar with a specific ID. */
+export async function closeCalendar(calendarId, documentLocator) {
+    // We close the calendar by clicking on the backdrop, even though all datepicker variants
+    // have the ability to close by pressing escape. The backdrop is preferrable, because the
+    // escape key has multiple functions inside a range picker (either cancel the current range
+    // or close the calendar). Since we don't have access to set the ID on the backdrop in all
+    // cases, we set a unique class instead which is the same as the calendar's ID and suffixed
+    // with `-backdrop`.
+    const backdropSelector = `.${await calendarId}-backdrop`;
+    return (await documentLocator.locatorFor(backdropSelector)()).click();
+}
+/** Gets the test harness for a calendar associated with a particular host. */
+export async function getCalendar(filter, host, documentLocator) {
+    const calendarId = await getCalendarId(host);
+    if (!calendarId) {
+        throw Error(`Element is not associated with a calendar`);
+    }
+    return documentLocator.locatorFor(MatCalendarHarness.with({
+        ...filter,
+        selector: `#${calendarId}`
+    }))();
+}
+//# sourceMappingURL=data:application/json;base64,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