@skyux/lookup 11.22.0 → 11.23.0

package/esm2022/testing/legacy/search/search-fixture.mjs

@@ -0,0 +1,60 @@
+import { By } from '@angular/platform-browser';
+import { SkyAppTestUtility } from '@skyux-sdk/testing';
+/**
+ * Allows interaction with a SKY UX search component.
+ * @deprecated Use `SkySearchHarness` instead.
+ * @internal
+ */
+export class SkySearchFixture {
+    /**
+     * Gets the search's current text.
+     */
+    get searchText() {
+        return this.#getInputEl().nativeElement.value;
+    }
+    /**
+     * Gets the search's current placeholder text.
+     */
+    get placeholderText() {
+        return this.#getInputEl().nativeElement.placeholder;
+    }
+    #debugEl;
+    constructor(fixture, skyTestId) {
+        this.#debugEl = SkyAppTestUtility.getDebugElementByTestId(fixture, skyTestId, 'sky-search');
+    }
+    /**
+     * Applies the specified search text, invoking the search.
+     * @param searchText The search text to apply.  If none is specified, the search's
+     * current search text will be applied.
+     */
+    apply(searchText) {
+        if (searchText) {
+            SkyAppTestUtility.setInputValue(this.#getInputEl().nativeElement, searchText);
+        }
+        const btnEl = this.#getApplyBtnEl();
+        btnEl.triggerEventHandler('click', {});
+    }
+    /**
+     * Clears the current search text. If there is no search text or the search text is
+     * not currently applied, an error is thrown.
+     */
+    clear() {
+        const clearEl = this.#debugEl.query(By.css('.sky-input-group-clear'));
+        if (!SkyAppTestUtility.isVisible(clearEl)) {
+            throw new Error('There currently is no search text or the current search text has not been applied, ' +
+                'so the clear button is not visible.');
+        }
+        const btnEl = this.#getClearBtnEl();
+        btnEl.triggerEventHandler('click', {});
+    }
+    #getApplyBtnEl() {
+        return this.#debugEl.query(By.css('.sky-search-btn-apply'));
+    }
+    #getClearBtnEl() {
+        return this.#debugEl.query(By.css('.sky-search-btn-clear'));
+    }
+    #getInputEl() {
+        return this.#debugEl.query(By.css('.sky-search-input'));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/{search → legacy/search}/search-testing.module.mjs

@@ -16,4 +16,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.8", ngImpor
                     exports: [NoopAnimationsModule, SkySearchModule],
                 }]
         }] });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLXRlc3RpbmcubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xvb2t1cC90ZXN0aW5nL3NyYy9zZWFyY2gvc2VhcmNoLXRlc3RpbmcubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFDNUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFFaEQ7O0dBRUc7QUFJSCxNQUFNLE9BQU8sc0JBQXNCOzhHQUF0QixzQkFBc0I7K0dBQXRCLHNCQUFzQixZQUZ2QixvQkFBb0IsRUFBRSxlQUFlOytHQUVwQyxzQkFBc0IsWUFGdkIsb0JBQW9CLEVBQUUsZUFBZTs7MkZBRXBDLHNCQUFzQjtrQkFIbEMsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxlQUFlLENBQUM7aUJBQ2pEIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE5vb3BBbmltYXRpb25zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlci9hbmltYXRpb25zJztcbmltcG9ydCB7IFNreVNlYXJjaE1vZHVsZSB9IGZyb20gJ0Bza3l1eC9sb29rdXAnO1xuXG4vKipcbiAqIEBpbnRlcm5hbFxuICovXG5ATmdNb2R1bGUoe1xuICBleHBvcnRzOiBbTm9vcEFuaW1hdGlvbnNNb2R1bGUsIFNreVNlYXJjaE1vZHVsZV0sXG59KVxuZXhwb3J0IGNsYXNzIFNreVNlYXJjaFRlc3RpbmdNb2R1bGUge31cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VhcmNoLXRlc3RpbmcubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xvb2t1cC90ZXN0aW5nL3NyYy9sZWdhY3kvc2VhcmNoL3NlYXJjaC10ZXN0aW5nLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBQzVFLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBRWhEOztHQUVHO0FBSUgsTUFBTSxPQUFPLHNCQUFzQjs4R0FBdEIsc0JBQXNCOytHQUF0QixzQkFBc0IsWUFGdkIsb0JBQW9CLEVBQUUsZUFBZTsrR0FFcEMsc0JBQXNCLFlBRnZCLG9CQUFvQixFQUFFLGVBQWU7OzJGQUVwQyxzQkFBc0I7a0JBSGxDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsb0JBQW9CLEVBQUUsZUFBZSxDQUFDO2lCQUNqRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBOb29wQW5pbWF0aW9uc01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL3BsYXRmb3JtLWJyb3dzZXIvYW5pbWF0aW9ucyc7XG5pbXBvcnQgeyBTa3lTZWFyY2hNb2R1bGUgfSBmcm9tICdAc2t5dXgvbG9va3VwJztcblxuLyoqXG4gKiBAaW50ZXJuYWxcbiAqL1xuQE5nTW9kdWxlKHtcbiAgZXhwb3J0czogW05vb3BBbmltYXRpb25zTW9kdWxlLCBTa3lTZWFyY2hNb2R1bGVdLFxufSlcbmV4cG9ydCBjbGFzcyBTa3lTZWFyY2hUZXN0aW5nTW9kdWxlIHt9XG4iXX0=

package/esm2022/testing/modules/autocomplete/autocomplete-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWhhcm5lc3MtZmlsdGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9sb29rdXAvdGVzdGluZy9zcmMvbW9kdWxlcy9hdXRvY29tcGxldGUvYXV0b2NvbXBsZXRlLWhhcm5lc3MtZmlsdGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5SGFybmVzc0ZpbHRlcnMgfSBmcm9tICdAc2t5dXgvY29yZS90ZXN0aW5nJztcblxuLyoqXG4gKiBBIHNldCBvZiBjcml0ZXJpYSB0aGF0IGNhbiBiZSB1c2VkIHRvIGZpbHRlciBhIGxpc3Qgb2YgU2t5QXV0b2NvbXBsZXRlSGFybmVzcyBpbnN0YW5jZXMuXG4gKi9cbi8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktaW50ZXJmYWNlLCBAdHlwZXNjcmlwdC1lc2xpbnQvbm8tZW1wdHktb2JqZWN0LXR5cGVcbmV4cG9ydCBpbnRlcmZhY2UgU2t5QXV0b2NvbXBsZXRlSGFybmVzc0ZpbHRlcnMgZXh0ZW5kcyBTa3lIYXJuZXNzRmlsdGVycyB7fVxuIl19

package/esm2022/testing/modules/autocomplete/autocomplete-harness.mjs

@@ -0,0 +1,192 @@
+import { SkyComponentHarness, SkyOverlayHarness } from '@skyux/core/testing';
+import { SkyAutocompleteInputHarness } from './autocomplete-input-harness';
+import { SkyAutocompleteSearchResultHarness } from './autocomplete-search-result-harness';
+/**
+ * Harness for interacting with an autocomplete component in tests.
+ */
+export class SkyAutocompleteHarness extends SkyComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = 'sky-autocomplete'; }
+    #documentRootLocator = this.documentRootLocatorFactory();
+    #getAutocomplete = this.locatorFor('.sky-autocomplete');
+    #getInput = this.locatorFor(SkyAutocompleteInputHarness);
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyAutocompleteHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return SkyAutocompleteHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Blurs the autocomplete input.
+     * @deprecated Call `await (await autocomplete.getControl()).blur()` instead.
+     */
+    async blur() {
+        await (await this.#getInput()).blur();
+    }
+    /**
+     * Clears the autocomplete input value.
+     * @deprecated Call `await (await autocomplete.getControl()).clear()` instead.
+     */
+    async clear() {
+        await (await this.#getInput()).clear();
+    }
+    /**
+     * Enters text into the autocomplete input.
+     * @deprecated Call `await (await autocomplete.getControl()).setValue()` instead.
+     */
+    async enterText(value) {
+        await (await this.#getInput()).setValue(value);
+    }
+    /**
+     * Focuses the autocomplete input.
+     * @deprecated Call `await (await autocomplete.getControl()).focus()` instead.
+     */
+    async focus() {
+        await (await this.#getInput()).focus();
+    }
+    /**
+     * Gets the autocomplete `aria-labelledby` value.
+     */
+    async getAriaLabelledby() {
+        return await (await this.#getAutocomplete()).getAttribute('aria-labelledby');
+    }
+    /**
+     * Gets the autocomplete input harness.
+     */
+    async getControl() {
+        return await this.#getInput();
+    }
+    /**
+     * Returns autocomplete search result harnesses.
+     */
+    async getSearchResults(filters) {
+        const overlay = await this.#getOverlay();
+        if (!overlay) {
+            throw new Error('Unable to retrieve search results. The autocomplete is closed.');
+        }
+        const harnesses = await overlay.queryHarnesses(SkyAutocompleteSearchResultHarness.with(filters || {}));
+        if (filters && harnesses.length === 0) {
+            // Stringify the regular expression so that it's readable in the console log.
+            if (filters.text instanceof RegExp) {
+                filters.text = filters.text.toString();
+            }
+            throw new Error(`Could not find search results matching filter(s): ${JSON.stringify(filters)}`);
+        }
+        return harnesses;
+    }
+    /**
+     * Returns the text content for each autocomplete search result.
+     */
+    async getSearchResultsText(filters) {
+        const harnesses = await this.getSearchResults(filters);
+        const text = [];
+        for (const harness of harnesses) {
+            text.push(await harness.getText());
+        }
+        return text;
+    }
+    /**
+     * Gets the value of the autocomplete input.
+     * @deprecated Call `await (await autocomplete.getControl()).getValue()` instead.
+     */
+    async getValue() {
+        return await (await this.#getInput()).getValue();
+    }
+    /**
+     * Gets the text displayed when no search results are found.
+     */
+    async getNoResultsFoundText() {
+        const overlay = await this.#getOverlay();
+        if (!overlay) {
+            throw new Error('Cannot find "no results found" text as the dropdown is closed.');
+        }
+        try {
+            const noResultFoundText = await overlay.querySelector('.sky-autocomplete-no-results');
+            return (await noResultFoundText?.text())?.trim();
+        }
+        catch {
+            throw new Error('Cannot find "no results found" text because there are search results.');
+        }
+    }
+    /**
+     * Whether the autocomplete input is disabled.
+     * @deprecated Call `await (await autocomplete.getControl()).isDisabled()` instead.
+     */
+    async isDisabled() {
+        return await (await this.#getInput()).isDisabled();
+    }
+    /**
+     * Whether the autocomplete input is focused.
+     * @deprecated Call `await (await autocomplete.getControl()).isFocused()` instead.
+     */
+    async isFocused() {
+        return await (await this.#getInput()).isFocused();
+    }
+    /**
+     * Whether the autocomplete is open.
+     */
+    async isOpen() {
+        const overlay = await this.#getOverlay();
+        return !!overlay;
+    }
+    /**
+     * Selects a search result.
+     */
+    async selectSearchResult(filters) {
+        const results = await this.getSearchResults(filters);
+        if (results && results.length > 0) {
+            await results[0].select();
+        }
+    }
+    /**
+     * Clicks the "Add" button in the autocomplete search results panel.
+     * (The "Add" functionality is not included in the public API
+     * of a "vanilla" autocomplete component, so this method is protected
+     * to prevent consumers of the autocomplete harness from calling it.
+     * The lookup harness, which extends the autocomplete harness, may
+     * still access this feature, however.)
+     * @internal
+     */
+    async clickAddButton() {
+        const overlay = await this.#getOverlay();
+        if (!overlay) {
+            throw new Error('Unable to find the "Add" button. The autocomplete is closed.');
+        }
+        const button = await overlay.querySelectorOrNull('button.sky-autocomplete-action-add');
+        if (!button) {
+            throw new Error('The "Add" button cannot be clicked because it does not exist.');
+        }
+        await button.click();
+    }
+    /**
+     * Clicks the "Show more" button.
+     * (The "Show more" functionality is not included in the public API
+     * of a "vanilla" autocomplete component, so this method is protected
+     * to prevent consumers of the autocomplete harness from calling it.
+     * The lookup harness, which extends the autocomplete harness, may
+     * still access this feature, however.)
+     * @internal
+     */
+    async clickShowMoreButton() {
+        const overlay = await this.#getOverlay();
+        if (!overlay) {
+            throw new Error('Unable to find the "Show more" button. ' +
+                'The autocomplete is closed.');
+        }
+        const button = await overlay.querySelectorOrNull('button.sky-autocomplete-action-more');
+        if (!button) {
+            throw new Error('The "Show more" button cannot be clicked because it does not exist.');
+        }
+        await button.click();
+    }
+    async #getOverlay() {
+        const overlayId = await (await this.#getInput()).getAriaControls();
+        return overlayId
+            ? await this.#documentRootLocator.locatorForOptional(SkyOverlayHarness.with({ selector: `#${overlayId}` }))()
+            : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autocomplete-harness.js","sourceRoot":"","sources":["../../../../../../../../libs/components/lookup/testing/src/modules/autocomplete/autocomplete-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyComponentHarness, SkyOverlayHarness } from '@skyux/core/testing';\n\nimport { SkyAutocompleteHarnessFilters } from './autocomplete-harness-filters';\nimport { SkyAutocompleteInputHarness } from './autocomplete-input-harness';\nimport { SkyAutocompleteSearchResultHarness } from './autocomplete-search-result-harness';\nimport { SkyAutocompleteSearchResultHarnessFilters } from './autocomplete-search-result-harness-filters';\n\n/**\n * Harness for interacting with an autocomplete component in tests.\n */\nexport class SkyAutocompleteHarness extends SkyComponentHarness {\n  /**\n   * @internal\n   */\n  public static hostSelector = 'sky-autocomplete';\n\n  #documentRootLocator = this.documentRootLocatorFactory();\n  #getAutocomplete = this.locatorFor('.sky-autocomplete');\n  #getInput = this.locatorFor(SkyAutocompleteInputHarness);\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyAutocompleteHarness` that meets certain criteria.\n   */\n  public static with(\n    filters: SkyAutocompleteHarnessFilters,\n  ): HarnessPredicate<SkyAutocompleteHarness> {\n    return SkyAutocompleteHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Blurs the autocomplete input.\n   * @deprecated Call `await (await autocomplete.getControl()).blur()` instead.\n   */\n  public async blur(): Promise<void> {\n    await (await this.#getInput()).blur();\n  }\n\n  /**\n   * Clears the autocomplete input value.\n   * @deprecated Call `await (await autocomplete.getControl()).clear()` instead.\n   */\n  public async clear(): Promise<void> {\n    await (await this.#getInput()).clear();\n  }\n\n  /**\n   * Enters text into the autocomplete input.\n   * @deprecated Call `await (await autocomplete.getControl()).setValue()` instead.\n   */\n  public async enterText(value: string): Promise<void> {\n    await (await this.#getInput()).setValue(value);\n  }\n\n  /**\n   * Focuses the autocomplete input.\n   * @deprecated Call `await (await autocomplete.getControl()).focus()` instead.\n   */\n  public async focus(): Promise<void> {\n    await (await this.#getInput()).focus();\n  }\n\n  /**\n   * Gets the autocomplete `aria-labelledby` value.\n   */\n  public async getAriaLabelledby(): Promise<string | null> {\n    return await (\n      await this.#getAutocomplete()\n    ).getAttribute('aria-labelledby');\n  }\n\n  /**\n   * Gets the autocomplete input harness.\n   */\n  public async getControl(): Promise<SkyAutocompleteInputHarness> {\n    return await this.#getInput();\n  }\n\n  /**\n   * Returns autocomplete search result harnesses.\n   */\n  public async getSearchResults(\n    filters?: SkyAutocompleteSearchResultHarnessFilters,\n  ): Promise<SkyAutocompleteSearchResultHarness[]> {\n    const overlay = await this.#getOverlay();\n\n    if (!overlay) {\n      throw new Error(\n        'Unable to retrieve search results. The autocomplete is closed.',\n      );\n    }\n\n    const harnesses = await overlay.queryHarnesses(\n      SkyAutocompleteSearchResultHarness.with(filters || {}),\n    );\n\n    if (filters && harnesses.length === 0) {\n      // Stringify the regular expression so that it's readable in the console log.\n      if (filters.text instanceof RegExp) {\n        filters.text = filters.text.toString();\n      }\n\n      throw new Error(\n        `Could not find search results matching filter(s): ${JSON.stringify(\n          filters,\n        )}`,\n      );\n    }\n\n    return harnesses;\n  }\n\n  /**\n   * Returns the text content for each autocomplete search result.\n   */\n  public async getSearchResultsText(\n    filters?: SkyAutocompleteSearchResultHarnessFilters,\n  ): Promise<string[]> {\n    const harnesses = await this.getSearchResults(filters);\n\n    const text: string[] = [];\n    for (const harness of harnesses) {\n      text.push(await harness.getText());\n    }\n\n    return text;\n  }\n\n  /**\n   * Gets the value of the autocomplete input.\n   * @deprecated Call `await (await autocomplete.getControl()).getValue()` instead.\n   */\n  public async getValue(): Promise<string> {\n    return await (await this.#getInput()).getValue();\n  }\n\n  /**\n   * Gets the text displayed when no search results are found.\n   */\n  public async getNoResultsFoundText(): Promise<string | undefined> {\n    const overlay = await this.#getOverlay();\n\n    if (!overlay) {\n      throw new Error(\n        'Cannot find \"no results found\" text as the dropdown is closed.',\n      );\n    }\n\n    try {\n      const noResultFoundText = await overlay.querySelector(\n        '.sky-autocomplete-no-results',\n      );\n      return (await noResultFoundText?.text())?.trim();\n    } catch {\n      throw new Error(\n        'Cannot find \"no results found\" text because there are search results.',\n      );\n    }\n  }\n\n  /**\n   * Whether the autocomplete input is disabled.\n   * @deprecated Call `await (await autocomplete.getControl()).isDisabled()` instead.\n   */\n  public async isDisabled(): Promise<boolean> {\n    return await (await this.#getInput()).isDisabled();\n  }\n\n  /**\n   * Whether the autocomplete input is focused.\n   * @deprecated Call `await (await autocomplete.getControl()).isFocused()` instead.\n   */\n  public async isFocused(): Promise<boolean> {\n    return await (await this.#getInput()).isFocused();\n  }\n\n  /**\n   * Whether the autocomplete is open.\n   */\n  public async isOpen(): Promise<boolean> {\n    const overlay = await this.#getOverlay();\n    return !!overlay;\n  }\n\n  /**\n   * Selects a search result.\n   */\n  public async selectSearchResult(\n    filters: SkyAutocompleteSearchResultHarnessFilters,\n  ): Promise<void> {\n    const results = await this.getSearchResults(filters);\n    if (results && results.length > 0) {\n      await results[0].select();\n    }\n  }\n\n  /**\n   * Clicks the \"Add\" button in the autocomplete search results panel.\n   * (The \"Add\" functionality is not included in the public API\n   * of a \"vanilla\" autocomplete component, so this method is protected\n   * to prevent consumers of the autocomplete harness from calling it.\n   * The lookup harness, which extends the autocomplete harness, may\n   * still access this feature, however.)\n   * @internal\n   */\n  protected async clickAddButton(): Promise<void> {\n    const overlay = await this.#getOverlay();\n    if (!overlay) {\n      throw new Error(\n        'Unable to find the \"Add\" button. The autocomplete is closed.',\n      );\n    }\n\n    const button = await overlay.querySelectorOrNull(\n      'button.sky-autocomplete-action-add',\n    );\n\n    if (!button) {\n      throw new Error(\n        'The \"Add\" button cannot be clicked because it does not exist.',\n      );\n    }\n\n    await button.click();\n  }\n\n  /**\n   * Clicks the \"Show more\" button.\n   * (The \"Show more\" functionality is not included in the public API\n   * of a \"vanilla\" autocomplete component, so this method is protected\n   * to prevent consumers of the autocomplete harness from calling it.\n   * The lookup harness, which extends the autocomplete harness, may\n   * still access this feature, however.)\n   * @internal\n   */\n  protected async clickShowMoreButton(): Promise<void> {\n    const overlay = await this.#getOverlay();\n\n    if (!overlay) {\n      throw new Error(\n        'Unable to find the \"Show more\" button. ' +\n          'The autocomplete is closed.',\n      );\n    }\n\n    const button = await overlay.querySelectorOrNull(\n      'button.sky-autocomplete-action-more',\n    );\n\n    if (!button) {\n      throw new Error(\n        'The \"Show more\" button cannot be clicked because it does not exist.',\n      );\n    }\n\n    await button.click();\n  }\n\n  async #getOverlay(): Promise<SkyOverlayHarness | null> {\n    const overlayId = await (await this.#getInput()).getAriaControls();\n\n    return overlayId\n      ? await this.#documentRootLocator.locatorForOptional(\n          SkyOverlayHarness.with({ selector: `#${overlayId}` }),\n        )()\n      : null;\n  }\n}\n"]}

package/esm2022/testing/modules/autocomplete/autocomplete-input-harness.mjs

@@ -0,0 +1,17 @@
+import { SkyInputHarness } from '@skyux/core/testing';
+/**
+ * Harness to interact with the autocomplete input harness.
+ */
+export class SkyAutocompleteInputHarness extends SkyInputHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = '[skyAutocomplete]'; }
+    /**
+     * Returns the value of the input's `aria-controls` attribute.
+     */
+    async getAriaControls() {
+        return await (await this.host()).getAttribute('aria-controls');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLWlucHV0LWhhcm5lc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvbG9va3VwL3Rlc3Rpbmcvc3JjL21vZHVsZXMvYXV0b2NvbXBsZXRlL2F1dG9jb21wbGV0ZS1pbnB1dC1oYXJuZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUV0RDs7R0FFRztBQUNILE1BQU0sT0FBTywyQkFBNEIsU0FBUSxlQUFlO0lBQzlEOztPQUVHO2FBQ1csaUJBQVksR0FBRyxtQkFBbUIsQ0FBQztJQUVqRDs7T0FFRztJQUNJLEtBQUssQ0FBQyxlQUFlO1FBQzFCLE9BQU8sTUFBTSxDQUFDLE1BQU0sSUFBSSxDQUFDLElBQUksRUFBRSxDQUFDLENBQUMsWUFBWSxDQUFDLGVBQWUsQ0FBQyxDQUFDO0lBQ2pFLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTa3lJbnB1dEhhcm5lc3MgfSBmcm9tICdAc2t5dXgvY29yZS90ZXN0aW5nJztcblxuLyoqXG4gKiBIYXJuZXNzIHRvIGludGVyYWN0IHdpdGggdGhlIGF1dG9jb21wbGV0ZSBpbnB1dCBoYXJuZXNzLlxuICovXG5leHBvcnQgY2xhc3MgU2t5QXV0b2NvbXBsZXRlSW5wdXRIYXJuZXNzIGV4dGVuZHMgU2t5SW5wdXRIYXJuZXNzIHtcbiAgLyoqXG4gICAqIEBpbnRlcm5hbFxuICAgKi9cbiAgcHVibGljIHN0YXRpYyBob3N0U2VsZWN0b3IgPSAnW3NreUF1dG9jb21wbGV0ZV0nO1xuXG4gIC8qKlxuICAgKiBSZXR1cm5zIHRoZSB2YWx1ZSBvZiB0aGUgaW5wdXQncyBgYXJpYS1jb250cm9sc2AgYXR0cmlidXRlLlxuICAgKi9cbiAgcHVibGljIGFzeW5jIGdldEFyaWFDb250cm9scygpOiBQcm9taXNlPHN0cmluZyB8IG51bGw+IHtcbiAgICByZXR1cm4gYXdhaXQgKGF3YWl0IHRoaXMuaG9zdCgpKS5nZXRBdHRyaWJ1dGUoJ2FyaWEtY29udHJvbHMnKTtcbiAgfVxufVxuIl19

package/esm2022/testing/modules/autocomplete/autocomplete-search-result-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXV0b2NvbXBsZXRlLXNlYXJjaC1yZXN1bHQtaGFybmVzcy1maWx0ZXJzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21wb25lbnRzL2xvb2t1cC90ZXN0aW5nL3NyYy9tb2R1bGVzL2F1dG9jb21wbGV0ZS9hdXRvY29tcGxldGUtc2VhcmNoLXJlc3VsdC1oYXJuZXNzLWZpbHRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJhc2VIYXJuZXNzRmlsdGVycyB9IGZyb20gJ0Bhbmd1bGFyL2Nkay90ZXN0aW5nJztcblxuLyoqXG4gKiBBIHNldCBvZiBjcml0ZXJpYSB0aGF0IGNhbiBiZSB1c2VkIHRvIGZpbHRlciBhIGxpc3Qgb2YgU2t5QXV0b2NvbXBsZXRlU2VhcmNoUmVzdWx0SGFybmVzcyBpbnN0YW5jZXMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBTa3lBdXRvY29tcGxldGVTZWFyY2hSZXN1bHRIYXJuZXNzRmlsdGVyc1xuICBleHRlbmRzIE9taXQ8QmFzZUhhcm5lc3NGaWx0ZXJzLCAnc2VsZWN0b3InPiB7XG4gIC8qKlxuICAgKiBPbmx5IGZpbmQgaW5zdGFuY2VzIHdob3NlIGNvbnRlbnQgbWF0Y2hlcyB0aGUgZ2l2ZW4gdmFsdWUuXG4gICAqL1xuICB0ZXh0Pzogc3RyaW5nIHwgUmVnRXhwO1xufVxuIl19

package/esm2022/testing/modules/autocomplete/autocomplete-search-result-harness.mjs

@@ -0,0 +1,38 @@
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { SkyQueryableComponentHarness } from '@skyux/core/testing';
+/**
+ * Harness for interacting with an autocomplete search result in tests.
+ */
+export class SkyAutocompleteSearchResultHarness extends SkyQueryableComponentHarness {
+    /**
+     * @internal
+     */
+    static { this.hostSelector = '.sky-autocomplete-result'; }
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyAutocompleteSearchResultHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return new HarnessPredicate(SkyAutocompleteSearchResultHarness, filters).addOption('textContent', filters.text, async (harness, text) => await HarnessPredicate.stringMatches(await harness.getText(), text));
+    }
+    /**
+     * Returns the value of the search result's descriptor property.
+     * This value is set by the autocomplete's `descriptorProperty` input.
+     */
+    async getDescriptorValue() {
+        return (await (await this.host()).getAttribute('data-descriptor-value'));
+    }
+    /**
+     * Selects the search result.
+     */
+    async select() {
+        await (await this.host()).click();
+    }
+    /**
+     * Returns the text of the search result.
+     */
+    async getText() {
+        return await (await this.host()).text();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modules/country-field/country-field-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnRyeS1maWVsZC1oYXJuZXNzLWZpbHRlcnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbXBvbmVudHMvbG9va3VwL3Rlc3Rpbmcvc3JjL21vZHVsZXMvY291bnRyeS1maWVsZC9jb3VudHJ5LWZpZWxkLWhhcm5lc3MtZmlsdGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5SGFybmVzc0ZpbHRlcnMgfSBmcm9tICdAc2t5dXgvY29yZS90ZXN0aW5nJztcblxuLyoqXG4gKiBBIHNldCBvZiBjcml0ZXJpYSB0aGF0IGNhbiBiZSB1c2VkIHRvIGZpbHRlciBhIGxpc3Qgb2YgYFNreUNvdW50cnlGaWVsZEhhcm5lc3NgIGluc3RhbmNlcy5cbiAqL1xuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1pbnRlcmZhY2UsIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1vYmplY3QtdHlwZVxuZXhwb3J0IGludGVyZmFjZSBTa3lDb3VudHJ5RmllbGRIYXJuZXNzRmlsdGVycyBleHRlbmRzIFNreUhhcm5lc3NGaWx0ZXJzIHt9XG4iXX0=

package/esm2022/testing/modules/country-field/country-field-harness.mjs

@@ -0,0 +1,139 @@
+import { SkyOverlayHarness } from '@skyux/core/testing';
+import { SkyAutocompleteHarness } from '../autocomplete/autocomplete-harness';
+import { SkyAutocompleteInputHarness } from '../autocomplete/autocomplete-input-harness';
+import { SkyCountryFieldSearchResultHarness } from './country-field-search-result-harness';
+/**
+ * Harness for interacting with a country field component in tests.
+ */
+export class SkyCountryFieldHarness extends SkyAutocompleteHarness {
+    /**
+     * Finds a standard country field component, or a country field component that is wrapped by an input box component.
+     * For input box implementations, we need to use the `.sky-input-box` selector since the `sky-country-field`
+     * element is removed from the DOM.
+     * @internal
+     */
+    static { this.hostSelector = 'sky-country-field,.sky-country-field-container'; }
+    #documentRootLocator = this.documentRootLocatorFactory();
+    #getInput = this.locatorFor(SkyAutocompleteInputHarness);
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyCountryFieldHarness` that meets certain criteria.
+     * These filters only work for standalone country fields.
+     * For country fields wrapped inside `sky-input-box`, place filters
+     * on the input box instead, and query the country field using a `SkyInputBoxHarness`.
+     * For the input box implementation, see the code example.
+     */
+    static with(filters) {
+        return SkyCountryFieldHarness.getDataSkyIdPredicate(filters);
+    }
+    /**
+     * Blurs the country field input.
+     */
+    async blur() {
+        return await super.blur();
+    }
+    /**
+     * Clears the country field input value.
+     */
+    async clear() {
+        return await super.clear();
+    }
+    /**
+     * Enters text into the country field input.
+     */
+    async enterText(value) {
+        return await super.enterText(value);
+    }
+    /**
+     * Focuses the country field input.
+     */
+    async focus() {
+        return await super.focus();
+    }
+    /**
+     * Gets the country field  `aria-labelledby` value.
+     * This is not needed for country field because the id is generated internally,
+     * and the method is marked internal to prevent it from being documented publicly.
+     * @internal
+     */
+    /* istanbul ignore next */
+    async getAriaLabelledby() {
+        return await super.getAriaLabelledby();
+    }
+    /**
+     * Returns country field search result harnesses.
+     */
+    async getSearchResults(filters) {
+        const overlay = await this.#getOverlay();
+        if (!overlay) {
+            throw new Error('Unable to retrieve search results. The country field is closed.');
+        }
+        const harnesses = await overlay.queryHarnesses(SkyCountryFieldSearchResultHarness.with(filters || {}));
+        if (filters && harnesses.length === 0) {
+            // Stringify the regular expression so that it's readable in the console log.
+            if (filters.text instanceof RegExp) {
+                filters.text = filters.text.toString();
+            }
+            throw new Error(`Could not find search results matching filter(s): ${JSON.stringify(filters)}`);
+        }
+        return harnesses;
+    }
+    /**
+     * Returns the text content for each country field search result.
+     */
+    async getSearchResultsText(filters) {
+        const harnesses = await this.getSearchResults(filters);
+        const text = [];
+        for (const harness of harnesses) {
+            text.push(await harness.getText());
+        }
+        return text;
+    }
+    /**
+     * Gets the value of the country field input.
+     */
+    async getValue() {
+        return await super.getValue();
+    }
+    /**
+     * Gets the text displayed when no search results are found.
+     * For a country field, this is always the default text and the method
+     * is marked internal to prevent it from being documented publicly.
+     * @internal
+     */
+    /* istanbul ignore next */
+    async getNoResultsFoundText() {
+        return await super.getNoResultsFoundText();
+    }
+    /**
+     * Whether the country field input is disabled.
+     */
+    async isDisabled() {
+        return await super.isDisabled();
+    }
+    /**
+     * Whether the country field input is focused.
+     */
+    async isFocused() {
+        return await super.isFocused();
+    }
+    /**
+     * Whether the country field is open.
+     */
+    async isOpen() {
+        return await super.isOpen();
+    }
+    /**
+     * Selects a search result.
+     */
+    async selectSearchResult(filters) {
+        return await super.selectSearchResult(filters);
+    }
+    async #getOverlay() {
+        const overlayId = await (await this.#getInput()).getAriaControls();
+        return overlayId
+            ? await this.#documentRootLocator.locatorForOptional(SkyOverlayHarness.with({ selector: `#${overlayId}` }))()
+            : null;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"country-field-harness.js","sourceRoot":"","sources":["../../../../../../../../libs/components/lookup/testing/src/modules/country-field/country-field-harness.ts"],"names":[],"mappings":"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","sourcesContent":["import { HarnessPredicate } from '@angular/cdk/testing';\nimport { SkyOverlayHarness } from '@skyux/core/testing';\n\nimport { SkyAutocompleteHarness } from '../autocomplete/autocomplete-harness';\nimport { SkyAutocompleteInputHarness } from '../autocomplete/autocomplete-input-harness';\n\nimport { SkyCountryFieldHarnessFilters } from './country-field-harness-filters';\nimport { SkyCountryFieldSearchResultHarness } from './country-field-search-result-harness';\nimport { SkyCountryFieldSearchResultHarnessFilters } from './country-field-search-result-harness-filters';\n\n/**\n * Harness for interacting with a country field component in tests.\n */\nexport class SkyCountryFieldHarness extends SkyAutocompleteHarness {\n  /**\n   * Finds a standard country field component, or a country field component that is wrapped by an input box component.\n   * For input box implementations, we need to use the `.sky-input-box` selector since the `sky-country-field`\n   * element is removed from the DOM.\n   * @internal\n   */\n  public static override hostSelector =\n    'sky-country-field,.sky-country-field-container';\n\n  #documentRootLocator = this.documentRootLocatorFactory();\n\n  #getInput = this.locatorFor(SkyAutocompleteInputHarness);\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a\n   * `SkyCountryFieldHarness` that meets certain criteria.\n   * These filters only work for standalone country fields.\n   * For country fields wrapped inside `sky-input-box`, place filters\n   * on the input box instead, and query the country field using a `SkyInputBoxHarness`.\n   * For the input box implementation, see the code example.\n   */\n  public static override with(\n    filters: SkyCountryFieldHarnessFilters,\n  ): HarnessPredicate<SkyCountryFieldHarness> {\n    return SkyCountryFieldHarness.getDataSkyIdPredicate(filters);\n  }\n\n  /**\n   * Blurs the country field input.\n   */\n  public override async blur(): Promise<void> {\n    return await super.blur();\n  }\n\n  /**\n   * Clears the country field input value.\n   */\n  public override async clear(): Promise<void> {\n    return await super.clear();\n  }\n\n  /**\n   * Enters text into the country field input.\n   */\n  public override async enterText(value: string): Promise<void> {\n    return await super.enterText(value);\n  }\n\n  /**\n   * Focuses the country field input.\n   */\n  public override async focus(): Promise<void> {\n    return await super.focus();\n  }\n\n  /**\n   * Gets the country field  `aria-labelledby` value.\n   * This is not needed for country field because the id is generated internally,\n   * and the method is marked internal to prevent it from being documented publicly.\n   * @internal\n   */\n  /* istanbul ignore next */\n  public override async getAriaLabelledby(): Promise<string | null> {\n    return await super.getAriaLabelledby();\n  }\n\n  /**\n   * Returns country field search result harnesses.\n   */\n  public override async getSearchResults(\n    filters?: SkyCountryFieldSearchResultHarnessFilters,\n  ): Promise<SkyCountryFieldSearchResultHarness[]> {\n    const overlay = await this.#getOverlay();\n\n    if (!overlay) {\n      throw new Error(\n        'Unable to retrieve search results. The country field is closed.',\n      );\n    }\n\n    const harnesses = await overlay.queryHarnesses(\n      SkyCountryFieldSearchResultHarness.with(filters || {}),\n    );\n\n    if (filters && harnesses.length === 0) {\n      // Stringify the regular expression so that it's readable in the console log.\n      if (filters.text instanceof RegExp) {\n        filters.text = filters.text.toString();\n      }\n\n      throw new Error(\n        `Could not find search results matching filter(s): ${JSON.stringify(\n          filters,\n        )}`,\n      );\n    }\n\n    return harnesses;\n  }\n\n  /**\n   * Returns the text content for each country field search result.\n   */\n  public override async getSearchResultsText(\n    filters?: SkyCountryFieldSearchResultHarnessFilters,\n  ): Promise<string[]> {\n    const harnesses = await this.getSearchResults(filters);\n\n    const text: string[] = [];\n    for (const harness of harnesses) {\n      text.push(await harness.getText());\n    }\n\n    return text;\n  }\n\n  /**\n   * Gets the value of the country field input.\n   */\n  public override async getValue(): Promise<string> {\n    return await super.getValue();\n  }\n\n  /**\n   * Gets the text displayed when no search results are found.\n   * For a country field, this is always the default text and the method\n   * is marked internal to prevent it from being documented publicly.\n   * @internal\n   */\n  /* istanbul ignore next */\n  public override async getNoResultsFoundText(): Promise<string | undefined> {\n    return await super.getNoResultsFoundText();\n  }\n\n  /**\n   * Whether the country field input is disabled.\n   */\n  public override async isDisabled(): Promise<boolean> {\n    return await super.isDisabled();\n  }\n\n  /**\n   * Whether the country field input is focused.\n   */\n  public override async isFocused(): Promise<boolean> {\n    return await super.isFocused();\n  }\n\n  /**\n   * Whether the country field is open.\n   */\n  public override async isOpen(): Promise<boolean> {\n    return await super.isOpen();\n  }\n\n  /**\n   * Selects a search result.\n   */\n  public override async selectSearchResult(\n    filters: SkyCountryFieldSearchResultHarnessFilters,\n  ): Promise<void> {\n    return await super.selectSearchResult(filters);\n  }\n\n  async #getOverlay(): Promise<SkyOverlayHarness | null> {\n    const overlayId = await (await this.#getInput()).getAriaControls();\n\n    return overlayId\n      ? await this.#documentRootLocator.locatorForOptional(\n          SkyOverlayHarness.with({ selector: `#${overlayId}` }),\n        )()\n      : null;\n  }\n}\n"]}

package/esm2022/testing/modules/country-field/country-field-search-result-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY291bnRyeS1maWVsZC1zZWFyY2gtcmVzdWx0LWhhcm5lc3MtZmlsdGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9sb29rdXAvdGVzdGluZy9zcmMvbW9kdWxlcy9jb3VudHJ5LWZpZWxkL2NvdW50cnktZmllbGQtc2VhcmNoLXJlc3VsdC1oYXJuZXNzLWZpbHRlcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQSBzZXQgb2YgY3JpdGVyaWEgdGhhdCBjYW4gYmUgdXNlZCB0byBmaWx0ZXIgYSBsaXN0IG9mIGBTa3lDb3VudHJ5RmllbGRTZWFyY2hSZXN1bHRIYXJuZXNzYCBpbnN0YW5jZXMuXG4gKiBAaW50ZXJuYWxcbiAqL1xuaW1wb3J0IHsgU2t5QXV0b2NvbXBsZXRlU2VhcmNoUmVzdWx0SGFybmVzc0ZpbHRlcnMgfSBmcm9tICcuLi9hdXRvY29tcGxldGUvYXV0b2NvbXBsZXRlLXNlYXJjaC1yZXN1bHQtaGFybmVzcy1maWx0ZXJzJztcblxuLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1pbnRlcmZhY2UsIEB0eXBlc2NyaXB0LWVzbGludC9uby1lbXB0eS1vYmplY3QtdHlwZVxuZXhwb3J0IGludGVyZmFjZSBTa3lDb3VudHJ5RmllbGRTZWFyY2hSZXN1bHRIYXJuZXNzRmlsdGVyc1xuICBleHRlbmRzIFNreUF1dG9jb21wbGV0ZVNlYXJjaFJlc3VsdEhhcm5lc3NGaWx0ZXJzIHt9XG4iXX0=

package/esm2022/testing/modules/country-field/country-field-search-result-harness.mjs

@@ -0,0 +1,27 @@
+import { HarnessPredicate } from '@angular/cdk/testing';
+import { SkyAutocompleteSearchResultHarness } from '../autocomplete/autocomplete-search-result-harness';
+/**
+ * Harness for interacting with an autocomplete search result in tests.
+ */
+export class SkyCountryFieldSearchResultHarness extends SkyAutocompleteSearchResultHarness {
+    /**
+     * Gets a `HarnessPredicate` that can be used to search for a
+     * `SkyCountryFieldSearchResultHarness` that meets certain criteria.
+     */
+    static with(filters) {
+        return new HarnessPredicate(SkyCountryFieldSearchResultHarness, filters).addOption('textContent', filters.text, async (harness, text) => {
+            const searchResultText = await harness.getText();
+            return await HarnessPredicate.stringMatches(searchResultText, text);
+        });
+    }
+    /**
+     * Returns the value of the search result's descriptor property.
+     * This is not needed by country field because it is always set to the country name,
+     * and the method is marked internal to prevent it from being documented publicly.
+     * @internal
+     */
+    async getDescriptorValue() {
+        return await super.getDescriptorValue();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/testing/modules/lookup/lookup-harness-filters.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9va3VwLWhhcm5lc3MtZmlsdGVycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tcG9uZW50cy9sb29rdXAvdGVzdGluZy9zcmMvbW9kdWxlcy9sb29rdXAvbG9va3VwLWhhcm5lc3MtZmlsdGVycy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2t5SGFybmVzc0ZpbHRlcnMgfSBmcm9tICdAc2t5dXgvY29yZS90ZXN0aW5nJztcblxuLyoqXG4gKiBBIHNldCBvZiBjcml0ZXJpYSB0aGF0IGNhbiBiZSB1c2VkIHRvIGZpbHRlciBhIGxpc3Qgb2YgYFNreUxvb2t1cEhhcm5lc3NgIGluc3RhbmNlcy5cbiAqIEBpbnRlcm5hbFxuICovXG4vLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LWludGVyZmFjZSwgQHR5cGVzY3JpcHQtZXNsaW50L25vLWVtcHR5LW9iamVjdC10eXBlXG5leHBvcnQgaW50ZXJmYWNlIFNreUxvb2t1cEhhcm5lc3NGaWx0ZXJzIGV4dGVuZHMgU2t5SGFybmVzc0ZpbHRlcnMge31cbiJdfQ==