/**
 * @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, parallel } from '@angular/cdk/testing';
import { ɵTileCoordinator as TileCoordinator } from '@angular/material/grid-list';
import { MatGridTileHarness } from './grid-tile-harness';
/** Harness for interacting with a standard `MatGridList` in tests. */
export class MatGridListHarness extends ComponentHarness {
    constructor() {
        super(...arguments);
        /**
         * Tile coordinator that is used by the "MatGridList" for computing
         * positions of tiles. We leverage the coordinator to provide an API
         * for retrieving tiles based on visual tile positions.
         */
        this._tileCoordinator = new TileCoordinator();
    }
    /** The selector for the host element of a `MatGridList` instance. */
    static { this.hostSelector = '.mat-grid-list'; }
    /**
     * Gets a `HarnessPredicate` that can be used to search for a `MatGridListHarness`
     * that meets certain criteria.
     * @param options Options for filtering which dialog instances are considered a match.
     * @return a `HarnessPredicate` configured with the given options.
     */
    static with(options = {}) {
        return new HarnessPredicate(MatGridListHarness, options);
    }
    /** Gets all tiles of the grid-list. */
    async getTiles(filters = {}) {
        return await this.locatorForAll(MatGridTileHarness.with(filters))();
    }
    /** Gets the amount of columns of the grid-list. */
    async getColumns() {
        return Number(await (await this.host()).getAttribute('cols'));
    }
    /**
     * Gets a tile of the grid-list that is located at the given location.
     * @param row Zero-based row index.
     * @param column Zero-based column index.
     */
    async getTileAtPosition({ row, column, }) {
        const [tileHarnesses, columns] = await parallel(() => [this.getTiles(), this.getColumns()]);
        const tileSpans = tileHarnesses.map(t => parallel(() => [t.getColspan(), t.getRowspan()]));
        const tiles = (await parallel(() => tileSpans)).map(([colspan, rowspan]) => ({
            colspan,
            rowspan,
        }));
        // Update the tile coordinator to reflect the current column amount and
        // rendered tiles. We update upon every call of this method since we do not
        // know if tiles have been added, removed or updated (in terms of rowspan/colspan).
        this._tileCoordinator.update(columns, tiles);
        // The tile coordinator respects the colspan and rowspan for calculating the positions
        // of tiles, but it does not create multiple position entries if a tile spans over multiple
        // columns or rows. We want to provide an API where developers can retrieve a tile based on
        // any position that lies within the visual tile boundaries. For example: If a tile spans
        // over two columns, then the same tile should be returned for either column indices.
        for (let i = 0; i < this._tileCoordinator.positions.length; i++) {
            const position = this._tileCoordinator.positions[i];
            const { rowspan, colspan } = tiles[i];
            // Return the tile harness if the given position visually resolves to the tile.
            if (column >= position.col &&
                column <= position.col + colspan - 1 &&
                row >= position.row &&
                row <= position.row + rowspan - 1) {
                return tileHarnesses[i];
            }
        }
        throw Error('Could not find tile at given position.');
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"grid-list-harness.js","sourceRoot":"","sources":["../../../../../../../src/material/grid-list/testing/grid-list-harness.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAC,gBAAgB,EAAE,gBAAgB,EAAE,QAAQ,EAAC,MAAM,sBAAsB,CAAC;AAClF,OAAO,EAAC,gBAAgB,IAAI,eAAe,EAAC,MAAM,6BAA6B,CAAC;AAEhF,OAAO,EAAC,kBAAkB,EAAC,MAAM,qBAAqB,CAAC;AAEvD,sEAAsE;AACtE,MAAM,OAAO,kBAAmB,SAAQ,gBAAgB;IAAxD;;QAcE;;;;WAIG;QACK,qBAAgB,GAAG,IAAI,eAAe,EAAE,CAAC;IAsDnD,CAAC;IAxEC,qEAAqE;aAC9D,iBAAY,GAAG,gBAAgB,AAAnB,CAAoB;IAEvC;;;;;OAKG;IACH,MAAM,CAAC,IAAI,CAAC,UAAkC,EAAE;QAC9C,OAAO,IAAI,gBAAgB,CAAC,kBAAkB,EAAE,OAAO,CAAC,CAAC;IAC3D,CAAC;IASD,uCAAuC;IACvC,KAAK,CAAC,QAAQ,CAAC,UAAkC,EAAE;QACjD,OAAO,MAAM,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC;IACtE,CAAC;IAED,mDAAmD;IACnD,KAAK,CAAC,UAAU;QACd,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACH,KAAK,CAAC,iBAAiB,CAAC,EACtB,GAAG,EACH,MAAM,GAIP;QACC,MAAM,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,MAAM,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC;QAC5F,MAAM,SAAS,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,CAAC;QAC3F,MAAM,KAAK,GAAG,CAAC,MAAM,QAAQ,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC;YAC3E,OAAO;YACP,OAAO;SACR,CAAC,CAAC,CAAC;QACJ,uEAAuE;QACvE,2EAA2E;QAC3E,mFAAmF;QACnF,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QAC7C,sFAAsF;QACtF,2FAA2F;QAC3F,2FAA2F;QAC3F,yFAAyF;QACzF,qFAAqF;QACrF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC/D,MAAM,QAAQ,GAAG,IAAI,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;YACpD,MAAM,EAAC,OAAO,EAAE,OAAO,EAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;YACpC,+EAA+E;YAC/E,IACE,MAAM,IAAI,QAAQ,CAAC,GAAG;gBACtB,MAAM,IAAI,QAAQ,CAAC,GAAG,GAAG,OAAO,GAAG,CAAC;gBACpC,GAAG,IAAI,QAAQ,CAAC,GAAG;gBACnB,GAAG,IAAI,QAAQ,CAAC,GAAG,GAAG,OAAO,GAAG,CAAC,EACjC;gBACA,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC;aACzB;SACF;QACD,MAAM,KAAK,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC","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 {ComponentHarness, HarnessPredicate, parallel} from '@angular/cdk/testing';\nimport {ɵTileCoordinator as TileCoordinator} from '@angular/material/grid-list';\nimport {GridListHarnessFilters, GridTileHarnessFilters} from './grid-list-harness-filters';\nimport {MatGridTileHarness} from './grid-tile-harness';\n\n/** Harness for interacting with a standard `MatGridList` in tests. */\nexport class MatGridListHarness extends ComponentHarness {\n  /** The selector for the host element of a `MatGridList` instance. */\n  static hostSelector = '.mat-grid-list';\n\n  /**\n   * Gets a `HarnessPredicate` that can be used to search for a `MatGridListHarness`\n   * that meets certain criteria.\n   * @param options Options for filtering which dialog instances are considered a match.\n   * @return a `HarnessPredicate` configured with the given options.\n   */\n  static with(options: GridListHarnessFilters = {}): HarnessPredicate<MatGridListHarness> {\n    return new HarnessPredicate(MatGridListHarness, options);\n  }\n\n  /**\n   * Tile coordinator that is used by the \"MatGridList\" for computing\n   * positions of tiles. We leverage the coordinator to provide an API\n   * for retrieving tiles based on visual tile positions.\n   */\n  private _tileCoordinator = new TileCoordinator();\n\n  /** Gets all tiles of the grid-list. */\n  async getTiles(filters: GridTileHarnessFilters = {}): Promise<MatGridTileHarness[]> {\n    return await this.locatorForAll(MatGridTileHarness.with(filters))();\n  }\n\n  /** Gets the amount of columns of the grid-list. */\n  async getColumns(): Promise<number> {\n    return Number(await (await this.host()).getAttribute('cols'));\n  }\n\n  /**\n   * Gets a tile of the grid-list that is located at the given location.\n   * @param row Zero-based row index.\n   * @param column Zero-based column index.\n   */\n  async getTileAtPosition({\n    row,\n    column,\n  }: {\n    row: number;\n    column: number;\n  }): Promise<MatGridTileHarness> {\n    const [tileHarnesses, columns] = await parallel(() => [this.getTiles(), this.getColumns()]);\n    const tileSpans = tileHarnesses.map(t => parallel(() => [t.getColspan(), t.getRowspan()]));\n    const tiles = (await parallel(() => tileSpans)).map(([colspan, rowspan]) => ({\n      colspan,\n      rowspan,\n    }));\n    // Update the tile coordinator to reflect the current column amount and\n    // rendered tiles. We update upon every call of this method since we do not\n    // know if tiles have been added, removed or updated (in terms of rowspan/colspan).\n    this._tileCoordinator.update(columns, tiles);\n    // The tile coordinator respects the colspan and rowspan for calculating the positions\n    // of tiles, but it does not create multiple position entries if a tile spans over multiple\n    // columns or rows. We want to provide an API where developers can retrieve a tile based on\n    // any position that lies within the visual tile boundaries. For example: If a tile spans\n    // over two columns, then the same tile should be returned for either column indices.\n    for (let i = 0; i < this._tileCoordinator.positions.length; i++) {\n      const position = this._tileCoordinator.positions[i];\n      const {rowspan, colspan} = tiles[i];\n      // Return the tile harness if the given position visually resolves to the tile.\n      if (\n        column >= position.col &&\n        column <= position.col + colspan - 1 &&\n        row >= position.row &&\n        row <= position.row + rowspan - 1\n      ) {\n        return tileHarnesses[i];\n      }\n    }\n    throw Error('Could not find tile at given position.');\n  }\n}\n"]}