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

package/esm2020/testing/harness-environment.mjs

@@ -0,0 +1,202 @@
+/**
+ * @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 } from './change-detection';
+import { ComponentHarness, HarnessPredicate, } from './component-harness';
+/**
+ * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in
+ * different test environments (e.g. testbed, protractor, etc.). This class implements the
+ * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw
+ * element type, `E`, used by the particular test environment.
+ */
+export class HarnessEnvironment {
+    constructor(rawRootElement) {
+        this.rawRootElement = rawRootElement;
+        this.rootElement = this.createTestElement(rawRootElement);
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    documentRootLocatorFactory() {
+        return this.createEnvironment(this.getDocumentRoot());
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorFor(...queries) {
+        return () => _assertResultFound(this._getAllHarnessesAndTestElements(queries), _getDescriptionForLocatorForQueries(queries));
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorForOptional(...queries) {
+        return async () => (await this._getAllHarnessesAndTestElements(queries))[0] || null;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    locatorForAll(...queries) {
+        return () => this._getAllHarnessesAndTestElements(queries);
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async rootHarnessLoader() {
+        return this;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderFor(selector) {
+        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
+            _getDescriptionForHarnessLoaderQuery(selector),
+        ]));
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderForOptional(selector) {
+        const elements = await this.getAllRawElements(selector);
+        return elements[0] ? this.createEnvironment(elements[0]) : null;
+    }
+    // Implemented as part of the `LocatorFactory` interface.
+    async harnessLoaderForAll(selector) {
+        const elements = await this.getAllRawElements(selector);
+        return elements.map(element => this.createEnvironment(element));
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    getHarness(query) {
+        return this.locatorFor(query)();
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    getAllHarnesses(query) {
+        return this.locatorForAll(query)();
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    async getChildLoader(selector) {
+        return this.createEnvironment(await _assertResultFound(this.getAllRawElements(selector), [
+            _getDescriptionForHarnessLoaderQuery(selector),
+        ]));
+    }
+    // Implemented as part of the `HarnessLoader` interface.
+    async getAllChildLoaders(selector) {
+        return (await this.getAllRawElements(selector)).map(e => this.createEnvironment(e));
+    }
+    /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */
+    createComponentHarness(harnessType, element) {
+        return new harnessType(this.createEnvironment(element));
+    }
+    /**
+     * Matches the given raw elements with the given list of element and harness queries to produce a
+     * list of matched harnesses and test elements.
+     */
+    async _getAllHarnessesAndTestElements(queries) {
+        const { allQueries, harnessQueries, elementQueries, harnessTypes } = _parseQueries(queries);
+        // Combine all of the queries into one large comma-delimited selector and use it to get all raw
+        // elements matching any of the individual queries.
+        const rawElements = await this.getAllRawElements([...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','));
+        // If every query is searching for the same harness subclass, we know every result corresponds
+        // to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know
+        // every result corresponds to a `TestElement`. Otherwise we need to verify which result was
+        // found by which selector so it can be matched to the appropriate instance.
+        const skipSelectorCheck = (elementQueries.length === 0 && harnessTypes.size === 1) || harnessQueries.length === 0;
+        const perElementMatches = await parallel(() => rawElements.map(async (rawElement) => {
+            const testElement = this.createTestElement(rawElement);
+            const allResultsForElement = await parallel(
+            // For each query, get `null` if it doesn't match, or a `TestElement` or
+            // `ComponentHarness` as appropriate if it does match. This gives us everything that
+            // matches the current raw element, but it may contain duplicate entries (e.g.
+            // multiple `TestElement` or multiple `ComponentHarness` of the same type).
+            () => allQueries.map(query => this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck)));
+            return _removeDuplicateQueryResults(allResultsForElement);
+        }));
+        return [].concat(...perElementMatches);
+    }
+    /**
+     * Check whether the given query matches the given element, if it does return the matched
+     * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller
+     * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used
+     * to skip verification and optimize performance.
+     */
+    async _getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck = false) {
+        if (typeof query === 'string') {
+            return skipSelectorCheck || (await testElement.matchesSelector(query)) ? testElement : null;
+        }
+        if (skipSelectorCheck || (await testElement.matchesSelector(query.getSelector()))) {
+            const harness = this.createComponentHarness(query.harnessType, rawElement);
+            return (await query.evaluate(harness)) ? harness : null;
+        }
+        return null;
+    }
+}
+/**
+ * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to
+ * work with format.
+ */
+function _parseQueries(queries) {
+    const allQueries = [];
+    const harnessQueries = [];
+    const elementQueries = [];
+    const harnessTypes = new Set();
+    for (const query of queries) {
+        if (typeof query === 'string') {
+            allQueries.push(query);
+            elementQueries.push(query);
+        }
+        else {
+            const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
+            allQueries.push(predicate);
+            harnessQueries.push(predicate);
+            harnessTypes.add(predicate.harnessType);
+        }
+    }
+    return { allQueries, harnessQueries, elementQueries, harnessTypes };
+}
+/**
+ * Removes duplicate query results for a particular element. (e.g. multiple `TestElement`
+ * instances or multiple instances of the same `ComponentHarness` class.
+ */
+async function _removeDuplicateQueryResults(results) {
+    let testElementMatched = false;
+    let matchedHarnessTypes = new Set();
+    const dedupedMatches = [];
+    for (const result of results) {
+        if (!result) {
+            continue;
+        }
+        if (result instanceof ComponentHarness) {
+            if (!matchedHarnessTypes.has(result.constructor)) {
+                matchedHarnessTypes.add(result.constructor);
+                dedupedMatches.push(result);
+            }
+        }
+        else if (!testElementMatched) {
+            testElementMatched = true;
+            dedupedMatches.push(result);
+        }
+    }
+    return dedupedMatches;
+}
+/** Verifies that there is at least one result in an array. */
+async function _assertResultFound(results, queryDescriptions) {
+    const result = (await results)[0];
+    if (result == undefined) {
+        throw Error(`Failed to find element matching one of the following queries:\n` +
+            queryDescriptions.map(desc => `(${desc})`).join(',\n'));
+    }
+    return result;
+}
+/** Gets a list of description strings from a list of queries. */
+function _getDescriptionForLocatorForQueries(queries) {
+    return queries.map(query => typeof query === 'string'
+        ? _getDescriptionForTestElementQuery(query)
+        : _getDescriptionForComponentHarnessQuery(query));
+}
+/** Gets a description string for a `ComponentHarness` query. */
+function _getDescriptionForComponentHarnessQuery(query) {
+    const harnessPredicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});
+    const { name, hostSelector } = harnessPredicate.harnessType;
+    const description = `${name} with host element matching selector: "${hostSelector}"`;
+    const constraints = harnessPredicate.getDescription();
+    return (description +
+        (constraints ? ` satisfying the constraints: ${harnessPredicate.getDescription()}` : ''));
+}
+/** Gets a description string for a `TestElement` query. */
+function _getDescriptionForTestElementQuery(selector) {
+    return `TestElement for element matching selector: "${selector}"`;
+}
+/** Gets a description string for a `HarnessLoader` query. */
+function _getDescriptionForHarnessLoaderQuery(selector) {
+    return `HarnessLoader for element matching selector: "${selector}"`;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"harness-environment.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/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 {parallel} from './change-detection';\nimport {\n  AsyncFactoryFn,\n  ComponentHarness,\n  ComponentHarnessConstructor,\n  HarnessLoader,\n  HarnessPredicate,\n  HarnessQuery,\n  LocatorFactory,\n  LocatorFnResult,\n} from './component-harness';\nimport {TestElement} from './test-element';\n\n/** Parsed form of the queries passed to the `locatorFor*` methods. */\ntype ParsedQueries<T extends ComponentHarness> = {\n  /** The full list of queries, in their original order. */\n  allQueries: (string | HarnessPredicate<T>)[];\n  /**\n   * A filtered view of `allQueries` containing only the queries that are looking for a\n   * `ComponentHarness`\n   */\n  harnessQueries: HarnessPredicate<T>[];\n  /**\n   * A filtered view of `allQueries` containing only the queries that are looking for a\n   * `TestElement`\n   */\n  elementQueries: string[];\n  /** The set of all `ComponentHarness` subclasses represented in the original query list. */\n  harnessTypes: Set<ComponentHarnessConstructor<T>>;\n};\n\n/**\n * Base harness environment class that can be extended to allow `ComponentHarness`es to be used in\n * different test environments (e.g. testbed, protractor, etc.). This class implements the\n * functionality of both a `HarnessLoader` and `LocatorFactory`. This class is generic on the raw\n * element type, `E`, used by the particular test environment.\n */\nexport abstract class HarnessEnvironment<E> implements HarnessLoader, LocatorFactory {\n  // Implemented as part of the `LocatorFactory` interface.\n  rootElement: TestElement;\n\n  protected constructor(protected rawRootElement: E) {\n    this.rootElement = this.createTestElement(rawRootElement);\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  documentRootLocatorFactory(): LocatorFactory {\n    return this.createEnvironment(this.getDocumentRoot());\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorFor<T extends (HarnessQuery<any> | string)[]>(\n    ...queries: T\n  ): AsyncFactoryFn<LocatorFnResult<T>> {\n    return () =>\n      _assertResultFound(\n        this._getAllHarnessesAndTestElements(queries),\n        _getDescriptionForLocatorForQueries(queries),\n      );\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorForOptional<T extends (HarnessQuery<any> | string)[]>(\n    ...queries: T\n  ): AsyncFactoryFn<LocatorFnResult<T> | null> {\n    return async () => (await this._getAllHarnessesAndTestElements(queries))[0] || null;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  locatorForAll<T extends (HarnessQuery<any> | string)[]>(\n    ...queries: T\n  ): AsyncFactoryFn<LocatorFnResult<T>[]> {\n    return () => this._getAllHarnessesAndTestElements(queries);\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async rootHarnessLoader(): Promise<HarnessLoader> {\n    return this;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderFor(selector: string): Promise<HarnessLoader> {\n    return this.createEnvironment(\n      await _assertResultFound(this.getAllRawElements(selector), [\n        _getDescriptionForHarnessLoaderQuery(selector),\n      ]),\n    );\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderForOptional(selector: string): Promise<HarnessLoader | null> {\n    const elements = await this.getAllRawElements(selector);\n    return elements[0] ? this.createEnvironment(elements[0]) : null;\n  }\n\n  // Implemented as part of the `LocatorFactory` interface.\n  async harnessLoaderForAll(selector: string): Promise<HarnessLoader[]> {\n    const elements = await this.getAllRawElements(selector);\n    return elements.map(element => this.createEnvironment(element));\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  getHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T> {\n    return this.locatorFor(query)();\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  getAllHarnesses<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T[]> {\n    return this.locatorForAll(query)();\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  async getChildLoader(selector: string): Promise<HarnessLoader> {\n    return this.createEnvironment(\n      await _assertResultFound(this.getAllRawElements(selector), [\n        _getDescriptionForHarnessLoaderQuery(selector),\n      ]),\n    );\n  }\n\n  // Implemented as part of the `HarnessLoader` interface.\n  async getAllChildLoaders(selector: string): Promise<HarnessLoader[]> {\n    return (await this.getAllRawElements(selector)).map(e => this.createEnvironment(e));\n  }\n\n  /** Creates a `ComponentHarness` for the given harness type with the given raw host element. */\n  protected createComponentHarness<T extends ComponentHarness>(\n    harnessType: ComponentHarnessConstructor<T>,\n    element: E,\n  ): T {\n    return new harnessType(this.createEnvironment(element));\n  }\n\n  // Part of LocatorFactory interface, subclasses will implement.\n  abstract forceStabilize(): Promise<void>;\n\n  // Part of LocatorFactory interface, subclasses will implement.\n  abstract waitForTasksOutsideAngular(): Promise<void>;\n\n  /** Gets the root element for the document. */\n  protected abstract getDocumentRoot(): E;\n\n  /** Creates a `TestElement` from a raw element. */\n  protected abstract createTestElement(element: E): TestElement;\n\n  /** Creates a `HarnessLoader` rooted at the given raw element. */\n  protected abstract createEnvironment(element: E): HarnessEnvironment<E>;\n\n  /**\n   * Gets a list of all elements matching the given selector under this environment's root element.\n   */\n  protected abstract getAllRawElements(selector: string): Promise<E[]>;\n\n  /**\n   * Matches the given raw elements with the given list of element and harness queries to produce a\n   * list of matched harnesses and test elements.\n   */\n  private async _getAllHarnessesAndTestElements<T extends (HarnessQuery<any> | string)[]>(\n    queries: T,\n  ): Promise<LocatorFnResult<T>[]> {\n    const {allQueries, harnessQueries, elementQueries, harnessTypes} = _parseQueries(queries);\n\n    // Combine all of the queries into one large comma-delimited selector and use it to get all raw\n    // elements matching any of the individual queries.\n    const rawElements = await this.getAllRawElements(\n      [...elementQueries, ...harnessQueries.map(predicate => predicate.getSelector())].join(','),\n    );\n\n    // If every query is searching for the same harness subclass, we know every result corresponds\n    // to an instance of that subclass. Likewise, if every query is for a `TestElement`, we know\n    // every result corresponds to a `TestElement`. Otherwise we need to verify which result was\n    // found by which selector so it can be matched to the appropriate instance.\n    const skipSelectorCheck =\n      (elementQueries.length === 0 && harnessTypes.size === 1) || harnessQueries.length === 0;\n\n    const perElementMatches = await parallel(() =>\n      rawElements.map(async rawElement => {\n        const testElement = this.createTestElement(rawElement);\n        const allResultsForElement = await parallel(\n          // For each query, get `null` if it doesn't match, or a `TestElement` or\n          // `ComponentHarness` as appropriate if it does match. This gives us everything that\n          // matches the current raw element, but it may contain duplicate entries (e.g.\n          // multiple `TestElement` or multiple `ComponentHarness` of the same type).\n          () =>\n            allQueries.map(query =>\n              this._getQueryResultForElement(query, rawElement, testElement, skipSelectorCheck),\n            ),\n        );\n        return _removeDuplicateQueryResults(allResultsForElement);\n      }),\n    );\n    return ([] as any).concat(...perElementMatches);\n  }\n\n  /**\n   * Check whether the given query matches the given element, if it does return the matched\n   * `TestElement` or `ComponentHarness`, if it does not, return null. In cases where the caller\n   * knows for sure that the query matches the element's selector, `skipSelectorCheck` can be used\n   * to skip verification and optimize performance.\n   */\n  private async _getQueryResultForElement<T extends ComponentHarness>(\n    query: string | HarnessPredicate<T>,\n    rawElement: E,\n    testElement: TestElement,\n    skipSelectorCheck: boolean = false,\n  ): Promise<T | TestElement | null> {\n    if (typeof query === 'string') {\n      return skipSelectorCheck || (await testElement.matchesSelector(query)) ? testElement : null;\n    }\n    if (skipSelectorCheck || (await testElement.matchesSelector(query.getSelector()))) {\n      const harness = this.createComponentHarness(query.harnessType, rawElement);\n      return (await query.evaluate(harness)) ? harness : null;\n    }\n    return null;\n  }\n}\n\n/**\n * Parses a list of queries in the format accepted by the `locatorFor*` methods into an easier to\n * work with format.\n */\nfunction _parseQueries<T extends (HarnessQuery<any> | string)[]>(\n  queries: T,\n): ParsedQueries<LocatorFnResult<T> & ComponentHarness> {\n  const allQueries = [];\n  const harnessQueries = [];\n  const elementQueries = [];\n  const harnessTypes = new Set<\n    ComponentHarnessConstructor<LocatorFnResult<T> & ComponentHarness>\n  >();\n\n  for (const query of queries) {\n    if (typeof query === 'string') {\n      allQueries.push(query);\n      elementQueries.push(query);\n    } else {\n      const predicate = query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});\n      allQueries.push(predicate);\n      harnessQueries.push(predicate);\n      harnessTypes.add(predicate.harnessType);\n    }\n  }\n\n  return {allQueries, harnessQueries, elementQueries, harnessTypes};\n}\n\n/**\n * Removes duplicate query results for a particular element. (e.g. multiple `TestElement`\n * instances or multiple instances of the same `ComponentHarness` class.\n */\nasync function _removeDuplicateQueryResults<T extends (ComponentHarness | TestElement | null)[]>(\n  results: T,\n): Promise<T> {\n  let testElementMatched = false;\n  let matchedHarnessTypes = new Set();\n  const dedupedMatches = [];\n  for (const result of results) {\n    if (!result) {\n      continue;\n    }\n    if (result instanceof ComponentHarness) {\n      if (!matchedHarnessTypes.has(result.constructor)) {\n        matchedHarnessTypes.add(result.constructor);\n        dedupedMatches.push(result);\n      }\n    } else if (!testElementMatched) {\n      testElementMatched = true;\n      dedupedMatches.push(result);\n    }\n  }\n  return dedupedMatches as T;\n}\n\n/** Verifies that there is at least one result in an array. */\nasync function _assertResultFound<T>(\n  results: Promise<T[]>,\n  queryDescriptions: string[],\n): Promise<T> {\n  const result = (await results)[0];\n  if (result == undefined) {\n    throw Error(\n      `Failed to find element matching one of the following queries:\\n` +\n        queryDescriptions.map(desc => `(${desc})`).join(',\\n'),\n    );\n  }\n  return result;\n}\n\n/** Gets a list of description strings from a list of queries. */\nfunction _getDescriptionForLocatorForQueries(queries: (string | HarnessQuery<any>)[]) {\n  return queries.map(query =>\n    typeof query === 'string'\n      ? _getDescriptionForTestElementQuery(query)\n      : _getDescriptionForComponentHarnessQuery(query),\n  );\n}\n\n/** Gets a description string for a `ComponentHarness` query. */\nfunction _getDescriptionForComponentHarnessQuery(query: HarnessQuery<any>) {\n  const harnessPredicate =\n    query instanceof HarnessPredicate ? query : new HarnessPredicate(query, {});\n  const {name, hostSelector} = harnessPredicate.harnessType;\n  const description = `${name} with host element matching selector: \"${hostSelector}\"`;\n  const constraints = harnessPredicate.getDescription();\n  return (\n    description +\n    (constraints ? ` satisfying the constraints: ${harnessPredicate.getDescription()}` : '')\n  );\n}\n\n/** Gets a description string for a `TestElement` query. */\nfunction _getDescriptionForTestElementQuery(selector: string) {\n  return `TestElement for element matching selector: \"${selector}\"`;\n}\n\n/** Gets a description string for a `HarnessLoader` query. */\nfunction _getDescriptionForHarnessLoaderQuery(selector: string) {\n  return `HarnessLoader for element matching selector: \"${selector}\"`;\n}\n"]}

package/esm2020/testing/protractor/protractor-element.mjs

@@ -0,0 +1,234 @@
+/**
+ * @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, TestKey, } from '@angular/cdk/testing';
+import { browser, Button, by, Key } from 'protractor';
+/** Maps the `TestKey` constants to Protractor's `Key` constants. */
+const keyMap = {
+    [TestKey.BACKSPACE]: Key.BACK_SPACE,
+    [TestKey.TAB]: Key.TAB,
+    [TestKey.ENTER]: Key.ENTER,
+    [TestKey.SHIFT]: Key.SHIFT,
+    [TestKey.CONTROL]: Key.CONTROL,
+    [TestKey.ALT]: Key.ALT,
+    [TestKey.ESCAPE]: Key.ESCAPE,
+    [TestKey.PAGE_UP]: Key.PAGE_UP,
+    [TestKey.PAGE_DOWN]: Key.PAGE_DOWN,
+    [TestKey.END]: Key.END,
+    [TestKey.HOME]: Key.HOME,
+    [TestKey.LEFT_ARROW]: Key.ARROW_LEFT,
+    [TestKey.UP_ARROW]: Key.ARROW_UP,
+    [TestKey.RIGHT_ARROW]: Key.ARROW_RIGHT,
+    [TestKey.DOWN_ARROW]: Key.ARROW_DOWN,
+    [TestKey.INSERT]: Key.INSERT,
+    [TestKey.DELETE]: Key.DELETE,
+    [TestKey.F1]: Key.F1,
+    [TestKey.F2]: Key.F2,
+    [TestKey.F3]: Key.F3,
+    [TestKey.F4]: Key.F4,
+    [TestKey.F5]: Key.F5,
+    [TestKey.F6]: Key.F6,
+    [TestKey.F7]: Key.F7,
+    [TestKey.F8]: Key.F8,
+    [TestKey.F9]: Key.F9,
+    [TestKey.F10]: Key.F10,
+    [TestKey.F11]: Key.F11,
+    [TestKey.F12]: Key.F12,
+    [TestKey.META]: Key.META,
+};
+/** Converts a `ModifierKeys` object to a list of Protractor `Key`s. */
+function toProtractorModifierKeys(modifiers) {
+    const result = [];
+    if (modifiers.control) {
+        result.push(Key.CONTROL);
+    }
+    if (modifiers.alt) {
+        result.push(Key.ALT);
+    }
+    if (modifiers.shift) {
+        result.push(Key.SHIFT);
+    }
+    if (modifiers.meta) {
+        result.push(Key.META);
+    }
+    return result;
+}
+/**
+ * A `TestElement` implementation for Protractor.
+ * @deprecated
+ * @breaking-change 13.0.0
+ */
+export class ProtractorElement {
+    constructor(element) {
+        this.element = element;
+    }
+    /** Blur the element. */
+    async blur() {
+        return browser.executeScript('arguments[0].blur()', this.element);
+    }
+    /** Clear the element's input (for input and textarea elements only). */
+    async clear() {
+        return this.element.clear();
+    }
+    async click(...args) {
+        await this._dispatchClickEventSequence(args, Button.LEFT);
+    }
+    async rightClick(...args) {
+        await this._dispatchClickEventSequence(args, Button.RIGHT);
+    }
+    /** Focus the element. */
+    async focus() {
+        return browser.executeScript('arguments[0].focus()', this.element);
+    }
+    /** Get the computed value of the given CSS property for the element. */
+    async getCssValue(property) {
+        return this.element.getCssValue(property);
+    }
+    /** Hovers the mouse over the element. */
+    async hover() {
+        return browser
+            .actions()
+            .mouseMove(await this.element.getWebElement())
+            .perform();
+    }
+    /** Moves the mouse away from the element. */
+    async mouseAway() {
+        return browser
+            .actions()
+            .mouseMove(await this.element.getWebElement(), { x: -1, y: -1 })
+            .perform();
+    }
+    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 = toProtractorModifierKeys(modifiers);
+        const keys = rest
+            .map(k => (typeof k === 'string' ? k.split('') : [keyMap[k]]))
+            .reduce((arr, k) => arr.concat(k), [])
+            // 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 ? Key.chord(...modifierKeys, k) : k));
+        return this.element.sendKeys(...keys);
+    }
+    /**
+     * Gets the text from the element.
+     * @param options Options that affect what text is included.
+     */
+    async text(options) {
+        if (options?.exclude) {
+            return browser.executeScript(_getTextWithExcludedElements, this.element, options.exclude);
+        }
+        // We don't go through Protractor's `getText`, because it excludes text from hidden elements.
+        return browser.executeScript(`return (arguments[0].textContent || '').trim()`, this.element);
+    }
+    /** Gets the value for the given attribute from the element. */
+    async getAttribute(name) {
+        return browser.executeScript(`return arguments[0].getAttribute(arguments[1])`, this.element, name);
+    }
+    /** Checks whether the element has the given class. */
+    async hasClass(name) {
+        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() {
+        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) {
+        return browser.executeScript(`return arguments[0][arguments[1]]`, this.element, name);
+    }
+    /** Sets the value of a property of an input. */
+    async setInputValue(value) {
+        return browser.executeScript(`arguments[0].value = arguments[1]`, this.element, value);
+    }
+    /** Selects the options at the specified indexes inside of a native `select` element. */
+    async selectOptions(...optionIndexes) {
+        const options = await this.element.all(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 browser.actions().keyDown(Key.CONTROL).perform();
+                    await options[i].click();
+                    await browser.actions().keyUp(Key.CONTROL).perform();
+                }
+            }
+        }
+    }
+    /** Checks whether this element matches the given selector. */
+    async matchesSelector(selector) {
+        return browser.executeScript(`
+          return (Element.prototype.matches ||
+                  Element.prototype.msMatchesSelector).call(arguments[0], arguments[1])
+          `, this.element, selector);
+    }
+    /** Checks whether the element is focused. */
+    async isFocused() {
+        return this.element.equals(browser.driver.switchTo().activeElement());
+    }
+    /**
+     * Dispatches an event with a particular name.
+     * @param name Name of the event to be dispatched.
+     */
+    async dispatchEvent(name, data) {
+        return browser.executeScript(_dispatchEvent, name, this.element, data);
+    }
+    /** 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 = toProtractorModifierKeys(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 = browser.actions().mouseMove(await this.element.getWebElement(), ...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
+ * Protractor and is executed inside the browser.
+ */
+function _dispatchEvent(name, element, data) {
+    const event = document.createEvent('Event');
+    event.initEvent(name);
+    if (data) {
+        // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.
+        Object.assign(event, data);
+    }
+    // This type has a string index signature, so we cannot access it using a dotted property access.
+    element['dispatchEvent'](event);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protractor-element.js","sourceRoot":"","sources":["../../../../../../../src/cdk/testing/protractor/protractor-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  ModifierKeys,\n  TestElement,\n  TestKey,\n  TextOptions,\n  EventData,\n} from '@angular/cdk/testing';\nimport {browser, Button, by, ElementFinder, Key} from 'protractor';\n\n/** Maps the `TestKey` constants to Protractor's `Key` constants. */\nconst keyMap = {\n  [TestKey.BACKSPACE]: Key.BACK_SPACE,\n  [TestKey.TAB]: Key.TAB,\n  [TestKey.ENTER]: Key.ENTER,\n  [TestKey.SHIFT]: Key.SHIFT,\n  [TestKey.CONTROL]: Key.CONTROL,\n  [TestKey.ALT]: Key.ALT,\n  [TestKey.ESCAPE]: Key.ESCAPE,\n  [TestKey.PAGE_UP]: Key.PAGE_UP,\n  [TestKey.PAGE_DOWN]: Key.PAGE_DOWN,\n  [TestKey.END]: Key.END,\n  [TestKey.HOME]: Key.HOME,\n  [TestKey.LEFT_ARROW]: Key.ARROW_LEFT,\n  [TestKey.UP_ARROW]: Key.ARROW_UP,\n  [TestKey.RIGHT_ARROW]: Key.ARROW_RIGHT,\n  [TestKey.DOWN_ARROW]: Key.ARROW_DOWN,\n  [TestKey.INSERT]: Key.INSERT,\n  [TestKey.DELETE]: Key.DELETE,\n  [TestKey.F1]: Key.F1,\n  [TestKey.F2]: Key.F2,\n  [TestKey.F3]: Key.F3,\n  [TestKey.F4]: Key.F4,\n  [TestKey.F5]: Key.F5,\n  [TestKey.F6]: Key.F6,\n  [TestKey.F7]: Key.F7,\n  [TestKey.F8]: Key.F8,\n  [TestKey.F9]: Key.F9,\n  [TestKey.F10]: Key.F10,\n  [TestKey.F11]: Key.F11,\n  [TestKey.F12]: Key.F12,\n  [TestKey.META]: Key.META,\n};\n\n/** Converts a `ModifierKeys` object to a list of Protractor `Key`s. */\nfunction toProtractorModifierKeys(modifiers: ModifierKeys): string[] {\n  const result: string[] = [];\n  if (modifiers.control) {\n    result.push(Key.CONTROL);\n  }\n  if (modifiers.alt) {\n    result.push(Key.ALT);\n  }\n  if (modifiers.shift) {\n    result.push(Key.SHIFT);\n  }\n  if (modifiers.meta) {\n    result.push(Key.META);\n  }\n  return result;\n}\n\n/**\n * A `TestElement` implementation for Protractor.\n * @deprecated\n * @breaking-change 13.0.0\n */\nexport class ProtractorElement implements TestElement {\n  constructor(readonly element: ElementFinder) {}\n\n  /** Blur the element. */\n  async blur(): Promise<void> {\n    return browser.executeScript('arguments[0].blur()', this.element);\n  }\n\n  /** Clear the element's input (for input and textarea elements only). */\n  async clear(): Promise<void> {\n    return this.element.clear();\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, Button.LEFT);\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, Button.RIGHT);\n  }\n\n  /** Focus the element. */\n  async focus(): Promise<void> {\n    return browser.executeScript('arguments[0].focus()', this.element);\n  }\n\n  /** Get the computed value of the given CSS property for the element. */\n  async getCssValue(property: string): Promise<string> {\n    return this.element.getCssValue(property);\n  }\n\n  /** Hovers the mouse over the element. */\n  async hover(): Promise<void> {\n    return browser\n      .actions()\n      .mouseMove(await this.element.getWebElement())\n      .perform();\n  }\n\n  /** Moves the mouse away from the element. */\n  async mouseAway(): Promise<void> {\n    return browser\n      .actions()\n      .mouseMove(await this.element.getWebElement(), {x: -1, y: -1})\n      .perform();\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 = toProtractorModifierKeys(modifiers);\n    const keys = rest\n      .map(k => (typeof k === 'string' ? k.split('') : [keyMap[k]]))\n      .reduce((arr, k) => arr.concat(k), [])\n      // 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 ? Key.chord(...modifierKeys, k) : k));\n\n    return this.element.sendKeys(...keys);\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    if (options?.exclude) {\n      return browser.executeScript(_getTextWithExcludedElements, this.element, options.exclude);\n    }\n    // We don't go through Protractor's `getText`, because it excludes text from hidden elements.\n    return browser.executeScript(`return (arguments[0].textContent || '').trim()`, this.element);\n  }\n\n  /** Gets the value for the given attribute from the element. */\n  async getAttribute(name: string): Promise<string | null> {\n    return browser.executeScript(\n      `return arguments[0].getAttribute(arguments[1])`,\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    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    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    return browser.executeScript(`return arguments[0][arguments[1]]`, this.element, name);\n  }\n\n  /** Sets the value of a property of an input. */\n  async setInputValue(value: string): Promise<void> {\n    return browser.executeScript(`arguments[0].value = arguments[1]`, this.element, value);\n  }\n\n  /** Selects the options at the specified indexes inside of a native `select` element. */\n  async selectOptions(...optionIndexes: number[]): Promise<void> {\n    const options = await this.element.all(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 browser.actions().keyDown(Key.CONTROL).perform();\n          await options[i].click();\n          await browser.actions().keyUp(Key.CONTROL).perform();\n        }\n      }\n    }\n  }\n\n  /** Checks whether this element matches the given selector. */\n  async matchesSelector(selector: string): Promise<boolean> {\n    return browser.executeScript(\n      `\n          return (Element.prototype.matches ||\n                  Element.prototype.msMatchesSelector).call(arguments[0], arguments[1])\n          `,\n      this.element,\n      selector,\n    );\n  }\n\n  /** Checks whether the element is focused. */\n  async isFocused(): Promise<boolean> {\n    return this.element.equals(browser.driver.switchTo().activeElement());\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    return browser.executeScript(_dispatchEvent, name, this.element, data);\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 = toProtractorModifierKeys(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 = browser.actions().mouseMove(await this.element.getWebElement(), ...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.\n * Note that this needs to be a pure function, because it gets stringified by\n * Protractor and is executed inside the browser.\n */\nfunction _dispatchEvent(name: string, element: ElementFinder, data?: Record<string, EventData>) {\n  const event = document.createEvent('Event');\n  event.initEvent(name);\n\n  if (data) {\n    // tslint:disable-next-line:ban Have to use `Object.assign` to preserve the original object.\n    Object.assign(event, data);\n  }\n\n  // This type has a string index signature, so we cannot access it using a dotted property access.\n  element['dispatchEvent'](event);\n}\n"]}

package/esm2020/testing/protractor/protractor-harness-environment.mjs

@@ -0,0 +1,72 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { HarnessEnvironment } from '@angular/cdk/testing';
+import { by, element as protractorElement } from 'protractor';
+import { ProtractorElement } from './protractor-element';
+/** The default environment options. */
+const defaultEnvironmentOptions = {
+    queryFn: (selector, root) => root.all(by.css(selector)),
+};
+/**
+ * A `HarnessEnvironment` implementation for Protractor.
+ * @deprecated
+ * @breaking-change 13.0.0
+ */
+export class ProtractorHarnessEnvironment extends HarnessEnvironment {
+    constructor(rawRootElement, options) {
+        super(rawRootElement);
+        this._options = { ...defaultEnvironmentOptions, ...options };
+    }
+    /** Creates a `HarnessLoader` rooted at the document root. */
+    static loader(options) {
+        return new ProtractorHarnessEnvironment(protractorElement(by.css('body')), options);
+    }
+    /** Gets the ElementFinder corresponding to the given TestElement. */
+    static getNativeElement(el) {
+        if (el instanceof ProtractorElement) {
+            return el.element;
+        }
+        throw Error('This TestElement was not created by the ProtractorHarnessEnvironment');
+    }
+    /**
+     * 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() { }
+    /** @docs-private */
+    async waitForTasksOutsideAngular() {
+        // TODO: figure out how we can do this for the protractor environment.
+        // https://github.com/angular/components/issues/17412
+    }
+    /** Gets the root element for the document. */
+    getDocumentRoot() {
+        return protractorElement(by.css('body'));
+    }
+    /** Creates a `TestElement` from a raw element. */
+    createTestElement(element) {
+        return new ProtractorElement(element);
+    }
+    /** Creates a `HarnessLoader` rooted at the given raw element. */
+    createEnvironment(element) {
+        return new ProtractorHarnessEnvironment(element, this._options);
+    }
+    /**
+     * Gets a list of all elements matching the given selector under this environment's root element.
+     */
+    async getAllRawElements(selector) {
+        const elementArrayFinder = this._options.queryFn(selector, this.rawRootElement);
+        const length = await elementArrayFinder.count();
+        const elements = [];
+        for (let i = 0; i < length; i++) {
+            elements.push(elementArrayFinder.get(i));
+        }
+        return elements;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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