/** * @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'; /** * 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. */ async host() { 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: `
`, 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: `
`, 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: `
`, 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. */ async forceStabilize() { 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. */ async waitForTasksOutsideAngular() { 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 `` of the component. */ export class ContentContainerComponentHarness extends ComponentHarness { async getChildLoader(selector) { return (await this.getRootHarnessLoader()).getChildLoader(selector); } async getAllChildLoaders(selector) { return (await this.getRootHarnessLoader()).getAllChildLoaders(selector); } async getHarness(query) { return (await this.getRootHarnessLoader()).getHarness(query); } async getHarnessOrNull(query) { return (await this.getRootHarnessLoader()).getHarnessOrNull(query); } async getAllHarnesses(query) { return (await this.getRootHarnessLoader()).getAllHarnesses(query); } async hasHarness(query) { return (await this.getRootHarnessLoader()).hasHarness(query); } /** * Gets the root harness loader from which to start * searching for content contained by this harness. */ async getRootHarnessLoader() { 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 async stringMatches(value, pattern) { value = await 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. */ async filter(harnesses) { if (harnesses.length === 0) { return []; } const results = await 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. */ async evaluate(harness) { const results = await 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}"`, async (item) => { return (await item.host()).matchesSelector(selector); }); } } } /** Represent a value as a string for the purpose of logging. */ function _valueAsString(value) { if (value === undefined) { return 'undefined'; } try { // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer. // Use a character that is unlikely to appear in real strings to denote the start and end of // the regex. This allows us to strip out the extra quotes around the value added by // `JSON.stringify`. Also do custom escaping on `"` characters to prevent `JSON.stringify` // from escaping them as if they were part of a string. const stringifiedValue = JSON.stringify(value, (_, v) => v instanceof RegExp ? `◬MAT_RE_ESCAPE◬${v.toString().replace(/"/g, '◬MAT_RE_ESCAPE◬')}◬MAT_RE_ESCAPE◬` : v); // Strip out the extra quotes around regexes and put back the manually escaped `"` characters. return stringifiedValue .replace(/"◬MAT_RE_ESCAPE◬|◬MAT_RE_ESCAPE◬"/g, '') .replace(/◬MAT_RE_ESCAPE◬/g, '"'); } catch { // `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>\n  | 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]: T[I] extends new (...args: any[]) => infer C // Map `ComponentHarnessConstructor<C>` to `C`.\n    ? C\n    : // Map `HarnessPredicate<C>` to `C`.\n    T[I] extends {harnessType: new (...args: any[]) => infer C}\n    ? C\n    : // Map `string` to `TestElement`.\n    T[I] extends string\n    ? TestElement\n    : // Map everything else to `never` (should not happen due to the type constraint on `T`).\n      never;\n}[number];\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 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, null is returned.\n   * @param query A query for a harness to create\n   * @return An instance of the given harness type (or null if not found).\n   */\n  getHarnessOrNull<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T | null>;\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   * Searches for an instance of the component corresponding to the given harness type under the\n   * `HarnessLoader`'s root element, and returns a boolean indicating if any were found.\n   * @param query A query for a harness to create\n   * @return A boolean indicating if an instance was found.\n   */\n  hasHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<boolean>;\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)[]>(\n    ...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)[]>(\n    ...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)[]>(\n    ...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)[]>(\n    ...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)[]>(\n    ...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)[]>(\n    ...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 * 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\n  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 getHarnessOrNull<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T | null> {\n    return (await this.getRootHarnessLoader()).getHarnessOrNull(query);\n  }\n\n  async getAllHarnesses<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<T[]> {\n    return (await this.getRootHarnessLoader()).getAllHarnesses(query);\n  }\n\n  async hasHarness<T extends ComponentHarness>(query: HarnessQuery<T>): Promise<boolean> {\n    return (await this.getRootHarnessLoader()).hasHarness(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(\n    value: string | null | Promise<string | null>,\n    pattern: string | RegExp | null,\n  ): 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] = _splitAndEscapeSelector(\n      this.harnessType.hostSelector || '',\n    );\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\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  try {\n    // `JSON.stringify` doesn't handle RegExp properly, so we need a custom replacer.\n    // Use a character that is unlikely to appear in real strings to denote the start and end of\n    // the regex. This allows us to strip out the extra quotes around the value added by\n    // `JSON.stringify`. Also do custom escaping on `\"` characters to prevent `JSON.stringify`\n    // from escaping them as if they were part of a string.\n    const stringifiedValue = JSON.stringify(value, (_, v) =>\n      v instanceof RegExp\n        ? `◬MAT_RE_ESCAPE◬${v.toString().replace(/\"/g, '◬MAT_RE_ESCAPE◬')}◬MAT_RE_ESCAPE◬`\n        : v,\n    );\n    // Strip out the extra quotes around regexes and put back the manually escaped `\"` characters.\n    return stringifiedValue\n      .replace(/\"◬MAT_RE_ESCAPE◬|◬MAT_RE_ESCAPE◬\"/g, '')\n      .replace(/◬MAT_RE_ESCAPE◬/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"]}