| /** |
| * @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 { parallel } from './change-detection'; |
| /** |
| * Base class for component harnesses that all component harness authors should extend. This base |
| * component harness provides the basic ability to locate element and sub-component harness. It |
| * should be inherited when defining user's own harness. |
| */ |
| export class ComponentHarness { |
| constructor(locatorFactory) { |
| this.locatorFactory = locatorFactory; |
| } |
| /** Gets a `Promise` for the `TestElement` representing the host element of the component. */ |
| host() { |
| return __awaiter(this, void 0, void 0, function* () { |
| return this.locatorFactory.rootElement; |
| }); |
| } |
| /** |
| * Gets a `LocatorFactory` for the document root element. This factory can be used to create |
| * locators for elements that a component creates outside of its own root element. (e.g. by |
| * appending to document.body). |
| */ |
| documentRootLocatorFactory() { |
| return this.locatorFactory.documentRootLocatorFactory(); |
| } |
| /** |
| * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance |
| * or element under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for the |
| * first element or harness matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If no matches are found, the |
| * `Promise` rejects. The type that the `Promise` resolves to is a union of all result types for |
| * each query. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'`: |
| * - `await ch.locatorFor(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1` |
| * - `await ch.locatorFor('div', DivHarness)()` gets a `TestElement` instance for `#d1` |
| * - `await ch.locatorFor('span')()` throws because the `Promise` rejects. |
| */ |
| locatorFor(...queries) { |
| return this.locatorFactory.locatorFor(...queries); |
| } |
| /** |
| * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance |
| * or element under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for the |
| * first element or harness matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If no matches are found, the |
| * `Promise` is resolved with `null`. The type that the `Promise` resolves to is a union of all |
| * result types for each query or null. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'`: |
| * - `await ch.locatorForOptional(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1` |
| * - `await ch.locatorForOptional('div', DivHarness)()` gets a `TestElement` instance for `#d1` |
| * - `await ch.locatorForOptional('span')()` gets `null`. |
| */ |
| locatorForOptional(...queries) { |
| return this.locatorFactory.locatorForOptional(...queries); |
| } |
| /** |
| * Creates an asynchronous locator function that can be used to find `ComponentHarness` instances |
| * or elements under the host element of this `ComponentHarness`. |
| * @param queries A list of queries specifying which harnesses and elements to search for: |
| * - A `string` searches for elements matching the CSS selector specified by the string. |
| * - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the |
| * given class. |
| * - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given |
| * predicate. |
| * @return An asynchronous locator function that searches for and returns a `Promise` for all |
| * elements and harnesses matching the given search criteria. Matches are ordered first by |
| * order in the DOM, and second by order in the queries list. If an element matches more than |
| * one `ComponentHarness` class, the locator gets an instance of each for the same element. If |
| * an element matches multiple `string` selectors, only one `TestElement` instance is returned |
| * for that element. The type that the `Promise` resolves to is an array where each element is |
| * the union of all result types for each query. |
| * |
| * e.g. Given the following DOM: `<div id="d1" /><div id="d2" />`, and assuming |
| * `DivHarness.hostSelector === 'div'` and `IdIsD1Harness.hostSelector === '#d1'`: |
| * - `await ch.locatorForAll(DivHarness, 'div')()` gets `[ |
| * DivHarness, // for #d1 |
| * TestElement, // for #d1 |
| * DivHarness, // for #d2 |
| * TestElement // for #d2 |
| * ]` |
| * - `await ch.locatorForAll('div', '#d1')()` gets `[ |
| * TestElement, // for #d1 |
| * TestElement // for #d2 |
| * ]` |
| * - `await ch.locatorForAll(DivHarness, IdIsD1Harness)()` gets `[ |
| * DivHarness, // for #d1 |
| * IdIsD1Harness, // for #d1 |
| * DivHarness // for #d2 |
| * ]` |
| * - `await ch.locatorForAll('span')()` gets `[]`. |
| */ |
| locatorForAll(...queries) { |
| return this.locatorFactory.locatorForAll(...queries); |
| } |
| /** |
| * Flushes change detection and async tasks 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. |
| */ |
| forceStabilize() { |
| return __awaiter(this, void 0, void 0, function* () { |
| return this.locatorFactory.forceStabilize(); |
| }); |
| } |
| /** |
| * Waits for all scheduled or running async tasks to complete. This allows harness |
| * authors to wait for async tasks outside of the Angular zone. |
| */ |
| waitForTasksOutsideAngular() { |
| return __awaiter(this, void 0, void 0, function* () { |
| return this.locatorFactory.waitForTasksOutsideAngular(); |
| }); |
| } |
| } |
| /** |
| * Base class for component harnesses that authors should extend if they anticipate that consumers |
| * of the harness may want to access other harnesses within the `<ng-content>` of the component. |
| */ |
| export class ContentContainerComponentHarness extends ComponentHarness { |
| getChildLoader(selector) { |
| return __awaiter(this, void 0, void 0, function* () { |
| return (yield this.getRootHarnessLoader()).getChildLoader(selector); |
| }); |
| } |
| getAllChildLoaders(selector) { |
| return __awaiter(this, void 0, void 0, function* () { |
| return (yield this.getRootHarnessLoader()).getAllChildLoaders(selector); |
| }); |
| } |
| getHarness(query) { |
| return __awaiter(this, void 0, void 0, function* () { |
| return (yield this.getRootHarnessLoader()).getHarness(query); |
| }); |
| } |
| getAllHarnesses(query) { |
| return __awaiter(this, void 0, void 0, function* () { |
| return (yield this.getRootHarnessLoader()).getAllHarnesses(query); |
| }); |
| } |
| /** |
| * Gets the root harness loader from which to start |
| * searching for content contained by this harness. |
| */ |
| getRootHarnessLoader() { |
| return __awaiter(this, void 0, void 0, function* () { |
| return this.locatorFactory.rootHarnessLoader(); |
| }); |
| } |
| } |
| /** |
| * A class used to associate a ComponentHarness class with predicates functions that can be used to |
| * filter instances of the class. |
| */ |
| export class HarnessPredicate { |
| constructor(harnessType, options) { |
| this.harnessType = harnessType; |
| this._predicates = []; |
| this._descriptions = []; |
| this._addBaseOptions(options); |
| } |
| /** |
| * Checks if the specified nullable string value matches the given pattern. |
| * @param value The nullable string value to check, or a Promise resolving to the |
| * nullable string value. |
| * @param pattern The pattern the value is expected to match. If `pattern` is a string, |
| * `value` is expected to match exactly. If `pattern` is a regex, a partial match is |
| * allowed. If `pattern` is `null`, the value is expected to be `null`. |
| * @return Whether the value matches the pattern. |
| */ |
| static stringMatches(value, pattern) { |
| return __awaiter(this, void 0, void 0, function* () { |
| value = yield value; |
| if (pattern === null) { |
| return value === null; |
| } |
| else if (value === null) { |
| return false; |
| } |
| return typeof pattern === 'string' ? value === pattern : pattern.test(value); |
| }); |
| } |
| /** |
| * Adds a predicate function to be run against candidate harnesses. |
| * @param description A description of this predicate that may be used in error messages. |
| * @param predicate An async predicate function. |
| * @return this (for method chaining). |
| */ |
| add(description, predicate) { |
| this._descriptions.push(description); |
| this._predicates.push(predicate); |
| return this; |
| } |
| /** |
| * Adds a predicate function that depends on an option value to be run against candidate |
| * harnesses. If the option value is undefined, the predicate will be ignored. |
| * @param name The name of the option (may be used in error messages). |
| * @param option The option value. |
| * @param predicate The predicate function to run if the option value is not undefined. |
| * @return this (for method chaining). |
| */ |
| addOption(name, option, predicate) { |
| if (option !== undefined) { |
| this.add(`${name} = ${_valueAsString(option)}`, item => predicate(item, option)); |
| } |
| return this; |
| } |
| /** |
| * Filters a list of harnesses on this predicate. |
| * @param harnesses The list of harnesses to filter. |
| * @return A list of harnesses that satisfy this predicate. |
| */ |
| filter(harnesses) { |
| return __awaiter(this, void 0, void 0, function* () { |
| if (harnesses.length === 0) { |
| return []; |
| } |
| const results = yield parallel(() => harnesses.map(h => this.evaluate(h))); |
| return harnesses.filter((_, i) => results[i]); |
| }); |
| } |
| /** |
| * Evaluates whether the given harness satisfies this predicate. |
| * @param harness The harness to check |
| * @return A promise that resolves to true if the harness satisfies this predicate, |
| * and resolves to false otherwise. |
| */ |
| evaluate(harness) { |
| return __awaiter(this, void 0, void 0, function* () { |
| const results = yield parallel(() => this._predicates.map(p => p(harness))); |
| return results.reduce((combined, current) => combined && current, true); |
| }); |
| } |
| /** Gets a description of this predicate for use in error messages. */ |
| getDescription() { |
| return this._descriptions.join(', '); |
| } |
| /** Gets the selector used to find candidate elements. */ |
| getSelector() { |
| // We don't have to go through the extra trouble if there are no ancestors. |
| if (!this._ancestor) { |
| return (this.harnessType.hostSelector || '').trim(); |
| } |
| const [ancestors, ancestorPlaceholders] = _splitAndEscapeSelector(this._ancestor); |
| const [selectors, selectorPlaceholders] = _splitAndEscapeSelector(this.harnessType.hostSelector || ''); |
| const result = []; |
| // We have to add the ancestor to each part of the host compound selector, otherwise we can get |
| // incorrect results. E.g. `.ancestor .a, .ancestor .b` vs `.ancestor .a, .b`. |
| ancestors.forEach(escapedAncestor => { |
| const ancestor = _restoreSelector(escapedAncestor, ancestorPlaceholders); |
| return selectors.forEach(escapedSelector => result.push(`${ancestor} ${_restoreSelector(escapedSelector, selectorPlaceholders)}`)); |
| }); |
| return result.join(', '); |
| } |
| /** Adds base options common to all harness types. */ |
| _addBaseOptions(options) { |
| this._ancestor = options.ancestor || ''; |
| if (this._ancestor) { |
| this._descriptions.push(`has ancestor matching selector "${this._ancestor}"`); |
| } |
| const selector = options.selector; |
| if (selector !== undefined) { |
| this.add(`host matches selector "${selector}"`, (item) => __awaiter(this, void 0, void 0, function* () { |
| return (yield item.host()).matchesSelector(selector); |
| })); |
| } |
| } |
| } |
| /** Represent a value as a string for the purpose of logging. */ |
| function _valueAsString(value) { |
| if (value === undefined) { |
| return 'undefined'; |
| } |
| // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer. |
| try { |
| return JSON.stringify(value, (_, v) => { |
| if (v instanceof RegExp) { |
| return `/${v.toString()}/`; |
| } |
| return typeof v === 'string' ? v.replace('/\//g', '\\/') : v; |
| }).replace(/"\/\//g, '\\/').replace(/\/\/"/g, '\\/').replace(/\\\//g, '/'); |
| } |
| catch (_a) { |
| // `JSON.stringify` will throw if the object is cyclical, |
| // in this case the best we can do is report the value as `{...}`. |
| return '{...}'; |
| } |
| } |
| /** |
| * Splits up a compound selector into its parts and escapes any quoted content. The quoted content |
| * has to be escaped, because it can contain commas which will throw throw us off when trying to |
| * split it. |
| * @param selector Selector to be split. |
| * @returns The escaped string where any quoted content is replaced with a placeholder. E.g. |
| * `[foo="bar"]` turns into `[foo=__cdkPlaceholder-0__]`. Use `_restoreSelector` to restore |
| * the placeholders. |
| */ |
| function _splitAndEscapeSelector(selector) { |
| const placeholders = []; |
| // Note that the regex doesn't account for nested quotes so something like `"ab'cd'e"` will be |
| // considered as two blocks. It's a bit of an edge case, but if we find that it's a problem, |
| // we can make it a bit smarter using a loop. Use this for now since it's more readable and |
| // compact. More complete implementation: |
| // https://github.com/angular/angular/blob/bd34bc9e89f18a/packages/compiler/src/shadow_css.ts#L655 |
| const result = selector.replace(/(["'][^["']*["'])/g, (_, keep) => { |
| const replaceBy = `__cdkPlaceholder-${placeholders.length}__`; |
| placeholders.push(keep); |
| return replaceBy; |
| }); |
| return [result.split(',').map(part => part.trim()), placeholders]; |
| } |
| /** Restores a selector whose content was escaped in `_splitAndEscapeSelector`. */ |
| function _restoreSelector(selector, placeholders) { |
| return selector.replace(/__cdkPlaceholder-(\d+)__/g, (_, index) => placeholders[+index]); |
| } |
| //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-harness.js","sourceRoot":"","sources":["../../../../../../src/cdk/testing/component-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 {parallel} from './change-detection';\nimport {TestElement} from './test-element';\n\n/** An async function that returns a promise when called. */\nexport type AsyncFactoryFn<T> = () => Promise<T>;\n\n/** An async function that takes an item and returns a boolean promise */\nexport type AsyncPredicate<T> = (item: T) => Promise<boolean>;\n\n/** An async function that takes an item and an option value and returns a boolean promise. */\nexport type AsyncOptionPredicate<T, O> = (item: T, option: O) => Promise<boolean>;\n\n/**\n * A query for a `ComponentHarness`, which is expressed as either a `ComponentHarnessConstructor` or\n * a `HarnessPredicate`.\n */\nexport type HarnessQuery<T extends ComponentHarness> =\n    ComponentHarnessConstructor<T> | HarnessPredicate<T>;\n\n/**\n * The result type obtained when searching using a particular list of queries. This type depends on\n * the particular items being queried.\n * - If one of the queries is for a `ComponentHarnessConstructor<C1>`, it means that the result\n *   might be a harness of type `C1`\n * - If one of the queries is for a `HarnessPredicate<C2>`, it means that the result might be a\n *   harness of type `C2`\n * - If one of the queries is for a `string`, it means that the result might be a `TestElement`.\n *\n * Since we don't know for sure which query will match, the result type if the union of the types\n * for all possible results.\n *\n * e.g.\n * The type:\n * `LocatorFnResult&lt;[\n *   ComponentHarnessConstructor&lt;MyHarness&gt;,\n *   HarnessPredicate&lt;MyOtherHarness&gt;,\n *   string\n * ]&gt;`\n * is equivalent to:\n * `MyHarness | MyOtherHarness | TestElement`.\n */\nexport type LocatorFnResult<T extends (HarnessQuery<any> | string)[]> = {\n  [I in keyof T]:\n      // Map `ComponentHarnessConstructor<C>` to `C`.\n      T[I] extends new (...args: any[]) => infer C ? C :\n      // Map `HarnessPredicate<C>` to `C`.\n      T[I] extends { harnessType: new (...args: any[]) => infer C } ? C :\n      // Map `string` to `TestElement`.\n      T[I] extends string ? TestElement :\n      // Map everything else to `never` (should not happen due to the type constraint on `T`).\n      never;\n}[number];\n\n\n/**\n * Interface used to load ComponentHarness objects. This interface is used by test authors to\n * instantiate `ComponentHarness`es.\n */\nexport interface HarnessLoader {\n  /**\n   * Searches for an element with the given selector under the current instances's root element,\n   * and returns a `HarnessLoader` rooted at the matching element. If multiple elements match the\n   * selector, the first is used. If no elements match, an error is thrown.\n   * @param selector The selector for the root element of the new `HarnessLoader`\n   * @return A `HarnessLoader` rooted at the element matching the given selector.\n   * @throws If a matching element can't be found.\n   */\n  getChildLoader(selector: string): Promise<HarnessLoader>;\n\n  /**\n   * Searches for all elements with the given selector under the current instances's root element,\n   * and returns an array of `HarnessLoader`s, one for each matching element, rooted at that\n   * element.\n   * @param selector The selector for the root element of the new `HarnessLoader`\n   * @return A list of `HarnessLoader`s, one for each matching element, rooted at that element.\n   */\n  getAllChildLoaders(selector: string): Promise<HarnessLoader[]>;\n\n  /**\n   * Searches for an instance of the component corresponding to the given harness type under the\n   * `HarnessLoader`'s root element, and returns a `ComponentHarness` for that instance. If multiple\n   * matching components are found, a harness for the first one is returned. If no matching\n   * component is found, an error is thrown.\n   * @param query A query for a harness to create\n   * @return An instance of the given harness type\n   * @throws If a matching component instance can't be found.\n   */\n  getHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T>;\n\n  /**\n   * Searches for all instances of the component corresponding to the given harness type under the\n   * `HarnessLoader`'s root element, and returns a list `ComponentHarness` for each instance.\n   * @param query A query for a harness to create\n   * @return A list instances of the given harness type.\n   */\n  getAllHarnesses<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T[]>;\n}\n\n/**\n * Interface used to create asynchronous locator functions used find elements and component\n * harnesses. This interface is used by `ComponentHarness` authors to create locator functions for\n * their `ComponentHarness` subclass.\n */\nexport interface LocatorFactory {\n  /** Gets a locator factory rooted at the document root. */\n  documentRootLocatorFactory(): LocatorFactory;\n\n  /** The root element of this `LocatorFactory` as a `TestElement`. */\n  rootElement: TestElement;\n\n  /**\n   * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance\n   * or element under the root element of this `LocatorFactory`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for the\n   *   first element or harness matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If no matches are found, the\n   *   `Promise` rejects. The type that the `Promise` resolves to is a union of all result types for\n   *   each query.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'`:\n   * - `await lf.locatorFor(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`\n   * - `await lf.locatorFor('div', DivHarness)()` gets a `TestElement` instance for `#d1`\n   * - `await lf.locatorFor('span')()` throws because the `Promise` rejects.\n   */\n  locatorFor<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>>;\n\n  /**\n   * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance\n   * or element under the root element of this `LocatorFactory`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for the\n   *   first element or harness matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If no matches are found, the\n   *   `Promise` is resolved with `null`. The type that the `Promise` resolves to is a union of all\n   *   result types for each query or null.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'`:\n   * - `await lf.locatorForOptional(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`\n   * - `await lf.locatorForOptional('div', DivHarness)()` gets a `TestElement` instance for `#d1`\n   * - `await lf.locatorForOptional('span')()` gets `null`.\n   */\n  locatorForOptional<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T> | null>;\n\n  /**\n   * Creates an asynchronous locator function that can be used to find `ComponentHarness` instances\n   * or elements under the root element of this `LocatorFactory`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for all\n   *   elements and harnesses matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If an element matches more than\n   *   one `ComponentHarness` class, the locator gets an instance of each for the same element. If\n   *   an element matches multiple `string` selectors, only one `TestElement` instance is returned\n   *   for that element. The type that the `Promise` resolves to is an array where each element is\n   *   the union of all result types for each query.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'` and `IdIsD1Harness.hostSelector === '#d1'`:\n   * - `await lf.locatorForAll(DivHarness, 'div')()` gets `[\n   *     DivHarness, // for #d1\n   *     TestElement, // for #d1\n   *     DivHarness, // for #d2\n   *     TestElement // for #d2\n   *   ]`\n   * - `await lf.locatorForAll('div', '#d1')()` gets `[\n   *     TestElement, // for #d1\n   *     TestElement // for #d2\n   *   ]`\n   * - `await lf.locatorForAll(DivHarness, IdIsD1Harness)()` gets `[\n   *     DivHarness, // for #d1\n   *     IdIsD1Harness, // for #d1\n   *     DivHarness // for #d2\n   *   ]`\n   * - `await lf.locatorForAll('span')()` gets `[]`.\n   */\n  locatorForAll<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>[]>;\n\n  /** @return A `HarnessLoader` rooted at the root element of this `LocatorFactory`. */\n  rootHarnessLoader(): Promise<HarnessLoader>;\n\n  /**\n   * Gets a `HarnessLoader` instance for an element under the root of this `LocatorFactory`.\n   * @param selector The selector for the root element.\n   * @return A `HarnessLoader` rooted at the first element matching the given selector.\n   * @throws If no matching element is found for the given selector.\n   */\n  harnessLoaderFor(selector: string): Promise<HarnessLoader>;\n\n  /**\n   * Gets a `HarnessLoader` instance for an element under the root of this `LocatorFactory`\n   * @param selector The selector for the root element.\n   * @return A `HarnessLoader` rooted at the first element matching the given selector, or null if\n   *     no matching element is found.\n   */\n  harnessLoaderForOptional(selector: string): Promise<HarnessLoader | null>;\n\n  /**\n   * Gets a list of `HarnessLoader` instances, one for each matching element.\n   * @param selector The selector for the root element.\n   * @return A list of `HarnessLoader`, one rooted at each element matching the given selector.\n   */\n  harnessLoaderForAll(selector: string): Promise<HarnessLoader[]>;\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  forceStabilize(): Promise<void>;\n\n  /**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */\n  waitForTasksOutsideAngular(): Promise<void>;\n}\n\n/**\n * Base class for component harnesses that all component harness authors should extend. This base\n * component harness provides the basic ability to locate element and sub-component harness. It\n * should be inherited when defining user's own harness.\n */\nexport abstract class ComponentHarness {\n  constructor(protected readonly locatorFactory: LocatorFactory) {}\n\n  /** Gets a `Promise` for the `TestElement` representing the host element of the component. */\n  async host(): Promise<TestElement> {\n    return this.locatorFactory.rootElement;\n  }\n\n  /**\n   * Gets a `LocatorFactory` for the document root element. This factory can be used to create\n   * locators for elements that a component creates outside of its own root element. (e.g. by\n   * appending to document.body).\n   */\n  protected documentRootLocatorFactory(): LocatorFactory {\n    return this.locatorFactory.documentRootLocatorFactory();\n  }\n\n  /**\n   * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance\n   * or element under the host element of this `ComponentHarness`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for the\n   *   first element or harness matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If no matches are found, the\n   *   `Promise` rejects. The type that the `Promise` resolves to is a union of all result types for\n   *   each query.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'`:\n   * - `await ch.locatorFor(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`\n   * - `await ch.locatorFor('div', DivHarness)()` gets a `TestElement` instance for `#d1`\n   * - `await ch.locatorFor('span')()` throws because the `Promise` rejects.\n   */\n  protected locatorFor<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>> {\n    return this.locatorFactory.locatorFor(...queries);\n  }\n\n  /**\n   * Creates an asynchronous locator function that can be used to find a `ComponentHarness` instance\n   * or element under the host element of this `ComponentHarness`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for the\n   *   first element or harness matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If no matches are found, the\n   *   `Promise` is resolved with `null`. The type that the `Promise` resolves to is a union of all\n   *   result types for each query or null.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'`:\n   * - `await ch.locatorForOptional(DivHarness, 'div')()` gets a `DivHarness` instance for `#d1`\n   * - `await ch.locatorForOptional('div', DivHarness)()` gets a `TestElement` instance for `#d1`\n   * - `await ch.locatorForOptional('span')()` gets `null`.\n   */\n  protected locatorForOptional<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T> | null> {\n    return this.locatorFactory.locatorForOptional(...queries);\n  }\n\n  /**\n   * Creates an asynchronous locator function that can be used to find `ComponentHarness` instances\n   * or elements under the host element of this `ComponentHarness`.\n   * @param queries A list of queries specifying which harnesses and elements to search for:\n   *   - A `string` searches for elements matching the CSS selector specified by the string.\n   *   - A `ComponentHarness` constructor searches for `ComponentHarness` instances matching the\n   *     given class.\n   *   - A `HarnessPredicate` searches for `ComponentHarness` instances matching the given\n   *     predicate.\n   * @return An asynchronous locator function that searches for and returns a `Promise` for all\n   *   elements and harnesses matching the given search criteria. Matches are ordered first by\n   *   order in the DOM, and second by order in the queries list. If an element matches more than\n   *   one `ComponentHarness` class, the locator gets an instance of each for the same element. If\n   *   an element matches multiple `string` selectors, only one `TestElement` instance is returned\n   *   for that element. The type that the `Promise` resolves to is an array where each element is\n   *   the union of all result types for each query.\n   *\n   * e.g. Given the following DOM: `<div id=\"d1\" /><div id=\"d2\" />`, and assuming\n   * `DivHarness.hostSelector === 'div'` and `IdIsD1Harness.hostSelector === '#d1'`:\n   * - `await ch.locatorForAll(DivHarness, 'div')()` gets `[\n   *     DivHarness, // for #d1\n   *     TestElement, // for #d1\n   *     DivHarness, // for #d2\n   *     TestElement // for #d2\n   *   ]`\n   * - `await ch.locatorForAll('div', '#d1')()` gets `[\n   *     TestElement, // for #d1\n   *     TestElement // for #d2\n   *   ]`\n   * - `await ch.locatorForAll(DivHarness, IdIsD1Harness)()` gets `[\n   *     DivHarness, // for #d1\n   *     IdIsD1Harness, // for #d1\n   *     DivHarness // for #d2\n   *   ]`\n   * - `await ch.locatorForAll('span')()` gets `[]`.\n   */\n  protected locatorForAll<T extends (HarnessQuery<any> | string)[]>(...queries: T):\n      AsyncFactoryFn<LocatorFnResult<T>[]> {\n    return this.locatorFactory.locatorForAll(...queries);\n  }\n\n  /**\n   * Flushes change detection and async tasks 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  protected async forceStabilize() {\n    return this.locatorFactory.forceStabilize();\n  }\n\n  /**\n   * Waits for all scheduled or running async tasks to complete. This allows harness\n   * authors to wait for async tasks outside of the Angular zone.\n   */\n  protected async waitForTasksOutsideAngular() {\n    return this.locatorFactory.waitForTasksOutsideAngular();\n  }\n}\n\n\n/**\n * Base class for component harnesses that authors should extend if they anticipate that consumers\n * of the harness may want to access other harnesses within the `<ng-content>` of the component.\n */\nexport abstract class ContentContainerComponentHarness<S extends string = string>\n  extends ComponentHarness implements HarnessLoader {\n\n  async getChildLoader(selector: S): Promise<HarnessLoader> {\n    return (await this.getRootHarnessLoader()).getChildLoader(selector);\n  }\n\n  async getAllChildLoaders(selector: S): Promise<HarnessLoader[]> {\n    return (await this.getRootHarnessLoader()).getAllChildLoaders(selector);\n  }\n\n  async getHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T> {\n    return (await this.getRootHarnessLoader()).getHarness(query);\n  }\n\n  async getAllHarnesses<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T[]> {\n    return (await this.getRootHarnessLoader()).getAllHarnesses(query);\n  }\n\n  /**\n   * Gets the root harness loader from which to start\n   * searching for content contained by this harness.\n   */\n  protected async getRootHarnessLoader(): Promise<HarnessLoader> {\n    return this.locatorFactory.rootHarnessLoader();\n  }\n}\n\n/** Constructor for a ComponentHarness subclass. */\nexport interface ComponentHarnessConstructor<T extends ComponentHarness> {\n  new(locatorFactory: LocatorFactory): T;\n\n  /**\n   * `ComponentHarness` subclasses must specify a static `hostSelector` property that is used to\n   * find the host element for the corresponding component. This property should match the selector\n   * for the Angular component.\n   */\n  hostSelector: string;\n}\n\n/** A set of criteria that can be used to filter a list of `ComponentHarness` instances. */\nexport interface BaseHarnessFilters {\n  /** Only find instances whose host element matches the given selector. */\n  selector?: string;\n  /** Only find instances that are nested under an element with the given selector. */\n  ancestor?: string;\n}\n\n/**\n * A class used to associate a ComponentHarness class with predicates functions that can be used to\n * filter instances of the class.\n */\nexport class HarnessPredicate<T extends ComponentHarness> {\n  private _predicates: AsyncPredicate<T>[] = [];\n  private _descriptions: string[] = [];\n  private _ancestor: string;\n\n  constructor(public harnessType: ComponentHarnessConstructor<T>, options: BaseHarnessFilters) {\n    this._addBaseOptions(options);\n  }\n\n  /**\n   * Checks if the specified nullable string value matches the given pattern.\n   * @param value The nullable string value to check, or a Promise resolving to the\n   *   nullable string value.\n   * @param pattern The pattern the value is expected to match. If `pattern` is a string,\n   *   `value` is expected to match exactly. If `pattern` is a regex, a partial match is\n   *   allowed. If `pattern` is `null`, the value is expected to be `null`.\n   * @return Whether the value matches the pattern.\n   */\n  static async stringMatches(value: string | null | Promise<string | null>,\n                             pattern: string | RegExp | null): Promise<boolean> {\n    value = await value;\n    if (pattern === null) {\n      return value === null;\n    } else if (value === null) {\n      return false;\n    }\n    return typeof pattern === 'string' ? value === pattern : pattern.test(value);\n  }\n\n  /**\n   * Adds a predicate function to be run against candidate harnesses.\n   * @param description A description of this predicate that may be used in error messages.\n   * @param predicate An async predicate function.\n   * @return this (for method chaining).\n   */\n  add(description: string, predicate: AsyncPredicate<T>) {\n    this._descriptions.push(description);\n    this._predicates.push(predicate);\n    return this;\n  }\n\n  /**\n   * Adds a predicate function that depends on an option value to be run against candidate\n   * harnesses. If the option value is undefined, the predicate will be ignored.\n   * @param name The name of the option (may be used in error messages).\n   * @param option The option value.\n   * @param predicate The predicate function to run if the option value is not undefined.\n   * @return this (for method chaining).\n   */\n  addOption<O>(name: string, option: O | undefined, predicate: AsyncOptionPredicate<T, O>) {\n    if (option !== undefined) {\n      this.add(`${name} = ${_valueAsString(option)}`, item => predicate(item, option));\n    }\n    return this;\n  }\n\n  /**\n   * Filters a list of harnesses on this predicate.\n   * @param harnesses The list of harnesses to filter.\n   * @return A list of harnesses that satisfy this predicate.\n   */\n  async filter(harnesses: T[]): Promise<T[]> {\n    if (harnesses.length === 0) {\n      return [];\n    }\n    const results = await parallel(() => harnesses.map(h => this.evaluate(h)));\n    return harnesses.filter((_, i) => results[i]);\n  }\n\n  /**\n   * Evaluates whether the given harness satisfies this predicate.\n   * @param harness The harness to check\n   * @return A promise that resolves to true if the harness satisfies this predicate,\n   *   and resolves to false otherwise.\n   */\n  async evaluate(harness: T): Promise<boolean> {\n    const results = await parallel(() => this._predicates.map(p => p(harness)));\n    return results.reduce((combined, current) => combined && current, true);\n  }\n\n  /** Gets a description of this predicate for use in error messages. */\n  getDescription() {\n    return this._descriptions.join(', ');\n  }\n\n  /** Gets the selector used to find candidate elements. */\n  getSelector() {\n    // We don't have to go through the extra trouble if there are no ancestors.\n    if (!this._ancestor) {\n      return (this.harnessType.hostSelector || '').trim();\n    }\n\n    const [ancestors, ancestorPlaceholders] = _splitAndEscapeSelector(this._ancestor);\n    const [selectors, selectorPlaceholders] =\n      _splitAndEscapeSelector(this.harnessType.hostSelector || '');\n    const result: string[] = [];\n\n    // We have to add the ancestor to each part of the host compound selector, otherwise we can get\n    // incorrect results. E.g. `.ancestor .a, .ancestor .b` vs `.ancestor .a, .b`.\n    ancestors.forEach(escapedAncestor => {\n      const ancestor = _restoreSelector(escapedAncestor, ancestorPlaceholders);\n      return selectors.forEach(escapedSelector =>\n        result.push(`${ancestor} ${_restoreSelector(escapedSelector, selectorPlaceholders)}`));\n    });\n\n    return result.join(', ');\n  }\n\n  /** Adds base options common to all harness types. */\n  private _addBaseOptions(options: BaseHarnessFilters) {\n    this._ancestor = options.ancestor || '';\n    if (this._ancestor) {\n      this._descriptions.push(`has ancestor matching selector \"${this._ancestor}\"`);\n    }\n    const selector = options.selector;\n    if (selector !== undefined) {\n      this.add(`host matches selector \"${selector}\"`, async item => {\n        return (await item.host()).matchesSelector(selector);\n      });\n    }\n  }\n}\n\n/** Represent a value as a string for the purpose of logging. */\nfunction _valueAsString(value: unknown) {\n  if (value === undefined) {\n    return 'undefined';\n  }\n  // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer.\n  try {\n    return JSON.stringify(value, (_, v) => {\n      if (v instanceof RegExp) {\n        return `/${v.toString()}/`;\n      }\n\n      return typeof v === 'string' ? v.replace('/\\//g', '\\\\/') : v;\n    }).replace(/\"\\/\\//g, '\\\\/').replace(/\\/\\/\"/g, '\\\\/').replace(/\\\\\\//g, '/');\n  } catch {\n    // `JSON.stringify` will throw if the object is cyclical,\n    // in this case the best we can do is report the value as `{...}`.\n    return '{...}';\n  }\n}\n\n/**\n * Splits up a compound selector into its parts and escapes any quoted content. The quoted content\n * has to be escaped, because it can contain commas which will throw throw us off when trying to\n * split it.\n * @param selector Selector to be split.\n * @returns The escaped string where any quoted content is replaced with a placeholder. E.g.\n * `[foo=\"bar\"]` turns into `[foo=__cdkPlaceholder-0__]`. Use `_restoreSelector` to restore\n * the placeholders.\n */\nfunction _splitAndEscapeSelector(selector: string): [parts: string[], placeholders: string[]] {\n  const placeholders: string[] = [];\n\n  // Note that the regex doesn't account for nested quotes so something like `\"ab'cd'e\"` will be\n  // considered as two blocks. It's a bit of an edge case, but if we find that it's a problem,\n  // we can make it a bit smarter using a loop. Use this for now since it's more readable and\n  // compact. More complete implementation:\n  // https://github.com/angular/angular/blob/bd34bc9e89f18a/packages/compiler/src/shadow_css.ts#L655\n  const result = selector.replace(/([\"'][^[\"']*[\"'])/g, (_, keep) => {\n    const replaceBy = `__cdkPlaceholder-${placeholders.length}__`;\n    placeholders.push(keep);\n    return replaceBy;\n  });\n\n  return [result.split(',').map(part => part.trim()), placeholders];\n}\n\n/** Restores a selector whose content was escaped in `_splitAndEscapeSelector`. */\nfunction _restoreSelector(selector: string, placeholders: string[]): string {\n  return selector.replace(/__cdkPlaceholder-(\\d+)__/g, (_, index) => placeholders[+index]);\n}\n"]} |
