/**
 * @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 { ComponentHarness, HarnessPredicate, } from '@angular/cdk/testing';
import { MatSelectHarness } from '@angular/material/select/testing';
import { coerceNumberProperty } from '@angular/cdk/coercion';
export class _MatPaginatorHarnessBase extends ComponentHarness {
    /** Goes to the next page in the paginator. */
    async goToNextPage() {
        return (await this._nextButton()).click();
    }
    /** Returns whether or not the next page button is disabled. */
    async isNextPageDisabled() {
        const disabledValue = await (await this._nextButton()).getAttribute('disabled');
        return disabledValue == 'true';
    }
    /* Returns whether or not the previous page button is disabled. */
    async isPreviousPageDisabled() {
        const disabledValue = await (await this._previousButton()).getAttribute('disabled');
        return disabledValue == 'true';
    }
    /** Goes to the previous page in the paginator. */
    async goToPreviousPage() {
        return (await this._previousButton()).click();
    }
    /** Goes to the first page in the paginator. */
    async goToFirstPage() {
        const button = await this._firstPageButton();
        // The first page button isn't enabled by default so we need to check for it.
        if (!button) {
            throw Error('Could not find first page button inside paginator. ' +
                'Make sure that `showFirstLastButtons` is enabled.');
        }
        return button.click();
    }
    /** Goes to the last page in the paginator. */
    async goToLastPage() {
        const button = await this._lastPageButton();
        // The last page button isn't enabled by default so we need to check for it.
        if (!button) {
            throw Error('Could not find last page button inside paginator. ' +
                'Make sure that `showFirstLastButtons` is enabled.');
        }
        return button.click();
    }
    /**
     * Sets the page size of the paginator.
     * @param size Page size that should be select.
     */
    async setPageSize(size) {
        const select = await this._select();
        // The select is only available if the `pageSizeOptions` are
        // set to an array with more than one item.
        if (!select) {
            throw Error('Cannot find page size selector in paginator. ' +
                'Make sure that the `pageSizeOptions` have been configured.');
        }
        return select.clickOptions({ text: `${size}` });
    }
    /** Gets the page size of the paginator. */
    async getPageSize() {
        const select = await this._select();
        const value = select ? select.getValueText() : (await this._pageSizeFallback()).text();
        return coerceNumberProperty(await value);
    }
    /** Gets the text of the range label of the paginator. */
    async getRangeLabel() {
        return (await this._rangeLabel()).text();
    }
}
/** Harness for interacting with an MDC-based mat-paginator in tests. */
export class MatPaginatorHarness extends _MatPaginatorHarnessBase {
    constructor() {
        super(...arguments);
        this._nextButton = this.locatorFor('.mat-mdc-paginator-navigation-next');
        this._previousButton = this.locatorFor('.mat-mdc-paginator-navigation-previous');
        this._firstPageButton = this.locatorForOptional('.mat-mdc-paginator-navigation-first');
        this._lastPageButton = this.locatorForOptional('.mat-mdc-paginator-navigation-last');
        this._select = this.locatorForOptional(MatSelectHarness.with({
            ancestor: '.mat-mdc-paginator-page-size',
        }));
        this._pageSizeFallback = this.locatorFor('.mat-mdc-paginator-page-size-value');
        this._rangeLabel = this.locatorFor('.mat-mdc-paginator-range-label');
    }
    /** Selector used to find paginator instances. */
    static { this.hostSelector = '.mat-mdc-paginator'; }
    /**
     * Gets a `HarnessPredicate` that can be used to search for a paginator with specific attributes.
     * @param options Options for filtering which paginator instances are considered a match.
     * @return a `HarnessPredicate` configured with the given options.
     */
    static with(options = {}) {
        return new HarnessPredicate(this, options);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"paginator-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/paginator/testing/paginator-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 {\n  AsyncFactoryFn,\n  ComponentHarness,\n  ComponentHarnessConstructor,\n  HarnessPredicate,\n  TestElement,\n} from '@angular/cdk/testing';\nimport {MatSelectHarness} from '@angular/material/select/testing';\nimport {coerceNumberProperty} from '@angular/cdk/coercion';\nimport {PaginatorHarnessFilters} from './paginator-harness-filters';\n\nexport abstract class _MatPaginatorHarnessBase extends ComponentHarness {\n  protected abstract _nextButton: AsyncFactoryFn<TestElement>;\n  protected abstract _previousButton: AsyncFactoryFn<TestElement>;\n  protected abstract _firstPageButton: AsyncFactoryFn<TestElement | null>;\n  protected abstract _lastPageButton: AsyncFactoryFn<TestElement | null>;\n  protected abstract _select: AsyncFactoryFn<\n    | (ComponentHarness & {\n        getValueText(): Promise<string>;\n        clickOptions(...filters: unknown[]): Promise<void>;\n      })\n    | null\n  >;\n  protected abstract _pageSizeFallback: AsyncFactoryFn<TestElement>;\n  protected abstract _rangeLabel: AsyncFactoryFn<TestElement>;\n\n  /** Goes to the next page in the paginator. */\n  async goToNextPage(): Promise<void> {\n    return (await this._nextButton()).click();\n  }\n\n  /** Returns whether or not the next page button is disabled. */\n  async isNextPageDisabled(): Promise<boolean> {\n    const disabledValue = await (await this._nextButton()).getAttribute('disabled');\n    return disabledValue == 'true';\n  }\n\n  /* Returns whether or not the previous page button is disabled. */\n  async isPreviousPageDisabled(): Promise<boolean> {\n    const disabledValue = await (await this._previousButton()).getAttribute('disabled');\n    return disabledValue == 'true';\n  }\n\n  /** Goes to the previous page in the paginator. */\n  async goToPreviousPage(): Promise<void> {\n    return (await this._previousButton()).click();\n  }\n\n  /** Goes to the first page in the paginator. */\n  async goToFirstPage(): Promise<void> {\n    const button = await this._firstPageButton();\n\n    // The first page button isn't enabled by default so we need to check for it.\n    if (!button) {\n      throw Error(\n        'Could not find first page button inside paginator. ' +\n          'Make sure that `showFirstLastButtons` is enabled.',\n      );\n    }\n\n    return button.click();\n  }\n\n  /** Goes to the last page in the paginator. */\n  async goToLastPage(): Promise<void> {\n    const button = await this._lastPageButton();\n\n    // The last page button isn't enabled by default so we need to check for it.\n    if (!button) {\n      throw Error(\n        'Could not find last page button inside paginator. ' +\n          'Make sure that `showFirstLastButtons` is enabled.',\n      );\n    }\n\n    return button.click();\n  }\n\n  /**\n   * Sets the page size of the paginator.\n   * @param size Page size that should be select.\n   */\n  async setPageSize(size: number): Promise<void> {\n    const select = await this._select();\n\n    // The select is only available if the `pageSizeOptions` are\n    // set to an array with more than one item.\n    if (!select) {\n      throw Error(\n        'Cannot find page size selector in paginator. ' +\n          'Make sure that the `pageSizeOptions` have been configured.',\n      );\n    }\n\n    return select.clickOptions({text: `${size}`});\n  }\n\n  /** Gets the page size of the paginator. */\n  async getPageSize(): Promise<number> {\n    const select = await this._select();\n    const value = select ? select.getValueText() : (await this._pageSizeFallback()).text();\n    return coerceNumberProperty(await value);\n  }\n\n  /** Gets the text of the range label of the paginator. */\n  async getRangeLabel(): Promise<string> {\n    return (await this._rangeLabel()).text();\n  }\n}\n\n/** Harness for interacting with an MDC-based mat-paginator in tests. */\nexport class MatPaginatorHarness extends _MatPaginatorHarnessBase {\n  /** Selector used to find paginator instances. */\n  static hostSelector = '.mat-mdc-paginator';\n  protected _nextButton = this.locatorFor('.mat-mdc-paginator-navigation-next');\n  protected _previousButton = this.locatorFor('.mat-mdc-paginator-navigation-previous');\n  protected _firstPageButton = this.locatorForOptional('.mat-mdc-paginator-navigation-first');\n  protected _lastPageButton = this.locatorForOptional('.mat-mdc-paginator-navigation-last');\n  protected _select = this.locatorForOptional(\n    MatSelectHarness.with({\n      ancestor: '.mat-mdc-paginator-page-size',\n    }),\n  );\n  protected _pageSizeFallback = this.locatorFor('.mat-mdc-paginator-page-size-value');\n  protected _rangeLabel = this.locatorFor('.mat-mdc-paginator-range-label');\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a paginator with specific attributes.\n   * @param options Options for filtering which paginator instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with<T extends MatPaginatorHarness>(\n    this: ComponentHarnessConstructor<T>,\n    options: PaginatorHarnessFilters = {},\n  ): HarnessPredicate<T> {\n    return new HarnessPredicate(this, options);\n  }\n}\n"]}