@angular/cdk 13.0.0-next.6 → 13.0.0-rc.1

package/esm2020/testing/selenium-webdriver/selenium-web-driver-element.mjs

@@ -0,0 +1,199 @@
+/**
+ * @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 { _getTextWithExcludedElements, } from '@angular/cdk/testing';
+import * as webdriver from 'selenium-webdriver';
+import { getSeleniumWebDriverModifierKeys, seleniumWebDriverKeyMap } from './selenium-webdriver-keys';
+/** A `TestElement` implementation for WebDriver. */
+export class SeleniumWebDriverElement {
+    constructor(element, _stabilize) {
+        this.element = element;
+        this._stabilize = _stabilize;
+    }
+    /** Blur the element. */
+    async blur() {
+        await this._executeScript((element) => element.blur(), this.element());
+        await this._stabilize();
+    }
+    /** Clear the element's input (for input and textarea elements only). */
+    async clear() {
+        await this.element().clear();
+        await this._stabilize();
+    }
+    async click(...args) {
+        await this._dispatchClickEventSequence(args, webdriver.Button.LEFT);
+        await this._stabilize();
+    }
+    async rightClick(...args) {
+        await this._dispatchClickEventSequence(args, webdriver.Button.RIGHT);
+        await this._stabilize();
+    }
+    /** Focus the element. */
+    async focus() {
+        await this._executeScript((element) => element.focus(), this.element());
+        await this._stabilize();
+    }
+    /** Get the computed value of the given CSS property for the element. */
+    async getCssValue(property) {
+        await this._stabilize();
+        return this.element().getCssValue(property);
+    }
+    /** Hovers the mouse over the element. */
+    async hover() {
+        await this._actions().mouseMove(this.element()).perform();
+        await this._stabilize();
+    }
+    /** Moves the mouse away from the element. */
+    async mouseAway() {
+        await this._actions().mouseMove(this.element(), { x: -1, y: -1 }).perform();
+        await this._stabilize();
+    }
+    async sendKeys(...modifiersAndKeys) {
+        const first = modifiersAndKeys[0];
+        let modifiers;
+        let rest;
+        if (typeof first !== 'string' && typeof first !== 'number') {
+            modifiers = first;
+            rest = modifiersAndKeys.slice(1);
+        }
+        else {
+            modifiers = {};
+            rest = modifiersAndKeys;
+        }
+        const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);
+        const keys = rest
+            .map(k => (typeof k === 'string' ? k.split('') : [seleniumWebDriverKeyMap[k]]))
+            .reduce((arr, k) => arr.concat(k), [])
+            // webdriver.Key.chord doesn't work well with geckodriver (mozilla/geckodriver#1502),
+            // so avoid it if no modifier keys are required.
+            .map(k => (modifierKeys.length > 0 ? webdriver.Key.chord(...modifierKeys, k) : k));
+        await this.element().sendKeys(...keys);
+        await this._stabilize();
+    }
+    /**
+     * Gets the text from the element.
+     * @param options Options that affect what text is included.
+     */
+    async text(options) {
+        await this._stabilize();
+        if (options?.exclude) {
+            return this._executeScript(_getTextWithExcludedElements, this.element(), options.exclude);
+        }
+        // We don't go through the WebDriver `getText`, because it excludes text from hidden elements.
+        return this._executeScript((element) => (element.textContent || '').trim(), this.element());
+    }
+    /** Gets the value for the given attribute from the element. */
+    async getAttribute(name) {
+        await this._stabilize();
+        return this._executeScript((element, attribute) => element.getAttribute(attribute), this.element(), name);
+    }
+    /** Checks whether the element has the given class. */
+    async hasClass(name) {
+        await this._stabilize();
+        const classes = (await this.getAttribute('class')) || '';
+        return new Set(classes.split(/\s+/).filter(c => c)).has(name);
+    }
+    /** Gets the dimensions of the element. */
+    async getDimensions() {
+        await this._stabilize();
+        const { width, height } = await this.element().getSize();
+        const { x: left, y: top } = await this.element().getLocation();
+        return { width, height, left, top };
+    }
+    /** Gets the value of a property of an element. */
+    async getProperty(name) {
+        await this._stabilize();
+        return this._executeScript((element, property) => element[property], this.element(), name);
+    }
+    /** Sets the value of a property of an input. */
+    async setInputValue(newValue) {
+        await this._executeScript((element, value) => (element.value = value), this.element(), newValue);
+        await this._stabilize();
+    }
+    /** Selects the options at the specified indexes inside of a native `select` element. */
+    async selectOptions(...optionIndexes) {
+        await this._stabilize();
+        const options = await this.element().findElements(webdriver.By.css('option'));
+        const indexes = new Set(optionIndexes); // Convert to a set to remove duplicates.
+        if (options.length && indexes.size) {
+            // Reset the value so all the selected states are cleared. We can
+            // reuse the input-specific method since the logic is the same.
+            await this.setInputValue('');
+            for (let i = 0; i < options.length; i++) {
+                if (indexes.has(i)) {
+                    // We have to hold the control key while clicking on options so that multiple can be
+                    // selected in multi-selection mode. The key doesn't do anything for single selection.
+                    await this._actions().keyDown(webdriver.Key.CONTROL).perform();
+                    await options[i].click();
+                    await this._actions().keyUp(webdriver.Key.CONTROL).perform();
+                }
+            }
+            await this._stabilize();
+        }
+    }
+    /** Checks whether this element matches the given selector. */
+    async matchesSelector(selector) {
+        await this._stabilize();
+        return this._executeScript((element, s) => (Element.prototype.matches || Element.prototype.msMatchesSelector).call(element, s), this.element(), selector);
+    }
+    /** Checks whether the element is focused. */
+    async isFocused() {
+        await this._stabilize();
+        return webdriver.WebElement.equals(this.element(), this.element().getDriver().switchTo().activeElement());
+    }
+    /**
+     * Dispatches an event with a particular name.
+     * @param name Name of the event to be dispatched.
+     */
+    async dispatchEvent(name, data) {
+        await this._executeScript(dispatchEvent, name, this.element(), data);
+        await this._stabilize();
+    }
+    /** Gets the webdriver action sequence. */
+    _actions() {
+        return this.element().getDriver().actions();
+    }
+    /** Executes a function in the browser. */
+    async _executeScript(script, ...var_args) {
+        return this.element()
+            .getDriver()
+            .executeScript(script, ...var_args);
+    }
+    /** Dispatches all the events that are part of a click event sequence. */
+    async _dispatchClickEventSequence(args, button) {
+        let modifiers = {};
+        if (args.length && typeof args[args.length - 1] === 'object') {
+            modifiers = args.pop();
+        }
+        const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);
+        // Omitting the offset argument to mouseMove results in clicking the center.
+        // This is the default behavior we want, so we use an empty array of offsetArgs if
+        // no args remain after popping the modifiers from the args passed to this function.
+        const offsetArgs = (args.length === 2 ? [{ x: args[0], y: args[1] }] : []);
+        let actions = this._actions().mouseMove(this.element(), ...offsetArgs);
+        for (const modifierKey of modifierKeys) {
+            actions = actions.keyDown(modifierKey);
+        }
+        actions = actions.click(button);
+        for (const modifierKey of modifierKeys) {
+            actions = actions.keyUp(modifierKey);
+        }
+        await actions.perform();
+    }
+}
+/**
+ * Dispatches an event with a particular name and data to an element. Note that this needs to be a
+ * pure function, because it gets stringified by WebDriver and is executed inside the browser.
+ */
+function dispatchEvent(name, element, data) {
+    const event = document.createEvent('Event');
+    event.initEvent(name);
+    // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.
+    Object.assign(event, data || {});
+    element.dispatchEvent(event);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selenium-web-driver-element.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/selenium-webdriver/selenium-web-driver-element.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  _getTextWithExcludedElements,\n  ElementDimensions,\n  EventData,\n  ModifierKeys,\n  TestElement,\n  TestKey,\n  TextOptions,\n} from '@angular/cdk/testing';\nimport * as webdriver from 'selenium-webdriver';\nimport {getSeleniumWebDriverModifierKeys, seleniumWebDriverKeyMap} from './selenium-webdriver-keys';\n\n/** A `TestElement` implementation for WebDriver. */\nexport class SeleniumWebDriverElement implements TestElement {\n  constructor(\n    readonly element: () => webdriver.WebElement,\n    private _stabilize: () => Promise<void>,\n  ) {}\n\n  /** Blur the element. */\n  async blur(): Promise<void> {\n    await this._executeScript((element: HTMLElement) => element.blur(), this.element());\n    await this._stabilize();\n  }\n\n  /** Clear the element's input (for input and textarea elements only). */\n  async clear(): Promise<void> {\n    await this.element().clear();\n    await this._stabilize();\n  }\n\n  /**\n   * Click the element at the default location for the current environment. If you need to guarantee\n   * the element is clicked at a specific location, consider using `click('center')` or\n   * `click(x, y)` instead.\n   */\n  click(modifiers?: ModifierKeys): Promise<void>;\n  /** Click the element at the element's center. */\n  click(location: 'center', modifiers?: ModifierKeys): Promise<void>;\n  /**\n   * Click the element at the specified coordinates relative to the top-left of the element.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */\n  click(relativeX: number, relativeY: number, modifiers?: ModifierKeys): Promise<void>;\n  async click(\n    ...args: [ModifierKeys?] | ['center', ModifierKeys?] | [number, number, ModifierKeys?]\n  ): Promise<void> {\n    await this._dispatchClickEventSequence(args, webdriver.Button.LEFT);\n    await this._stabilize();\n  }\n\n  /**\n   * Right clicks on the element at the specified coordinates relative to the top-left of it.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */\n  rightClick(relativeX: number, relativeY: number, modifiers?: ModifierKeys): Promise<void>;\n  async rightClick(\n    ...args: [ModifierKeys?] | ['center', ModifierKeys?] | [number, number, ModifierKeys?]\n  ): Promise<void> {\n    await this._dispatchClickEventSequence(args, webdriver.Button.RIGHT);\n    await this._stabilize();\n  }\n\n  /** Focus the element. */\n  async focus(): Promise<void> {\n    await this._executeScript((element: HTMLElement) => element.focus(), this.element());\n    await this._stabilize();\n  }\n\n  /** Get the computed value of the given CSS property for the element. */\n  async getCssValue(property: string): Promise<string> {\n    await this._stabilize();\n    return this.element().getCssValue(property);\n  }\n\n  /** Hovers the mouse over the element. */\n  async hover(): Promise<void> {\n    await this._actions().mouseMove(this.element()).perform();\n    await this._stabilize();\n  }\n\n  /** Moves the mouse away from the element. */\n  async mouseAway(): Promise<void> {\n    await this._actions().mouseMove(this.element(), {x: -1, y: -1}).perform();\n    await this._stabilize();\n  }\n\n  /**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */\n  async sendKeys(...keys: (string | TestKey)[]): Promise<void>;\n  /**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */\n  async sendKeys(modifiers: ModifierKeys, ...keys: (string | TestKey)[]): Promise<void>;\n  async sendKeys(...modifiersAndKeys: any[]): Promise<void> {\n    const first = modifiersAndKeys[0];\n    let modifiers: ModifierKeys;\n    let rest: (string | TestKey)[];\n    if (typeof first !== 'string' && typeof first !== 'number') {\n      modifiers = first;\n      rest = modifiersAndKeys.slice(1);\n    } else {\n      modifiers = {};\n      rest = modifiersAndKeys;\n    }\n\n    const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);\n    const keys = rest\n      .map(k => (typeof k === 'string' ? k.split('') : [seleniumWebDriverKeyMap[k]]))\n      .reduce((arr, k) => arr.concat(k), [])\n      // webdriver.Key.chord doesn't work well with geckodriver (mozilla/geckodriver#1502),\n      // so avoid it if no modifier keys are required.\n      .map(k => (modifierKeys.length > 0 ? webdriver.Key.chord(...modifierKeys, k) : k));\n\n    await this.element().sendKeys(...keys);\n    await this._stabilize();\n  }\n\n  /**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */\n  async text(options?: TextOptions): Promise<string> {\n    await this._stabilize();\n    if (options?.exclude) {\n      return this._executeScript(_getTextWithExcludedElements, this.element(), options.exclude);\n    }\n    // We don't go through the WebDriver `getText`, because it excludes text from hidden elements.\n    return this._executeScript(\n      (element: Element) => (element.textContent || '').trim(),\n      this.element(),\n    );\n  }\n\n  /** Gets the value for the given attribute from the element. */\n  async getAttribute(name: string): Promise<string | null> {\n    await this._stabilize();\n    return this._executeScript(\n      (element: Element, attribute: string) => element.getAttribute(attribute),\n      this.element(),\n      name,\n    );\n  }\n\n  /** Checks whether the element has the given class. */\n  async hasClass(name: string): Promise<boolean> {\n    await this._stabilize();\n    const classes = (await this.getAttribute('class')) || '';\n    return new Set(classes.split(/\\s+/).filter(c => c)).has(name);\n  }\n\n  /** Gets the dimensions of the element. */\n  async getDimensions(): Promise<ElementDimensions> {\n    await this._stabilize();\n    const {width, height} = await this.element().getSize();\n    const {x: left, y: top} = await this.element().getLocation();\n    return {width, height, left, top};\n  }\n\n  /** Gets the value of a property of an element. */\n  async getProperty<T = any>(name: string): Promise<T> {\n    await this._stabilize();\n    return this._executeScript(\n      (element: Element, property: keyof Element) => element[property],\n      this.element(),\n      name,\n    );\n  }\n\n  /** Sets the value of a property of an input. */\n  async setInputValue(newValue: string): Promise<void> {\n    await this._executeScript(\n      (element: HTMLInputElement, value: string) => (element.value = value),\n      this.element(),\n      newValue,\n    );\n    await this._stabilize();\n  }\n\n  /** Selects the options at the specified indexes inside of a native `select` element. */\n  async selectOptions(...optionIndexes: number[]): Promise<void> {\n    await this._stabilize();\n    const options = await this.element().findElements(webdriver.By.css('option'));\n    const indexes = new Set(optionIndexes); // Convert to a set to remove duplicates.\n\n    if (options.length && indexes.size) {\n      // Reset the value so all the selected states are cleared. We can\n      // reuse the input-specific method since the logic is the same.\n      await this.setInputValue('');\n\n      for (let i = 0; i < options.length; i++) {\n        if (indexes.has(i)) {\n          // We have to hold the control key while clicking on options so that multiple can be\n          // selected in multi-selection mode. The key doesn't do anything for single selection.\n          await this._actions().keyDown(webdriver.Key.CONTROL).perform();\n          await options[i].click();\n          await this._actions().keyUp(webdriver.Key.CONTROL).perform();\n        }\n      }\n\n      await this._stabilize();\n    }\n  }\n\n  /** Checks whether this element matches the given selector. */\n  async matchesSelector(selector: string): Promise<boolean> {\n    await this._stabilize();\n    return this._executeScript(\n      (element: Element, s: string) =>\n        (Element.prototype.matches || (Element.prototype as any).msMatchesSelector).call(\n          element,\n          s,\n        ),\n      this.element(),\n      selector,\n    );\n  }\n\n  /** Checks whether the element is focused. */\n  async isFocused(): Promise<boolean> {\n    await this._stabilize();\n    return webdriver.WebElement.equals(\n      this.element(),\n      this.element().getDriver().switchTo().activeElement(),\n    );\n  }\n\n  /**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */\n  async dispatchEvent(name: string, data?: Record<string, EventData>): Promise<void> {\n    await this._executeScript(dispatchEvent, name, this.element(), data);\n    await this._stabilize();\n  }\n\n  /** Gets the webdriver action sequence. */\n  private _actions() {\n    return this.element().getDriver().actions();\n  }\n\n  /** Executes a function in the browser. */\n  private async _executeScript<T>(script: Function, ...var_args: any[]): Promise<T> {\n    return this.element()\n      .getDriver()\n      .executeScript(script, ...var_args);\n  }\n\n  /** Dispatches all the events that are part of a click event sequence. */\n  private async _dispatchClickEventSequence(\n    args: [ModifierKeys?] | ['center', ModifierKeys?] | [number, number, ModifierKeys?],\n    button: string,\n  ) {\n    let modifiers: ModifierKeys = {};\n    if (args.length && typeof args[args.length - 1] === 'object') {\n      modifiers = args.pop() as ModifierKeys;\n    }\n    const modifierKeys = getSeleniumWebDriverModifierKeys(modifiers);\n\n    // Omitting the offset argument to mouseMove results in clicking the center.\n    // This is the default behavior we want, so we use an empty array of offsetArgs if\n    // no args remain after popping the modifiers from the args passed to this function.\n    const offsetArgs = (args.length === 2 ? [{x: args[0], y: args[1]}] : []) as [\n      {x: number; y: number},\n    ];\n\n    let actions = this._actions().mouseMove(this.element(), ...offsetArgs);\n\n    for (const modifierKey of modifierKeys) {\n      actions = actions.keyDown(modifierKey);\n    }\n    actions = actions.click(button);\n    for (const modifierKey of modifierKeys) {\n      actions = actions.keyUp(modifierKey);\n    }\n\n    await actions.perform();\n  }\n}\n\n/**\n * Dispatches an event with a particular name and data to an element. Note that this needs to be a\n * pure function, because it gets stringified by WebDriver and is executed inside the browser.\n */\nfunction dispatchEvent(name: string, element: Element, data?: Record<string, EventData>) {\n  const event = document.createEvent('Event');\n  event.initEvent(name);\n  // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.\n  Object.assign(event, data || {});\n  element.dispatchEvent(event);\n}\n"]}

package/esm2020/testing/selenium-webdriver/selenium-web-driver-harness-environment.mjs

@@ -0,0 +1,87 @@
+/**
+ * @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 { HarnessEnvironment } from '@angular/cdk/testing';
+import * as webdriver from 'selenium-webdriver';
+import { SeleniumWebDriverElement } from './selenium-web-driver-element';
+/** The default environment options. */
+const defaultEnvironmentOptions = {
+    queryFn: async (selector, root) => root().findElements(webdriver.By.css(selector)),
+};
+/**
+ * This function is meant to be executed in the browser. It taps into the hooks exposed by Angular
+ * and invokes the specified `callback` when the application is stable (no more pending tasks).
+ */
+function whenStable(callback) {
+    Promise.all(window.frameworkStabilizers.map(stabilizer => new Promise(stabilizer))).then(callback);
+}
+/**
+ * This function is meant to be executed in the browser. It checks whether the Angular framework has
+ * bootstrapped yet.
+ */
+function isBootstrapped() {
+    return !!window.frameworkStabilizers;
+}
+/** Waits for angular to be ready after the page load. */
+export async function waitForAngularReady(wd) {
+    await wd.wait(() => wd.executeScript(isBootstrapped));
+    await wd.executeAsyncScript(whenStable);
+}
+/** A `HarnessEnvironment` implementation for WebDriver. */
+export class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment {
+    constructor(rawRootElement, options) {
+        super(rawRootElement);
+        this._options = { ...defaultEnvironmentOptions, ...options };
+    }
+    /** Gets the ElementFinder corresponding to the given TestElement. */
+    static getNativeElement(el) {
+        if (el instanceof SeleniumWebDriverElement) {
+            return el.element();
+        }
+        throw Error('This TestElement was not created by the WebDriverHarnessEnvironment');
+    }
+    /** Creates a `HarnessLoader` rooted at the document root. */
+    static loader(driver, options) {
+        return new SeleniumWebDriverHarnessEnvironment(() => driver.findElement(webdriver.By.css('body')), options);
+    }
+    /**
+     * Flushes change detection and async tasks captured in the Angular zone.
+     * In most cases it should not be necessary to call this manually. However, there may be some edge
+     * cases where it is needed to fully flush animation events.
+     */
+    async forceStabilize() {
+        await this.rawRootElement().getDriver().executeAsyncScript(whenStable);
+    }
+    /** @docs-private */
+    async waitForTasksOutsideAngular() {
+        // TODO: figure out how we can do this for the webdriver environment.
+        //  https://github.com/angular/components/issues/17412
+    }
+    /** Gets the root element for the document. */
+    getDocumentRoot() {
+        return () => this.rawRootElement().getDriver().findElement(webdriver.By.css('body'));
+    }
+    /** Creates a `TestElement` from a raw element. */
+    createTestElement(element) {
+        return new SeleniumWebDriverElement(element, () => this.forceStabilize());
+    }
+    /** Creates a `HarnessLoader` rooted at the given raw element. */
+    createEnvironment(element) {
+        return new SeleniumWebDriverHarnessEnvironment(element, this._options);
+    }
+    // Note: This seems to be working, though we may need to re-evaluate if we encounter issues with
+    // stale element references. `() => Promise<webdriver.WebElement[]>` seems like a more correct
+    // return type, though supporting it would require changes to the public harness API.
+    /**
+     * Gets a list of all elements matching the given selector under this environment's root element.
+     */
+    async getAllRawElements(selector) {
+        const els = await this._options.queryFn(selector, this.rawRootElement);
+        return els.map((x) => () => x);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"selenium-web-driver-harness-environment.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/selenium-webdriver/selenium-web-driver-harness-environment.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 {HarnessEnvironment, HarnessLoader, TestElement} from '@angular/cdk/testing';\nimport * as webdriver from 'selenium-webdriver';\nimport {SeleniumWebDriverElement} from './selenium-web-driver-element';\n\n/**\n * An Angular framework stabilizer function that takes a callback and calls it when the application\n * is stable, passing a boolean indicating if any work was done.\n */\ndeclare interface FrameworkStabilizer {\n  (callback: (didWork: boolean) => void): void;\n}\n\ndeclare global {\n  interface Window {\n    /**\n     * These hooks are exposed by Angular to register a callback for when the application is stable\n     * (no more pending tasks).\n     *\n     * For the implementation, see: https://github.com/\n     *  angular/angular/blob/master/packages/platform-browser/src/browser/testability.ts#L30-L49\n     */\n    frameworkStabilizers: FrameworkStabilizer[];\n  }\n}\n\n/** Options to configure the environment. */\nexport interface WebDriverHarnessEnvironmentOptions {\n  /** The query function used to find DOM elements. */\n  queryFn: (selector: string, root: () => webdriver.WebElement) => Promise<webdriver.WebElement[]>;\n}\n\n/** The default environment options. */\nconst defaultEnvironmentOptions: WebDriverHarnessEnvironmentOptions = {\n  queryFn: async (selector: string, root: () => webdriver.WebElement) =>\n    root().findElements(webdriver.By.css(selector)),\n};\n\n/**\n * This function is meant to be executed in the browser. It taps into the hooks exposed by Angular\n * and invokes the specified `callback` when the application is stable (no more pending tasks).\n */\nfunction whenStable(callback: (didWork: boolean[]) => void): void {\n  Promise.all(window.frameworkStabilizers.map(stabilizer => new Promise(stabilizer))).then(\n    callback,\n  );\n}\n\n/**\n * This function is meant to be executed in the browser. It checks whether the Angular framework has\n * bootstrapped yet.\n */\nfunction isBootstrapped() {\n  return !!window.frameworkStabilizers;\n}\n\n/** Waits for angular to be ready after the page load. */\nexport async function waitForAngularReady(wd: webdriver.WebDriver) {\n  await wd.wait(() => wd.executeScript(isBootstrapped));\n  await wd.executeAsyncScript(whenStable);\n}\n\n/** A `HarnessEnvironment` implementation for WebDriver. */\nexport class SeleniumWebDriverHarnessEnvironment extends HarnessEnvironment<\n  () => webdriver.WebElement\n> {\n  /** The options for this environment. */\n  private _options: WebDriverHarnessEnvironmentOptions;\n\n  protected constructor(\n    rawRootElement: () => webdriver.WebElement,\n    options?: WebDriverHarnessEnvironmentOptions,\n  ) {\n    super(rawRootElement);\n    this._options = {...defaultEnvironmentOptions, ...options};\n  }\n\n  /** Gets the ElementFinder corresponding to the given TestElement. */\n  static getNativeElement(el: TestElement): webdriver.WebElement {\n    if (el instanceof SeleniumWebDriverElement) {\n      return el.element();\n    }\n    throw Error('This TestElement was not created by the WebDriverHarnessEnvironment');\n  }\n\n  /** Creates a `HarnessLoader` rooted at the document root. */\n  static loader(\n    driver: webdriver.WebDriver,\n    options?: WebDriverHarnessEnvironmentOptions,\n  ): HarnessLoader {\n    return new SeleniumWebDriverHarnessEnvironment(\n      () => driver.findElement(webdriver.By.css('body')),\n      options,\n    );\n  }\n\n  /**\n   * Flushes change detection and async tasks captured in the Angular zone.\n   * In most cases it should not be necessary to call this manually. However, there may be some edge\n   * cases where it is needed to fully flush animation events.\n   */\n  async forceStabilize(): Promise<void> {\n    await this.rawRootElement().getDriver().executeAsyncScript(whenStable);\n  }\n\n  /** @docs-private */\n  async waitForTasksOutsideAngular(): Promise<void> {\n    // TODO: figure out how we can do this for the webdriver environment.\n    //  https://github.com/angular/components/issues/17412\n  }\n\n  /** Gets the root element for the document. */\n  protected getDocumentRoot(): () => webdriver.WebElement {\n    return () => this.rawRootElement().getDriver().findElement(webdriver.By.css('body'));\n  }\n\n  /** Creates a `TestElement` from a raw element. */\n  protected createTestElement(element: () => webdriver.WebElement): TestElement {\n    return new SeleniumWebDriverElement(element, () => this.forceStabilize());\n  }\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected createEnvironment(\n    element: () => webdriver.WebElement,\n  ): HarnessEnvironment<() => webdriver.WebElement> {\n    return new SeleniumWebDriverHarnessEnvironment(element, this._options);\n  }\n\n  // Note: This seems to be working, though we may need to re-evaluate if we encounter issues with\n  // stale element references. `() => Promise<webdriver.WebElement[]>` seems like a more correct\n  // return type, though supporting it would require changes to the public harness API.\n  /**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */\n  protected async getAllRawElements(selector: string): Promise<(() => webdriver.WebElement)[]> {\n    const els = await this._options.queryFn(selector, this.rawRootElement);\n    return els.map((x: webdriver.WebElement) => () => x);\n  }\n}\n"]}

package/{esm2015/testing/selenium-webdriver/selenium-webdriver-keys.js → esm2020/testing/selenium-webdriver/selenium-webdriver-keys.mjs}

@@ -41,7 +41,7 @@ export const seleniumWebDriverKeyMap = {
     [TestKey.F10]: webdriver.Key.F10,
     [TestKey.F11]: webdriver.Key.F11,
     [TestKey.F12]: webdriver.Key.F12,
-    [TestKey.META]: webdriver.Key.META
+    [TestKey.META]: webdriver.Key.META,
 };
 /** Gets a list of WebDriver `Key`s for the given `ModifierKeys`. */
 export function getSeleniumWebDriverModifierKeys(modifiers) {
@@ -60,4 +60,4 @@ export function getSeleniumWebDriverModifierKeys(modifiers) {
     }
     return result;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/test-element.mjs

@@ -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
+ */
+/** An enum of non-text keys that can be used with the `sendKeys` method. */
+// NOTE: This is a separate enum from `@angular/cdk/keycodes` because we don't necessarily want to
+// support every possible keyCode. We also can't rely on Protractor's `Key` because we don't want a
+// dependency on any particular testing framework here. Instead we'll just maintain this supported
+// list of keys and let individual concrete `HarnessEnvironment` classes map them to whatever key
+// representation is used in its respective testing framework.
+// tslint:disable-next-line:prefer-const-enum Seems like this causes some issues with System.js
+export var TestKey;
+(function (TestKey) {
+    TestKey[TestKey["BACKSPACE"] = 0] = "BACKSPACE";
+    TestKey[TestKey["TAB"] = 1] = "TAB";
+    TestKey[TestKey["ENTER"] = 2] = "ENTER";
+    TestKey[TestKey["SHIFT"] = 3] = "SHIFT";
+    TestKey[TestKey["CONTROL"] = 4] = "CONTROL";
+    TestKey[TestKey["ALT"] = 5] = "ALT";
+    TestKey[TestKey["ESCAPE"] = 6] = "ESCAPE";
+    TestKey[TestKey["PAGE_UP"] = 7] = "PAGE_UP";
+    TestKey[TestKey["PAGE_DOWN"] = 8] = "PAGE_DOWN";
+    TestKey[TestKey["END"] = 9] = "END";
+    TestKey[TestKey["HOME"] = 10] = "HOME";
+    TestKey[TestKey["LEFT_ARROW"] = 11] = "LEFT_ARROW";
+    TestKey[TestKey["UP_ARROW"] = 12] = "UP_ARROW";
+    TestKey[TestKey["RIGHT_ARROW"] = 13] = "RIGHT_ARROW";
+    TestKey[TestKey["DOWN_ARROW"] = 14] = "DOWN_ARROW";
+    TestKey[TestKey["INSERT"] = 15] = "INSERT";
+    TestKey[TestKey["DELETE"] = 16] = "DELETE";
+    TestKey[TestKey["F1"] = 17] = "F1";
+    TestKey[TestKey["F2"] = 18] = "F2";
+    TestKey[TestKey["F3"] = 19] = "F3";
+    TestKey[TestKey["F4"] = 20] = "F4";
+    TestKey[TestKey["F5"] = 21] = "F5";
+    TestKey[TestKey["F6"] = 22] = "F6";
+    TestKey[TestKey["F7"] = 23] = "F7";
+    TestKey[TestKey["F8"] = 24] = "F8";
+    TestKey[TestKey["F9"] = 25] = "F9";
+    TestKey[TestKey["F10"] = 26] = "F10";
+    TestKey[TestKey["F11"] = 27] = "F11";
+    TestKey[TestKey["F12"] = 28] = "F12";
+    TestKey[TestKey["META"] = 29] = "META";
+})(TestKey || (TestKey = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"test-element.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/test-element.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsBH,4EAA4E;AAC5E,kGAAkG;AAClG,mGAAmG;AACnG,kGAAkG;AAClG,iGAAiG;AACjG,8DAA8D;AAC9D,+FAA+F;AAC/F,MAAM,CAAN,IAAY,OA+BX;AA/BD,WAAY,OAAO;IACjB,+CAAS,CAAA;IACT,mCAAG,CAAA;IACH,uCAAK,CAAA;IACL,uCAAK,CAAA;IACL,2CAAO,CAAA;IACP,mCAAG,CAAA;IACH,yCAAM,CAAA;IACN,2CAAO,CAAA;IACP,+CAAS,CAAA;IACT,mCAAG,CAAA;IACH,sCAAI,CAAA;IACJ,kDAAU,CAAA;IACV,8CAAQ,CAAA;IACR,oDAAW,CAAA;IACX,kDAAU,CAAA;IACV,0CAAM,CAAA;IACN,0CAAM,CAAA;IACN,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,kCAAE,CAAA;IACF,oCAAG,CAAA;IACH,oCAAG,CAAA;IACH,oCAAG,CAAA;IACH,sCAAI,CAAA;AACN,CAAC,EA/BW,OAAO,KAAP,OAAO,QA+BlB","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 {ElementDimensions} from './element-dimensions';\n\n/** Modifier keys that may be held while typing. */\nexport interface ModifierKeys {\n  control?: boolean;\n  alt?: boolean;\n  shift?: boolean;\n  meta?: boolean;\n}\n\n/** Data that can be attached to a custom event dispatched from a `TestElement`. */\nexport type EventData =\n  | string\n  | number\n  | boolean\n  | undefined\n  | null\n  | EventData[]\n  | {[key: string]: EventData};\n\n/** An enum of non-text keys that can be used with the `sendKeys` method. */\n// NOTE: This is a separate enum from `@angular/cdk/keycodes` because we don't necessarily want to\n// support every possible keyCode. We also can't rely on Protractor's `Key` because we don't want a\n// dependency on any particular testing framework here. Instead we'll just maintain this supported\n// list of keys and let individual concrete `HarnessEnvironment` classes map them to whatever key\n// representation is used in its respective testing framework.\n// tslint:disable-next-line:prefer-const-enum Seems like this causes some issues with System.js\nexport enum TestKey {\n  BACKSPACE,\n  TAB,\n  ENTER,\n  SHIFT,\n  CONTROL,\n  ALT,\n  ESCAPE,\n  PAGE_UP,\n  PAGE_DOWN,\n  END,\n  HOME,\n  LEFT_ARROW,\n  UP_ARROW,\n  RIGHT_ARROW,\n  DOWN_ARROW,\n  INSERT,\n  DELETE,\n  F1,\n  F2,\n  F3,\n  F4,\n  F5,\n  F6,\n  F7,\n  F8,\n  F9,\n  F10,\n  F11,\n  F12,\n  META,\n}\n\n/**\n * This acts as a common interface for DOM elements across both unit and e2e tests. It is the\n * interface through which the ComponentHarness interacts with the component's DOM.\n */\nexport interface TestElement {\n  /** Blur the element. */\n  blur(): Promise<void>;\n\n  /** Clear the element's input (for input and textarea elements only). */\n  clear(): Promise<void>;\n\n  /**\n   * Click the element at the default location for the current environment. If you need to guarantee\n   * the element is clicked at a specific location, consider using `click('center')` or\n   * `click(x, y)` instead.\n   */\n  click(modifiers?: ModifierKeys): Promise<void>;\n\n  /** Click the element at the element's center. */\n  click(location: 'center', modifiers?: ModifierKeys): Promise<void>;\n\n  /**\n   * Click the element at the specified coordinates relative to the top-left of the element.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */\n  click(relativeX: number, relativeY: number, modifiers?: ModifierKeys): Promise<void>;\n\n  /**\n   * Right clicks on the element at the specified coordinates relative to the top-left of it.\n   * @param relativeX Coordinate within the element, along the X-axis at which to click.\n   * @param relativeY Coordinate within the element, along the Y-axis at which to click.\n   * @param modifiers Modifier keys held while clicking\n   */\n  rightClick(relativeX: number, relativeY: number, modifiers?: ModifierKeys): Promise<void>;\n\n  /** Focus the element. */\n  focus(): Promise<void>;\n\n  /** Get the computed value of the given CSS property for the element. */\n  getCssValue(property: string): Promise<string>;\n\n  /** Hovers the mouse over the element. */\n  hover(): Promise<void>;\n\n  /** Moves the mouse away from the element. */\n  mouseAway(): Promise<void>;\n\n  /**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */\n  sendKeys(...keys: (string | TestKey)[]): Promise<void>;\n\n  /**\n   * Sends the given string to the input as a series of key presses. Also fires input events\n   * and attempts to add the string to the Element's value.\n   */\n  sendKeys(modifiers: ModifierKeys, ...keys: (string | TestKey)[]): Promise<void>;\n\n  /**\n   * Gets the text from the element.\n   * @param options Options that affect what text is included.\n   */\n  text(options?: TextOptions): Promise<string>;\n\n  /** Gets the value for the given attribute from the element. */\n  getAttribute(name: string): Promise<string | null>;\n\n  /** Checks whether the element has the given class. */\n  hasClass(name: string): Promise<boolean>;\n\n  /** Gets the dimensions of the element. */\n  getDimensions(): Promise<ElementDimensions>;\n\n  /** Gets the value of a property of an element. */\n  getProperty<T = any>(name: string): Promise<T>;\n\n  /** Checks whether this element matches the given selector. */\n  matchesSelector(selector: string): Promise<boolean>;\n\n  /** Checks whether the element is focused. */\n  isFocused(): Promise<boolean>;\n\n  /** Sets the value of a property of an input. */\n  setInputValue(value: string): Promise<void>;\n\n  // Note that ideally here we'd be selecting options based on their value, rather than their\n  // index, but we're limited by `@angular/forms` which will modify the option value in some cases.\n  // Since the value will be truncated, we can't rely on it to do the lookup in the DOM. See:\n  // https://github.com/angular/angular/blob/master/packages/forms/src/directives/select_control_value_accessor.ts#L19\n  /** Selects the options at the specified indexes inside of a native `select` element. */\n  selectOptions(...optionIndexes: number[]): Promise<void>;\n\n  /**\n   * Dispatches an event with a particular name.\n   * @param name Name of the event to be dispatched.\n   */\n  dispatchEvent(name: string, data?: Record<string, EventData>): Promise<void>;\n}\n\nexport interface TextOptions {\n  /** Optional selector for elements to exclude. */\n  exclude?: string;\n}\n"]}

package/esm2020/testing/testbed/fake-events/dispatch-events.mjs

@@ -0,0 +1,53 @@
+/**
+ * @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 { createFakeEvent, createKeyboardEvent, createMouseEvent, createPointerEvent, createTouchEvent, } from './event-objects';
+/**
+ * Utility to dispatch any event on a Node.
+ * @docs-private
+ */
+export function dispatchEvent(node, event) {
+    node.dispatchEvent(event);
+    return event;
+}
+/**
+ * Shorthand to dispatch a fake event on a specified node.
+ * @docs-private
+ */
+export function dispatchFakeEvent(node, type, bubbles) {
+    return dispatchEvent(node, createFakeEvent(type, bubbles));
+}
+/**
+ * Shorthand to dispatch a keyboard event with a specified key code and
+ * optional modifiers.
+ * @docs-private
+ */
+export function dispatchKeyboardEvent(node, type, keyCode, key, modifiers) {
+    return dispatchEvent(node, createKeyboardEvent(type, keyCode, key, modifiers));
+}
+/**
+ * Shorthand to dispatch a mouse event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchMouseEvent(node, type, clientX = 0, clientY = 0, button, modifiers) {
+    return dispatchEvent(node, createMouseEvent(type, clientX, clientY, button, modifiers));
+}
+/**
+ * Shorthand to dispatch a pointer event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchPointerEvent(node, type, clientX = 0, clientY = 0, options) {
+    return dispatchEvent(node, createPointerEvent(type, clientX, clientY, options));
+}
+/**
+ * Shorthand to dispatch a touch event on the specified coordinates.
+ * @docs-private
+ */
+export function dispatchTouchEvent(node, type, pageX = 0, pageY = 0, clientX = 0, clientY = 0) {
+    return dispatchEvent(node, createTouchEvent(type, pageX, pageY, clientX, clientY));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/testing/testbed/fake-events/element-focus.mjs

@@ -0,0 +1,39 @@
+/**
+ * @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 { dispatchFakeEvent } from './dispatch-events';
+function triggerFocusChange(element, event) {
+    let eventFired = false;
+    const handler = () => (eventFired = true);
+    element.addEventListener(event, handler);
+    element[event]();
+    element.removeEventListener(event, handler);
+    if (!eventFired) {
+        dispatchFakeEvent(element, event);
+    }
+}
+/**
+ * Patches an elements focus and blur methods to emit events consistently and predictably.
+ * This is necessary, because some browsers can call the focus handlers asynchronously,
+ * while others won't fire them at all if the browser window is not focused.
+ * @docs-private
+ */
+// TODO: Check if this element focus patching is still needed for local testing,
+// where browser is not necessarily focused.
+export function patchElementFocus(element) {
+    element.focus = () => dispatchFakeEvent(element, 'focus');
+    element.blur = () => dispatchFakeEvent(element, 'blur');
+}
+/** @docs-private */
+export function triggerFocus(element) {
+    triggerFocusChange(element, 'focus');
+}
+/** @docs-private */
+export function triggerBlur(element) {
+    triggerFocusChange(element, 'blur');
+}
+//# sourceMappingURL=data:application/json;base64,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