@internetarchive/collection-browser 1.14.17 → 2.0.0

package/dist/src/data-source/collection-browser-data-source.js

@@ -0,0 +1,912 @@
+import { FilterConstraint, FilterMapBuilder, SearchType, } from '@internetarchive/search-service';
+import { prefixFilterAggregationKeys, TileModel, SortField, SORT_OPTIONS, } from '../models';
+import { FACETLESS_PAGE_ELEMENTS } from './models';
+import { sha1 } from '../utils/sha1';
+import { log } from '../utils/log';
+export class CollectionBrowserDataSource {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(
+    /** The host element to which this controller should attach listeners */
+    host, 
+    /** Default size of result pages */
+    pageSize = 50) {
+        this.host = host;
+        this.pageSize = pageSize;
+        /**
+         * All pages of tile models that have been fetched so far, indexed by their page
+         * number (with the first being page 1).
+         */
+        this.pages = {};
+        /**
+         * Tile offset to apply when looking up tiles in the pages, in order to maintain
+         * page alignment after tiles are removed.
+         */
+        this.offset = 0;
+        /**
+         * Total number of tile models stored in this data source's pages
+         */
+        this.numTileModels = 0;
+        /**
+         * A set of fetch IDs that are valid for the current query state
+         */
+        this.fetchesInProgress = new Set();
+        /**
+         * A record of the query key used for the last search.
+         * If this changes, we need to load new results.
+         */
+        this.previousQueryKey = '';
+        /**
+         * Whether the initial page of search results for the current query state
+         * is presently being fetched.
+         */
+        this.searchResultsLoading = false;
+        /**
+         * Whether the facets (aggregations) for the current query state are
+         * presently being fetched.
+         */
+        this.facetsLoading = false;
+        /**
+         * Whether further query changes should be ignored and not trigger fetches
+         */
+        this.suppressFetches = false;
+        /**
+         * @inheritdoc
+         */
+        this.totalResults = 0;
+        /**
+         * @inheritdoc
+         */
+        this.endOfDataReached = false;
+        /**
+         * @inheritdoc
+         */
+        this.queryInitialized = false;
+        /**
+         * @inheritdoc
+         */
+        this.collectionTitles = new Map();
+        /**
+         * @inheritdoc
+         */
+        this.parentCollections = [];
+        /**
+         * @inheritdoc
+         */
+        this.prefixFilterCountMap = {};
+        /**
+         * Internal property to store the private value backing the `initialSearchComplete` getter.
+         */
+        this._initialSearchCompletePromise = new Promise(res => {
+            this._initialSearchCompleteResolver = res;
+        });
+        /**
+         * @inheritdoc
+         */
+        this.checkAllTiles = () => {
+            this.map(model => {
+                const cloned = model.clone();
+                cloned.checked = true;
+                return cloned;
+            });
+        };
+        /**
+         * @inheritdoc
+         */
+        this.uncheckAllTiles = () => {
+            this.map(model => {
+                const cloned = model.clone();
+                cloned.checked = false;
+                return cloned;
+            });
+        };
+        /**
+         * @inheritdoc
+         */
+        this.removeCheckedTiles = () => {
+            // To make sure our data source remains page-aligned, we will offset our data source by
+            // the number of removed tiles, so that we can just add the offset when the infinite
+            // scroller queries for cell contents.
+            // This only matters while we're still viewing the same set of results. If the user changes
+            // their query/filters/sort, then the data source is overwritten and the offset cleared.
+            const { checkedTileModels, uncheckedTileModels } = this;
+            const numChecked = checkedTileModels.length;
+            if (numChecked === 0)
+                return;
+            this.offset += numChecked;
+            const newPages = {};
+            // Which page the remaining tile models start on, post-offset
+            let offsetPageNumber = Math.floor(this.offset / this.pageSize) + 1;
+            let indexOnPage = this.offset % this.pageSize;
+            // Fill the pages up to that point with empty models
+            for (let page = 1; page <= offsetPageNumber; page += 1) {
+                const remainingHidden = this.offset - this.pageSize * (page - 1);
+                const offsetCellsOnPage = Math.min(this.pageSize, remainingHidden);
+                newPages[page] = Array(offsetCellsOnPage).fill(undefined);
+            }
+            // Shift all the remaining tiles into their new positions in the data source
+            for (const model of uncheckedTileModels) {
+                if (!newPages[offsetPageNumber])
+                    newPages[offsetPageNumber] = [];
+                newPages[offsetPageNumber].push(model);
+                indexOnPage += 1;
+                if (indexOnPage >= this.pageSize) {
+                    offsetPageNumber += 1;
+                    indexOnPage = 0;
+                }
+            }
+            // Swap in the new pages
+            this.pages = newPages;
+            this.numTileModels -= numChecked;
+            this.requestHostUpdate();
+            this.refreshVisibleResults();
+        };
+        // Just setting some property values
+    }
+    /**
+     * @inheritdoc
+     */
+    get initialSearchComplete() {
+        return this._initialSearchCompletePromise;
+    }
+    hostConnected() {
+        this.setSearchResultsLoading(this.searchResultsLoading);
+        this.setFacetsLoading(this.facetsLoading);
+    }
+    hostUpdate() {
+        // This reactive controller hook is run whenever the host component (collection-browser) performs an update.
+        // We check whether the host's state has changed in a way which should trigger a reset & new results fetch.
+        // Only the currently-installed data source should react to the update
+        if (!this.activeOnHost)
+            return;
+        // Copy loading states onto the host
+        this.setSearchResultsLoading(this.searchResultsLoading);
+        this.setFacetsLoading(this.facetsLoading);
+        // Can't perform searches without a search service
+        if (!this.host.searchService)
+            return;
+        // We should only reset if part of the full query state has changed
+        const queryKeyChanged = this.pageFetchQueryKey !== this.previousQueryKey;
+        if (!queryKeyChanged)
+            return;
+        // We should only reset if either:
+        //  (a) our state permits a valid search, or
+        //  (b) we have a blank query that we want to show empty results for
+        const shouldShowEmptyQueryResults = this.host.clearResultsOnEmptyQuery && this.host.baseQuery === '';
+        if (!(this.canPerformSearch || shouldShowEmptyQueryResults))
+            return;
+        if (this.activeOnHost)
+            this.host.emitQueryStateChanged();
+        this.handleQueryChange();
+    }
+    /**
+     * Returns whether this data source is the one currently installed on the host component.
+     */
+    get activeOnHost() {
+        return this.host.dataSource === this;
+    }
+    /**
+     * @inheritdoc
+     */
+    get size() {
+        return this.numTileModels;
+    }
+    /**
+     * @inheritdoc
+     */
+    reset() {
+        log('Resetting CB data source');
+        this.pages = {};
+        this.aggregations = {};
+        this.yearHistogramAggregation = undefined;
+        this.pageElements = undefined;
+        this.parentCollections = [];
+        this.queryErrorMessage = undefined;
+        this.offset = 0;
+        this.numTileModels = 0;
+        this.totalResults = 0;
+        this.endOfDataReached = false;
+        this.queryInitialized = false;
+        // Invalidate any fetches in progress
+        this.fetchesInProgress.clear();
+        if (this.activeOnHost)
+            this.host.setTotalResultCount(0);
+        this.requestHostUpdate();
+    }
+    /**
+     * @inheritdoc
+     */
+    addPage(pageNum, pageTiles) {
+        this.pages[pageNum] = pageTiles;
+        this.numTileModels += pageTiles.length;
+        this.requestHostUpdate();
+    }
+    /**
+     * @inheritdoc
+     */
+    getPage(pageNum) {
+        return this.pages[pageNum];
+    }
+    /**
+     * @inheritdoc
+     */
+    getAllPages() {
+        return this.pages;
+    }
+    /**
+     * @inheritdoc
+     */
+    hasPage(pageNum) {
+        return !!this.pages[pageNum];
+    }
+    /**
+     * @inheritdoc
+     */
+    getTileModelAt(index) {
+        var _a;
+        const pageNum = Math.floor(index / this.pageSize) + 1;
+        const indexOnPage = index % this.pageSize;
+        return (_a = this.pages[pageNum]) === null || _a === void 0 ? void 0 : _a[indexOnPage];
+    }
+    /**
+     * @inheritdoc
+     */
+    indexOf(tile) {
+        return Object.values(this.pages).flat().indexOf(tile);
+    }
+    /**
+     * @inheritdoc
+     */
+    getPageSize() {
+        return this.pageSize;
+    }
+    /**
+     * @inheritdoc
+     */
+    setPageSize(pageSize) {
+        this.reset();
+        this.pageSize = pageSize;
+    }
+    /**
+     * @inheritdoc
+     */
+    setFetchesSuppressed(suppressed) {
+        this.suppressFetches = suppressed;
+    }
+    /**
+     * @inheritdoc
+     */
+    async handleQueryChange() {
+        // Don't react to the change if fetches are suppressed for this data source
+        if (this.suppressFetches)
+            return;
+        this.reset();
+        // Reset the `initialSearchComplete` promise with a new value for the imminent search
+        this._initialSearchCompletePromise = new Promise(res => {
+            this._initialSearchCompleteResolver = res;
+        });
+        const shouldFetchFacets = !this.host.suppressFacets &&
+            !FACETLESS_PAGE_ELEMENTS.includes(this.host.profileElement);
+        // Fire the initial page & facet requests
+        this.queryInitialized = true;
+        await Promise.all([
+            this.doInitialPageFetch(),
+            shouldFetchFacets ? this.fetchFacets() : null,
+        ]);
+        // Resolve the `initialSearchComplete` promise for this search
+        this._initialSearchCompleteResolver(true);
+    }
+    /**
+     * @inheritdoc
+     */
+    map(callback) {
+        this.pages = Object.fromEntries(Object.entries(this.pages).map(([page, tileModels]) => [
+            page,
+            tileModels.map((model, index, array) => model ? callback(model, index, array) : model),
+        ]));
+        this.requestHostUpdate();
+        this.refreshVisibleResults();
+    }
+    /**
+     * @inheritdoc
+     */
+    get checkedTileModels() {
+        return this.getFilteredTileModels(model => model.checked);
+    }
+    /**
+     * @inheritdoc
+     */
+    get uncheckedTileModels() {
+        return this.getFilteredTileModels(model => !model.checked);
+    }
+    /**
+     * Returns a flattened, filtered array of all the tile models in the data source
+     * for which the given predicate returns a truthy value.
+     *
+     * @param predicate A callback function to apply on each tile model, as with Array.filter
+     * @returns A filtered array of tile models satisfying the predicate
+     */
+    getFilteredTileModels(predicate) {
+        return Object.values(this.pages)
+            .flat()
+            .filter((model, index, array) => model ? predicate(model, index, array) : false);
+    }
+    /**
+     * @inheritdoc
+     */
+    get canPerformSearch() {
+        var _a;
+        if (!this.host.searchService)
+            return false;
+        const trimmedQuery = (_a = this.host.baseQuery) === null || _a === void 0 ? void 0 : _a.trim();
+        const hasNonEmptyQuery = !!trimmedQuery;
+        const isCollectionSearch = !!this.host.withinCollection;
+        const isProfileSearch = !!this.host.withinProfile;
+        const hasProfileElement = !!this.host.profileElement;
+        const isMetadataSearch = this.host.searchType === SearchType.METADATA;
+        // Metadata searches within a collection/profile are allowed to have no query.
+        // Otherwise, a non-empty query must be set.
+        return (hasNonEmptyQuery ||
+            (isCollectionSearch && isMetadataSearch) ||
+            (isProfileSearch && hasProfileElement && isMetadataSearch));
+    }
+    /**
+     * Sets the state for whether the initial set of search results for the
+     * current query is loading
+     */
+    setSearchResultsLoading(loading) {
+        this.searchResultsLoading = loading;
+        if (this.activeOnHost) {
+            this.host.setSearchResultsLoading(loading);
+        }
+    }
+    /**
+     * Sets the state for whether the facets for a query is loading
+     */
+    setFacetsLoading(loading) {
+        this.facetsLoading = loading;
+        if (this.activeOnHost) {
+            this.host.setFacetsLoading(loading);
+        }
+    }
+    /**
+     * Requests that the host perform an update, provided this data
+     * source is actively installed on it.
+     */
+    requestHostUpdate() {
+        if (this.activeOnHost) {
+            this.host.requestUpdate();
+        }
+    }
+    /**
+     * Requests that the host refresh its visible tiles, provided this
+     * data source is actively installed on it.
+     */
+    refreshVisibleResults() {
+        if (this.activeOnHost) {
+            this.host.refreshVisibleResults();
+        }
+    }
+    /**
+     * The query key is a string that uniquely identifies the current search.
+     * It consists of:
+     *  - The current base query
+     *  - The current collection/profile target & page element
+     *  - The current search type
+     *  - Any currently-applied facets
+     *  - Any currently-applied date range
+     *  - Any currently-applied prefix filters
+     *  - The current sort options
+     *
+     * This lets us internally keep track of queries so we don't persist data that's
+     * no longer relevant. Not meant to be human-readable.
+     */
+    get pageFetchQueryKey() {
+        var _a, _b, _c;
+        const profileKey = `pf;${this.host.withinProfile}--pe;${this.host.profileElement}`;
+        const pageTarget = (_a = this.host.withinCollection) !== null && _a !== void 0 ? _a : profileKey;
+        const sortField = (_b = this.host.selectedSort) !== null && _b !== void 0 ? _b : 'none';
+        const sortDirection = (_c = this.host.sortDirection) !== null && _c !== void 0 ? _c : 'none';
+        return `fq:${this.fullQuery}-pt:${pageTarget}-st:${this.host.searchType}-sf:${sortField}-sd:${sortDirection}`;
+    }
+    /**
+     * Similar to `pageFetchQueryKey` above, but excludes sort fields since they
+     * are not relevant in determining aggregation queries.
+     */
+    get facetFetchQueryKey() {
+        var _a;
+        const profileKey = `pf;${this.host.withinProfile}--pe;${this.host.profileElement}`;
+        const pageTarget = (_a = this.host.withinCollection) !== null && _a !== void 0 ? _a : profileKey;
+        return `fq:${this.fullQuery}-pt:${pageTarget}-st:${this.host.searchType}`;
+    }
+    /**
+     * Constructs a search service FilterMap object from the combination of
+     * all the currently-applied filters. This includes any facets, letter
+     * filters, and date range.
+     */
+    get filterMap() {
+        const builder = new FilterMapBuilder();
+        // Add the date range, if applicable
+        if (this.host.minSelectedDate) {
+            builder.addFilter('year', this.host.minSelectedDate, FilterConstraint.GREATER_OR_EQUAL);
+        }
+        if (this.host.maxSelectedDate) {
+            builder.addFilter('year', this.host.maxSelectedDate, FilterConstraint.LESS_OR_EQUAL);
+        }
+        // Add any selected facets
+        if (this.host.selectedFacets) {
+            for (const [facetName, facetValues] of Object.entries(this.host.selectedFacets)) {
+                const { name, values } = this.prepareFacetForFetch(facetName, facetValues);
+                for (const [value, bucket] of Object.entries(values)) {
+                    let constraint;
+                    if (bucket.state === 'selected') {
+                        constraint = FilterConstraint.INCLUDE;
+                    }
+                    else if (bucket.state === 'hidden') {
+                        constraint = FilterConstraint.EXCLUDE;
+                    }
+                    if (constraint) {
+                        builder.addFilter(name, value, constraint);
+                    }
+                }
+            }
+        }
+        // Add any letter filters
+        if (this.host.selectedTitleFilter) {
+            builder.addFilter('firstTitle', this.host.selectedTitleFilter, FilterConstraint.INCLUDE);
+        }
+        if (this.host.selectedCreatorFilter) {
+            builder.addFilter('firstCreator', this.host.selectedCreatorFilter, FilterConstraint.INCLUDE);
+        }
+        const filterMap = builder.build();
+        return filterMap;
+    }
+    /**
+     * Produces a compact unique ID for a search request that can help with debugging
+     * on the backend by making related requests easier to trace through different services.
+     * (e.g., tying the hits/aggregations requests for the same page back to a single hash).
+     *
+     * @param params The search service parameters for the request
+     * @param kind The kind of request (hits-only, aggregations-only, or both)
+     * @returns A Promise resolving to the uid to apply to the request
+     */
+    async requestUID(params, kind) {
+        var _a;
+        const paramsToHash = JSON.stringify({
+            pageType: params.pageType,
+            pageTarget: params.pageTarget,
+            query: params.query,
+            fields: params.fields,
+            filters: params.filters,
+            sort: params.sort,
+            searchType: this.host.searchType,
+        });
+        const fullQueryHash = (await sha1(paramsToHash)).slice(0, 20); // First 80 bits of SHA-1 are plenty for this
+        const sessionId = (await this.host.getSessionId()).slice(0, 20); // Likewise
+        const page = (_a = params.page) !== null && _a !== void 0 ? _a : 0;
+        const kindPrefix = kind.charAt(0); // f = full, h = hits, a = aggregations
+        const currentTime = Date.now();
+        return `R:${fullQueryHash}-S:${sessionId}-P:${page}-K:${kindPrefix}-T:${currentTime}`;
+    }
+    /**
+     * @inheritdoc
+     */
+    get pageSpecifierParams() {
+        if (this.host.withinCollection) {
+            return {
+                pageType: 'collection_details',
+                pageTarget: this.host.withinCollection,
+            };
+        }
+        if (this.host.withinProfile) {
+            return {
+                pageType: 'account_details',
+                pageTarget: this.host.withinProfile,
+                pageElements: this.host.profileElement
+                    ? [this.host.profileElement]
+                    : [],
+            };
+        }
+        return null;
+    }
+    /**
+     * The full query, including year facets and date range clauses
+     */
+    get fullQuery() {
+        var _a, _b;
+        let fullQuery = (_b = (_a = this.host.baseQuery) === null || _a === void 0 ? void 0 : _a.trim()) !== null && _b !== void 0 ? _b : '';
+        const { facetQuery, dateRangeQueryClause, sortFilterQueries } = this;
+        if (facetQuery) {
+            fullQuery += ` AND ${facetQuery}`;
+        }
+        if (dateRangeQueryClause) {
+            fullQuery += ` AND ${dateRangeQueryClause}`;
+        }
+        if (sortFilterQueries) {
+            fullQuery += ` AND ${sortFilterQueries}`;
+        }
+        return fullQuery.trim();
+    }
+    /**
+     * Generates a query string representing the current set of applied facets
+     *
+     * Example: `mediatype:("collection" OR "audio" OR -"etree") AND year:("2000" OR "2001")`
+     */
+    get facetQuery() {
+        var _a;
+        if (!this.host.selectedFacets)
+            return undefined;
+        const facetClauses = [];
+        for (const [facetName, facetValues] of Object.entries(this.host.selectedFacets)) {
+            facetClauses.push(this.buildFacetClause(facetName, facetValues));
+        }
+        return (_a = this.joinFacetClauses(facetClauses)) === null || _a === void 0 ? void 0 : _a.trim();
+    }
+    get dateRangeQueryClause() {
+        if (!this.host.minSelectedDate || !this.host.maxSelectedDate) {
+            return undefined;
+        }
+        return `year:[${this.host.minSelectedDate} TO ${this.host.maxSelectedDate}]`;
+    }
+    get sortFilterQueries() {
+        const queries = [this.titleQuery, this.creatorQuery];
+        return queries.filter(q => q).join(' AND ');
+    }
+    /**
+     * Returns a query clause identifying the currently selected title filter,
+     * e.g., `firstTitle:X`.
+     */
+    get titleQuery() {
+        return this.host.selectedTitleFilter
+            ? `firstTitle:${this.host.selectedTitleFilter}`
+            : undefined;
+    }
+    /**
+     * Returns a query clause identifying the currently selected creator filter,
+     * e.g., `firstCreator:X`.
+     */
+    get creatorQuery() {
+        return this.host.selectedCreatorFilter
+            ? `firstCreator:${this.host.selectedCreatorFilter}`
+            : undefined;
+    }
+    /**
+     * Builds an OR-joined facet clause for the given facet name and values.
+     *
+     * E.g., for name `subject` and values
+     * `{ foo: { state: 'selected' }, bar: { state: 'hidden' } }`
+     * this will produce the clause
+     * `subject:("foo" OR -"bar")`.
+     *
+     * @param facetName The facet type (e.g., 'collection')
+     * @param facetValues The facet buckets, mapped by their keys
+     */
+    buildFacetClause(facetName, facetValues) {
+        const { name: facetQueryName, values } = this.prepareFacetForFetch(facetName, facetValues);
+        const facetEntries = Object.entries(values);
+        if (facetEntries.length === 0)
+            return '';
+        const facetValuesArray = [];
+        for (const [key, facetData] of facetEntries) {
+            const plusMinusPrefix = facetData.state === 'hidden' ? '-' : '';
+            facetValuesArray.push(`${plusMinusPrefix}"${key}"`);
+        }
+        const valueQuery = facetValuesArray.join(` OR `);
+        return `${facetQueryName}:(${valueQuery})`;
+    }
+    /**
+     * Handles some special pre-request normalization steps for certain facet types
+     * that require them.
+     *
+     * @param facetName The name of the facet type (e.g., 'language')
+     * @param facetValues An array of values for that facet type
+     */
+    prepareFacetForFetch(facetName, facetValues) {
+        // eslint-disable-next-line prefer-const
+        let [normalizedName, normalizedValues] = [facetName, facetValues];
+        // The full "search engine" name of the lending field is "lending___status"
+        if (facetName === 'lending') {
+            normalizedName = 'lending___status';
+        }
+        return {
+            name: normalizedName,
+            values: normalizedValues,
+        };
+    }
+    /**
+     * Takes an array of facet clauses, and combines them into a
+     * full AND-joined facet query string. Empty clauses are ignored.
+     */
+    joinFacetClauses(facetClauses) {
+        const nonEmptyFacetClauses = facetClauses.filter(clause => clause.length > 0);
+        return nonEmptyFacetClauses.length > 0
+            ? `(${nonEmptyFacetClauses.join(' AND ')})`
+            : undefined;
+    }
+    /**
+     * Fires a backend request to fetch a set of aggregations (representing UI facets) for
+     * the current search state.
+     */
+    async fetchFacets() {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const trimmedQuery = (_a = this.host.baseQuery) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!this.canPerformSearch)
+            return;
+        const { facetFetchQueryKey } = this;
+        if (this.fetchesInProgress.has(facetFetchQueryKey))
+            return;
+        this.fetchesInProgress.add(facetFetchQueryKey);
+        const sortParams = this.host.sortParam ? [this.host.sortParam] : [];
+        const params = {
+            ...this.pageSpecifierParams,
+            query: trimmedQuery || '',
+            rows: 0,
+            filters: this.filterMap,
+            // Fetch a few extra buckets beyond the 6 we show, in case some get suppressed
+            aggregationsSize: 10,
+            // Note: we don't need an aggregations param to fetch the default aggregations from the PPS.
+            // The default aggregations for the search_results page type should be what we need here.
+        };
+        params.uid = await this.requestUID({ ...params, sort: sortParams }, 'aggregations');
+        this.setFacetsLoading(true);
+        const searchResponse = await ((_b = this.host.searchService) === null || _b === void 0 ? void 0 : _b.search(params, this.host.searchType));
+        const success = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.success;
+        // This is checking to see if the query has changed since the data was fetched.
+        // If so, we just want to discard this set of aggregations because they are
+        // likely no longer valid for the newer query.
+        const queryChangedSinceFetch = !this.fetchesInProgress.has(facetFetchQueryKey);
+        this.fetchesInProgress.delete(facetFetchQueryKey);
+        if (queryChangedSinceFetch)
+            return;
+        if (!success) {
+            const errorMsg = (_c = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.error) === null || _c === void 0 ? void 0 : _c.message;
+            const detailMsg = (_e = (_d = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.error) === null || _d === void 0 ? void 0 : _d.details) === null || _e === void 0 ? void 0 : _e.message;
+            if (!errorMsg && !detailMsg) {
+                // @ts-ignore: Property 'Sentry' does not exist on type 'Window & typeof globalThis'
+                (_g = (_f = window === null || window === void 0 ? void 0 : window.Sentry) === null || _f === void 0 ? void 0 : _f.captureMessage) === null || _g === void 0 ? void 0 : _g.call(_f, 'Missing or malformed facet response from backend', 'error');
+            }
+            this.setFacetsLoading(false);
+            return;
+        }
+        const { aggregations, collectionTitles } = success.response;
+        this.aggregations = aggregations;
+        if (collectionTitles) {
+            for (const [id, title] of Object.entries(collectionTitles)) {
+                this.collectionTitles.set(id, title);
+            }
+        }
+        this.yearHistogramAggregation =
+            (_j = (_h = success === null || success === void 0 ? void 0 : success.response) === null || _h === void 0 ? void 0 : _h.aggregations) === null || _j === void 0 ? void 0 : _j.year_histogram;
+        this.setFacetsLoading(false);
+        this.requestHostUpdate();
+    }
+    /**
+     * Performs the initial page fetch(es) for the current search state.
+     */
+    async doInitialPageFetch() {
+        this.setSearchResultsLoading(true);
+        // Try to batch 2 initial page requests when possible
+        await this.fetchPage(this.host.initialPageNumber, 2);
+    }
+    /**
+     * Fetches one or more pages of results and updates the data source.
+     *
+     * @param pageNumber The page number to fetch
+     * @param numInitialPages If this is an initial page fetch (`pageNumber = 1`),
+     *  specifies how many pages to batch together in one request. Ignored
+     *  if `pageNumber != 1`, defaulting to a single page.
+     */
+    async fetchPage(pageNumber, numInitialPages = 1) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        const trimmedQuery = (_a = this.host.baseQuery) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!this.canPerformSearch)
+            return;
+        // if we already have data, don't fetch again
+        if (this.hasPage(pageNumber))
+            return;
+        if (this.endOfDataReached)
+            return;
+        // Batch multiple initial page requests together if needed (e.g., can request
+        // pages 1 and 2 together in a single request).
+        let numPages = pageNumber === 1 ? numInitialPages : 1;
+        const numRows = this.pageSize * numPages;
+        // if a fetch is already in progress for this query and page, don't fetch again
+        const { pageFetchQueryKey } = this;
+        const currentPageKey = `${pageFetchQueryKey}-p:${pageNumber}`;
+        if (this.fetchesInProgress.has(currentPageKey))
+            return;
+        for (let i = 0; i < numPages; i += 1) {
+            this.fetchesInProgress.add(`${pageFetchQueryKey}-p:${pageNumber + i}`);
+        }
+        this.previousQueryKey = pageFetchQueryKey;
+        let sortParams = this.host.sortParam ? [this.host.sortParam] : [];
+        // TODO eventually the PPS should handle these defaults natively
+        const isDefaultProfileSort = this.host.withinProfile && this.host.selectedSort === SortField.default;
+        if (isDefaultProfileSort && this.host.defaultSortParam) {
+            const sortOption = SORT_OPTIONS[this.host.defaultSortParam.field];
+            if (sortOption.searchServiceKey) {
+                sortParams = [
+                    {
+                        field: sortOption.searchServiceKey,
+                        direction: 'desc',
+                    },
+                ];
+            }
+        }
+        const params = {
+            ...this.pageSpecifierParams,
+            query: trimmedQuery || '',
+            page: pageNumber,
+            rows: numRows,
+            sort: sortParams,
+            filters: this.filterMap,
+            aggregations: { omit: true },
+        };
+        params.uid = await this.requestUID(params, 'hits');
+        log('=== FIRING PAGE REQUEST ===', params);
+        const searchResponse = await ((_b = this.host.searchService) === null || _b === void 0 ? void 0 : _b.search(params, this.host.searchType));
+        log('=== RECEIVED PAGE RESPONSE IN CB ===', searchResponse);
+        const success = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.success;
+        // This is checking to see if the fetch has been invalidated since it was fired off.
+        // If so, we just want to discard the response since it is for an obsolete query state.
+        if (!this.fetchesInProgress.has(currentPageKey))
+            return;
+        for (let i = 0; i < numPages; i += 1) {
+            this.fetchesInProgress.delete(`${pageFetchQueryKey}-p:${pageNumber + i}`);
+        }
+        if (!success) {
+            const errorMsg = (_c = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.error) === null || _c === void 0 ? void 0 : _c.message;
+            const detailMsg = (_e = (_d = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.error) === null || _d === void 0 ? void 0 : _d.details) === null || _e === void 0 ? void 0 : _e.message;
+            this.queryErrorMessage = `${errorMsg !== null && errorMsg !== void 0 ? errorMsg : ''}${detailMsg ? `; ${detailMsg}` : ''}`;
+            if (!this.queryErrorMessage) {
+                this.queryErrorMessage = 'Missing or malformed response from backend';
+                // @ts-ignore: Property 'Sentry' does not exist on type 'Window & typeof globalThis'
+                (_g = (_f = window === null || window === void 0 ? void 0 : window.Sentry) === null || _f === void 0 ? void 0 : _f.captureMessage) === null || _g === void 0 ? void 0 : _g.call(_f, this.queryErrorMessage, 'error');
+            }
+            this.setSearchResultsLoading(false);
+            this.requestHostUpdate();
+            return;
+        }
+        this.totalResults = success.response.totalResults - this.offset;
+        if (this.activeOnHost) {
+            this.host.setTotalResultCount(this.totalResults);
+            // display event to offshoot when result count is zero.
+            if (this.totalResults === 0) {
+                this.host.emitEmptyResults();
+            }
+        }
+        if (this.host.withinCollection) {
+            this.collectionExtraInfo = success.response.collectionExtraInfo;
+            // For collections, we want the UI to respect the default sort option
+            // which can be specified in metadata, or otherwise assumed to be week:desc
+            if (this.activeOnHost) {
+                this.host.applyDefaultCollectionSort(this.collectionExtraInfo);
+            }
+            if (this.collectionExtraInfo) {
+                this.parentCollections = [].concat((_j = (_h = this.collectionExtraInfo.public_metadata) === null || _h === void 0 ? void 0 : _h.collection) !== null && _j !== void 0 ? _j : []);
+            }
+        }
+        else if (this.host.withinProfile) {
+            this.accountExtraInfo = success.response.accountExtraInfo;
+            this.pageElements = success.response.pageElements;
+        }
+        const { results, collectionTitles } = success.response;
+        if (results && results.length > 0) {
+            // Load any collection titles present on the response into the cache,
+            // or queue up preload fetches for them if none were present.
+            if (collectionTitles) {
+                for (const [id, title] of Object.entries(collectionTitles)) {
+                    this.collectionTitles.set(id, title);
+                }
+            }
+            // Update the data source for each returned page.
+            // For loans and web archives, we must account for receiving more pages than we asked for.
+            if (this.host.profileElement === 'lending' ||
+                this.host.profileElement === 'web_archives') {
+                numPages = Math.ceil(results.length / this.pageSize);
+                this.endOfDataReached = true;
+                if (this.activeOnHost)
+                    this.host.setTileCount(this.totalResults);
+            }
+            for (let i = 0; i < numPages; i += 1) {
+                const pageStartIndex = this.pageSize * i;
+                this.addTilesToDataSource(pageNumber + i, results.slice(pageStartIndex, pageStartIndex + this.pageSize));
+            }
+        }
+        // When we reach the end of the data, we can set the infinite scroller's
+        // item count to the real total number of results (rather than the
+        // temporary estimates based on pages rendered so far).
+        const resultCountDiscrepancy = numRows - results.length;
+        if (resultCountDiscrepancy > 0) {
+            this.endOfDataReached = true;
+            if (this.activeOnHost)
+                this.host.setTileCount(this.totalResults);
+        }
+        this.setSearchResultsLoading(false);
+        this.requestHostUpdate();
+    }
+    /**
+     * Update the datasource from the fetch response
+     *
+     * @param pageNumber
+     * @param results
+     */
+    addTilesToDataSource(pageNumber, results) {
+        const tiles = [];
+        results === null || results === void 0 ? void 0 : results.forEach(result => {
+            if (!result.identifier)
+                return;
+            tiles.push(new TileModel(result));
+        });
+        this.addPage(pageNumber, tiles);
+        const visiblePages = this.host.currentVisiblePageNumbers;
+        const needsReload = visiblePages.includes(pageNumber);
+        if (needsReload) {
+            this.refreshVisibleResults();
+        }
+    }
+    /**
+     * Fetches the aggregation buckets for the given prefix filter type.
+     */
+    async fetchPrefixFilterBuckets(filterType) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        const trimmedQuery = (_a = this.host.baseQuery) === null || _a === void 0 ? void 0 : _a.trim();
+        if (!this.canPerformSearch)
+            return [];
+        const filterAggregationKey = prefixFilterAggregationKeys[filterType];
+        const sortParams = this.host.sortParam ? [this.host.sortParam] : [];
+        const params = {
+            ...this.pageSpecifierParams,
+            query: trimmedQuery || '',
+            rows: 0,
+            filters: this.filterMap,
+            // Only fetch the firstTitle or firstCreator aggregation
+            aggregations: { simpleParams: [filterAggregationKey] },
+            // Fetch all 26 letter buckets
+            aggregationsSize: 26,
+        };
+        params.uid = await this.requestUID({ ...params, sort: sortParams }, 'aggregations');
+        const searchResponse = await ((_b = this.host.searchService) === null || _b === void 0 ? void 0 : _b.search(params, this.host.searchType));
+        return ((_g = (_f = (_e = (_d = (_c = searchResponse === null || searchResponse === void 0 ? void 0 : searchResponse.success) === null || _c === void 0 ? void 0 : _c.response) === null || _d === void 0 ? void 0 : _d.aggregations) === null || _e === void 0 ? void 0 : _e[filterAggregationKey]) === null || _f === void 0 ? void 0 : _f.buckets) !== null && _g !== void 0 ? _g : []);
+    }
+    /**
+     * Fetches and caches the prefix filter counts for the given filter type.
+     */
+    async updatePrefixFilterCounts(filterType) {
+        const { facetFetchQueryKey } = this;
+        const buckets = await this.fetchPrefixFilterBuckets(filterType);
+        // Don't update the filter counts for an outdated query (if it has been changed
+        // since we sent the request)
+        const queryChangedSinceFetch = facetFetchQueryKey !== this.facetFetchQueryKey;
+        if (queryChangedSinceFetch)
+            return;
+        // Unpack the aggregation buckets into a simple map like { 'A': 50, 'B': 25, ... }
+        this.prefixFilterCountMap = { ...this.prefixFilterCountMap }; // Clone the object to trigger an update
+        this.prefixFilterCountMap[filterType] = buckets.reduce((acc, bucket) => {
+            acc[bucket.key.toUpperCase()] = bucket.doc_count;
+            return acc;
+        }, {});
+        this.requestHostUpdate();
+    }
+    /**
+     * @inheritdoc
+     */
+    async updatePrefixFiltersForCurrentSort() {
+        if (['title', 'creator'].includes(this.host.selectedSort)) {
+            const filterType = this.host.selectedSort;
+            if (!this.prefixFilterCountMap[filterType]) {
+                this.updatePrefixFilterCounts(filterType);
+            }
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    refreshLetterCounts() {
+        if (Object.keys(this.prefixFilterCountMap).length > 0) {
+            this.prefixFilterCountMap = {};
+        }
+        this.updatePrefixFiltersForCurrentSort();
+        this.requestHostUpdate();
+    }
+}
+//# sourceMappingURL=collection-browser-data-source.js.map