@angular/material 10.1.1 → 10.2.0

package/esm2015/datepicker/testing/date-range-input-harness.js

@@ -0,0 +1,116 @@
+/**
+ * @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 { __awaiter } from "tslib";
+import { HarnessPredicate, 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. */
+    getValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [start, end, separator] = yield Promise.all([
+                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. */
+    getStartInput() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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. */
+    getEndInput() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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. */
+    getSeparator() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.locatorFor('.mat-date-range-input-separator')()).text();
+        });
+    }
+    /** Gets whether the range input is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // We consider the input as disabled if both of the sub-inputs are disabled.
+            const [startDisabled, endDisabled] = yield Promise.all([
+                this.getStartInput().then(input => input.isDisabled()),
+                this.getEndInput().then(input => input.isDisabled())
+            ]);
+            return startDisabled && endDisabled;
+        });
+    }
+    /** Gets whether the range input is required. */
+    isRequired() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-date-range-input-required');
+        });
+    }
+    /** Opens the calendar associated with the input. */
+    isCalendarOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // `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 = yield (yield this.getStartInput()).host();
+            return (yield startHost.getAttribute('aria-owns')) != null;
+        });
+    }
+    _openCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Alt + down arrow is the combination for opening the calendar with the keyboard.
+            const startHost = yield (yield 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, 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 Promise.all([\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 Promise.all([\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/esm2015/datepicker/testing/datepicker-harness-filters.js

@@ -0,0 +1,9 @@
+/**
+ * @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 {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/testing/datepicker-input-harness-base.js

@@ -0,0 +1,100 @@
+/**
+ * @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 { __awaiter } from "tslib";
+import { HarnessPredicate, ComponentHarness, } from '@angular/cdk/testing';
+/** 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 ComponentHarness {
+    /** Whether the input is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getProperty('disabled');
+        });
+    }
+    /** Whether the input is required. */
+    isRequired() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getProperty('required');
+        });
+    }
+    /** Gets the value of the input. */
+    getValue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // The "value" property of the native input is always defined.
+            return (yield (yield this.host()).getProperty('value'));
+        });
+    }
+    /**
+     * Sets the value of the input. The value will be set by simulating
+     * keypresses that correspond to the given value.
+     */
+    setValue(newValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inputEl = yield this.host();
+            yield 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) {
+                yield inputEl.sendKeys(newValue);
+            }
+        });
+    }
+    /** Gets the placeholder of the input. */
+    getPlaceholder() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield (yield this.host()).getProperty('placeholder'));
+        });
+    }
+    /**
+     * Focuses the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    focus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).focus();
+        });
+    }
+    /**
+     * Blurs the input and returns a promise that indicates when the
+     * action is complete.
+     */
+    blur() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).blur();
+        });
+    }
+    /** Whether the input is focused. */
+    isFocused() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).isFocused();
+        });
+    }
+    /** Gets the formatted minimum date for the input's value. */
+    getMin() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getAttribute('min');
+        });
+    }
+    /** Gets the formatted maximum date for the input's value. */
+    getMax() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).getAttribute('max');
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/testing/datepicker-input-harness.js

@@ -0,0 +1,69 @@
+/**
+ * @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 { __awaiter } from "tslib";
+import { 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. */
+    isCalendarOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // `aria-owns` is set only if there's an open datepicker so we can use it as an indicator.
+            const host = yield this.host();
+            return (yield host.getAttribute('aria-owns')) != null;
+        });
+    }
+    /** Opens the calendar associated with the input. */
+    openCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [isDisabled, hasCalendar] = yield Promise.all([this.isDisabled(), this.hasCalendar()]);
+            if (!isDisabled && hasCalendar) {
+                // Alt + down arrow is the combination for opening the calendar with the keyboard.
+                const host = yield this.host();
+                return host.sendKeys({ alt: true }, TestKey.DOWN_ARROW);
+            }
+        });
+    }
+    /** Closes the calendar associated with the input. */
+    closeCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isCalendarOpen()) {
+                yield closeCalendar(getCalendarId(this.host()), this.documentRootLocatorFactory());
+                // This is necessary so that we wait for the closing animation to finish in touch UI mode.
+                yield this.forceStabilize();
+            }
+        });
+    }
+    /** Whether a calendar is associated with the input. */
+    hasCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield getCalendarId(this.host())) != null;
+        });
+    }
+    /**
+     * Gets the `MatCalendarHarness` that is associated with the trigger.
+     * @param filter Optionally filters which calendar is included.
+     */
+    getCalendar(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return getCalendar(filter, this.host(), this.documentRootLocatorFactory());
+        });
+    }
+}
+MatDatepickerInputHarness.hostSelector = '.mat-datepicker-input';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXBpY2tlci1pbnB1dC1oYXJuZXNzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21hdGVyaWFsL2RhdGVwaWNrZXIvdGVzdGluZy9kYXRlcGlja2VyLWlucHV0LWhhcm5lc3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HOztBQUVILE9BQU8sRUFBbUIsT0FBTyxFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFFL0QsT0FBTyxFQUFDLDZCQUE2QixFQUFFLGlCQUFpQixFQUFDLE1BQU0saUNBQWlDLENBQUM7QUFFakcsT0FBTyxFQUVMLGFBQWEsRUFDYixhQUFhLEVBQ2IsV0FBVyxHQUNaLE1BQU0sbUNBQW1DLENBQUM7QUFFM0MsbUZBQW1GO0FBQ25GLE1BQU0sT0FBTyx5QkFBMEIsU0FBUSw2QkFBNkI7SUFJMUU7Ozs7O09BS0c7SUFDSCxNQUFNLENBQUMsSUFBSSxDQUFDLFVBQXlDLEVBQUU7UUFFckQsT0FBTyxpQkFBaUIsQ0FBQyx5QkFBeUIsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUMvRCxDQUFDO0lBRUQsbUVBQW1FO0lBQzdELGNBQWM7O1lBQ2xCLDBGQUEwRjtZQUMxRixNQUFNLElBQUksR0FBRyxNQUFNLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztZQUMvQixPQUFPLENBQUMsTUFBTSxJQUFJLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDO1FBQ3hELENBQUM7S0FBQTtJQUVELG9EQUFvRDtJQUM5QyxZQUFZOztZQUNoQixNQUFNLENBQUMsVUFBVSxFQUFFLFdBQVcsQ0FBQyxHQUFHLE1BQU0sT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxVQUFVLEVBQUUsRUFBRSxJQUFJLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQyxDQUFDO1lBRTdGLElBQUksQ0FBQyxVQUFVLElBQUksV0FBVyxFQUFFO2dCQUM5QixrRkFBa0Y7Z0JBQ2xGLE1BQU0sSUFBSSxHQUFHLE1BQU0sSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDO2dCQUMvQixPQUFPLElBQUksQ0FBQyxRQUFRLENBQUMsRUFBQyxHQUFHLEVBQUUsSUFBSSxFQUFDLEVBQUUsT0FBTyxDQUFDLFVBQVUsQ0FBQyxDQUFDO2FBQ3ZEO1FBQ0gsQ0FBQztLQUFBO0lBRUQscURBQXFEO0lBQy9DLGFBQWE7O1lBQ2pCLElBQUksTUFBTSxJQUFJLENBQUMsY0FBYyxFQUFFLEVBQUU7Z0JBQy9CLE1BQU0sYUFBYSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUMsRUFBRSxJQUFJLENBQUMsMEJBQTBCLEVBQUUsQ0FBQyxDQUFDO2dCQUNuRiwwRkFBMEY7Z0JBQzFGLE1BQU0sSUFBSSxDQUFDLGNBQWMsRUFBRSxDQUFDO2FBQzdCO1FBQ0gsQ0FBQztLQUFBO0lBRUQsdURBQXVEO0lBQ2pELFdBQVc7O1lBQ2YsT0FBTyxDQUFDLE1BQU0sYUFBYSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLElBQUksSUFBSSxDQUFDO1FBQ3BELENBQUM7S0FBQTtJQUVEOzs7T0FHRztJQUNHLFdBQVcsQ0FBQyxTQUFpQyxFQUFFOztZQUNuRCxPQUFPLFdBQVcsQ0FBQyxNQUFNLEVBQUUsSUFBSSxDQUFDLElBQUksRUFBRSxFQUFFLElBQUksQ0FBQywwQkFBMEIsRUFBRSxDQUFDLENBQUM7UUFDN0UsQ0FBQztLQUFBOztBQW5ETSxzQ0FBWSxHQUFHLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmltcG9ydCB7SGFybmVzc1ByZWRpY2F0ZSwgVGVzdEtleX0gZnJvbSAnQGFuZ3VsYXIvY2RrL3Rlc3RpbmcnO1xuaW1wb3J0IHtEYXRlcGlja2VySW5wdXRIYXJuZXNzRmlsdGVycywgQ2FsZW5kYXJIYXJuZXNzRmlsdGVyc30gZnJvbSAnLi9kYXRlcGlja2VyLWhhcm5lc3MtZmlsdGVycyc7XG5pbXBvcnQge01hdERhdGVwaWNrZXJJbnB1dEhhcm5lc3NCYXNlLCBnZXRJbnB1dFByZWRpY2F0ZX0gZnJvbSAnLi9kYXRlcGlja2VyLWlucHV0LWhhcm5lc3MtYmFzZSc7XG5pbXBvcnQge01hdENhbGVuZGFySGFybmVzc30gZnJvbSAnLi9jYWxlbmRhci1oYXJuZXNzJztcbmltcG9ydCB7XG4gIERhdGVwaWNrZXJUcmlnZ2VyLFxuICBjbG9zZUNhbGVuZGFyLFxuICBnZXRDYWxlbmRhcklkLFxuICBnZXRDYWxlbmRhcixcbn0gZnJvbSAnLi9kYXRlcGlja2VyLXRyaWdnZXItaGFybmVzcy1iYXNlJztcblxuLyoqIEhhcm5lc3MgZm9yIGludGVyYWN0aW5nIHdpdGggYSBzdGFuZGFyZCBNYXRlcmlhbCBkYXRlcGlja2VyIGlucHV0cyBpbiB0ZXN0cy4gKi9cbmV4cG9ydCBjbGFzcyBNYXREYXRlcGlja2VySW5wdXRIYXJuZXNzIGV4dGVuZHMgTWF0RGF0ZXBpY2tlcklucHV0SGFybmVzc0Jhc2UgaW1wbGVtZW50c1xuICBEYXRlcGlja2VyVHJpZ2dlciB7XG4gIHN0YXRpYyBob3N0U2VsZWN0b3IgPSAnLm1hdC1kYXRlcGlja2VyLWlucHV0JztcblxuICAvKipcbiAgICogR2V0cyBhIGBIYXJuZXNzUHJlZGljYXRlYCB0aGF0IGNhbiBiZSB1c2VkIHRvIHNlYXJjaCBmb3IgYSBgTWF0RGF0ZXBpY2tlcklucHV0SGFybmVzc2BcbiAgICogdGhhdCBtZWV0cyBjZXJ0YWluIGNyaXRlcmlhLlxuICAgKiBAcGFyYW0gb3B0aW9ucyBPcHRpb25zIGZvciBmaWx0ZXJpbmcgd2hpY2ggaW5wdXQgaW5zdGFuY2VzIGFyZSBjb25zaWRlcmVkIGEgbWF0Y2guXG4gICAqIEByZXR1cm4gYSBgSGFybmVzc1ByZWRpY2F0ZWAgY29uZmlndXJlZCB3aXRoIHRoZSBnaXZlbiBvcHRpb25zLlxuICAgKi9cbiAgc3RhdGljIHdpdGgob3B0aW9uczogRGF0ZXBpY2tlcklucHV0SGFybmVzc0ZpbHRlcnMgPSB7fSk6XG4gICAgSGFybmVzc1ByZWRpY2F0ZTxNYXREYXRlcGlja2VySW5wdXRIYXJuZXNzPiB7XG4gICAgcmV0dXJuIGdldElucHV0UHJlZGljYXRlKE1hdERhdGVwaWNrZXJJbnB1dEhhcm5lc3MsIG9wdGlvbnMpO1xuICB9XG5cbiAgLyoqIEdldHMgd2hldGhlciB0aGUgY2FsZW5kYXIgYXNzb2NpYXRlZCB3aXRoIHRoZSBpbnB1dCBpcyBvcGVuLiAqL1xuICBhc3luYyBpc0NhbGVuZGFyT3BlbigpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICAvLyBgYXJpYS1vd25zYCBpcyBzZXQgb25seSBpZiB0aGVyZSdzIGFuIG9wZW4gZGF0ZXBpY2tlciBzbyB3ZSBjYW4gdXNlIGl0IGFzIGFuIGluZGljYXRvci5cbiAgICBjb25zdCBob3N0ID0gYXdhaXQgdGhpcy5ob3N0KCk7XG4gICAgcmV0dXJuIChhd2FpdCBob3N0LmdldEF0dHJpYnV0ZSgnYXJpYS1vd25zJykpICE9IG51bGw7XG4gIH1cblxuICAvKiogT3BlbnMgdGhlIGNhbGVuZGFyIGFzc29jaWF0ZWQgd2l0aCB0aGUgaW5wdXQuICovXG4gIGFzeW5jIG9wZW5DYWxlbmRhcigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBjb25zdCBbaXNEaXNhYmxlZCwgaGFzQ2FsZW5kYXJdID0gYXdhaXQgUHJvbWlzZS5hbGwoW3RoaXMuaXNEaXNhYmxlZCgpLCB0aGlzLmhhc0NhbGVuZGFyKCldKTtcblxuICAgIGlmICghaXNEaXNhYmxlZCAmJiBoYXNDYWxlbmRhcikge1xuICAgICAgLy8gQWx0ICsgZG93biBhcnJvdyBpcyB0aGUgY29tYmluYXRpb24gZm9yIG9wZW5pbmcgdGhlIGNhbGVuZGFyIHdpdGggdGhlIGtleWJvYXJkLlxuICAgICAgY29uc3QgaG9zdCA9IGF3YWl0IHRoaXMuaG9zdCgpO1xuICAgICAgcmV0dXJuIGhvc3Quc2VuZEtleXMoe2FsdDogdHJ1ZX0sIFRlc3RLZXkuRE9XTl9BUlJPVyk7XG4gICAgfVxuICB9XG5cbiAgLyoqIENsb3NlcyB0aGUgY2FsZW5kYXIgYXNzb2NpYXRlZCB3aXRoIHRoZSBpbnB1dC4gKi9cbiAgYXN5bmMgY2xvc2VDYWxlbmRhcigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgICBpZiAoYXdhaXQgdGhpcy5pc0NhbGVuZGFyT3BlbigpKSB7XG4gICAgICBhd2FpdCBjbG9zZUNhbGVuZGFyKGdldENhbGVuZGFySWQodGhpcy5ob3N0KCkpLCB0aGlzLmRvY3VtZW50Um9vdExvY2F0b3JGYWN0b3J5KCkpO1xuICAgICAgLy8gVGhpcyBpcyBuZWNlc3Nhcnkgc28gdGhhdCB3ZSB3YWl0IGZvciB0aGUgY2xvc2luZyBhbmltYXRpb24gdG8gZmluaXNoIGluIHRvdWNoIFVJIG1vZGUuXG4gICAgICBhd2FpdCB0aGlzLmZvcmNlU3RhYmlsaXplKCk7XG4gICAgfVxuICB9XG5cbiAgLyoqIFdoZXRoZXIgYSBjYWxlbmRhciBpcyBhc3NvY2lhdGVkIHdpdGggdGhlIGlucHV0LiAqL1xuICBhc3luYyBoYXNDYWxlbmRhcigpOiBQcm9taXNlPGJvb2xlYW4+IHtcbiAgICByZXR1cm4gKGF3YWl0IGdldENhbGVuZGFySWQodGhpcy5ob3N0KCkpKSAhPSBudWxsO1xuICB9XG5cbiAgLyoqXG4gICAqIEdldHMgdGhlIGBNYXRDYWxlbmRhckhhcm5lc3NgIHRoYXQgaXMgYXNzb2NpYXRlZCB3aXRoIHRoZSB0cmlnZ2VyLlxuICAgKiBAcGFyYW0gZmlsdGVyIE9wdGlvbmFsbHkgZmlsdGVycyB3aGljaCBjYWxlbmRhciBpcyBpbmNsdWRlZC5cbiAgICovXG4gIGFzeW5jIGdldENhbGVuZGFyKGZpbHRlcjogQ2FsZW5kYXJIYXJuZXNzRmlsdGVycyA9IHt9KTogUHJvbWlzZTxNYXRDYWxlbmRhckhhcm5lc3M+IHtcbiAgICByZXR1cm4gZ2V0Q2FsZW5kYXIoZmlsdGVyLCB0aGlzLmhvc3QoKSwgdGhpcy5kb2N1bWVudFJvb3RMb2NhdG9yRmFjdG9yeSgpKTtcbiAgfVxufVxuIl19

package/esm2015/datepicker/testing/datepicker-toggle-harness.js

@@ -0,0 +1,48 @@
+/**
+ * @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 { __awaiter } from "tslib";
+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. */
+    isCalendarOpen() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.host()).hasClass('mat-datepicker-toggle-active');
+        });
+    }
+    /** Whether the toggle is disabled. */
+    isDisabled() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const button = yield this._button();
+            return coerceBooleanProperty(yield button.getAttribute('disabled'));
+        });
+    }
+    _openCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this._button()).click();
+        });
+    }
+}
+MatDatepickerToggleHarness.hostSelector = '.mat-datepicker-toggle';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/testing/datepicker-trigger-harness-base.js

@@ -0,0 +1,77 @@
+/**
+ * @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 { __awaiter } from "tslib";
+import { ComponentHarness } 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. */
+    openCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const [isDisabled, hasCalendar] = yield Promise.all([this.isDisabled(), this.hasCalendar()]);
+            if (!isDisabled && hasCalendar) {
+                return this._openCalendar();
+            }
+        });
+    }
+    /** Closes the calendar if it is open. */
+    closeCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isCalendarOpen()) {
+                yield closeCalendar(getCalendarId(this.host()), this.documentRootLocatorFactory());
+                // This is necessary so that we wait for the closing animation to finish in touch UI mode.
+                yield this.forceStabilize();
+            }
+        });
+    }
+    /** Gets whether there is a calendar associated with the trigger. */
+    hasCalendar() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield getCalendarId(this.host())) != null;
+        });
+    }
+    /**
+     * Gets the `MatCalendarHarness` that is associated with the trigger.
+     * @param filter Optionally filters which calendar is included.
+     */
+    getCalendar(filter = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return getCalendar(filter, this.host(), this.documentRootLocatorFactory());
+        });
+    }
+}
+/** Gets the ID of the calendar that a particular test element can trigger. */
+export function getCalendarId(host) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield host).getAttribute('data-mat-calendar');
+    });
+}
+/** Closes the calendar with a specific ID. */
+export function closeCalendar(calendarId, documentLocator) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // 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 = `.${yield calendarId}-backdrop`;
+        return (yield documentLocator.locatorFor(backdropSelector)()).click();
+    });
+}
+/** Gets the test harness for a calendar associated with a particular host. */
+export function getCalendar(filter, host, documentLocator) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const calendarId = yield getCalendarId(host);
+        if (!calendarId) {
+            throw Error(`Element is not associated with a calendar`);
+        }
+        return documentLocator.locatorFor(MatCalendarHarness.with(Object.assign(Object.assign({}, filter), { selector: `#${calendarId}` })))();
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/datepicker/testing/index.js

@@ -0,0 +1,9 @@
+/**
+ * @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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbWF0ZXJpYWwvZGF0ZXBpY2tlci90ZXN0aW5nL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsY0FBYyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IEdvb2dsZSBMTEMgQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqXG4gKiBVc2Ugb2YgdGhpcyBzb3VyY2UgY29kZSBpcyBnb3Zlcm5lZCBieSBhbiBNSVQtc3R5bGUgbGljZW5zZSB0aGF0IGNhbiBiZVxuICogZm91bmQgaW4gdGhlIExJQ0VOU0UgZmlsZSBhdCBodHRwczovL2FuZ3VsYXIuaW8vbGljZW5zZVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

package/esm2015/datepicker/testing/public-api.js

@@ -0,0 +1,14 @@
+/**
+ * @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 './datepicker-harness-filters';
+export * from './datepicker-input-harness';
+export * from './datepicker-toggle-harness';
+export * from './date-range-input-harness';
+export * from './calendar-harness';
+export * from './calendar-cell-harness';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tYXRlcmlhbC9kYXRlcGlja2VyL3Rlc3RpbmcvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7O0dBTUc7QUFFSCxjQUFjLDhCQUE4QixDQUFDO0FBQzdDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyx5QkFBeUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2RhdGVwaWNrZXItaGFybmVzcy1maWx0ZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZXBpY2tlci1pbnB1dC1oYXJuZXNzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZXBpY2tlci10b2dnbGUtaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGUtcmFuZ2UtaW5wdXQtaGFybmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL2NhbGVuZGFyLWhhcm5lc3MnO1xuZXhwb3J0ICogZnJvbSAnLi9jYWxlbmRhci1jZWxsLWhhcm5lc3MnO1xuIl19