@internetarchive/collection-browser 0.0.1-alpha.1

package/dist/src/collection-browser.d.ts

@@ -0,0 +1,151 @@
+import { LitElement, PropertyValues, TemplateResult } from 'lit';
+import type { InfiniteScrollerCellProviderInterface } from '@internetarchive/infinite-scroller';
+import { SearchServiceInterface } from '@internetarchive/search-service';
+import { SortParam } from '@internetarchive/search-service/dist/src/search-params';
+import { SharedResizeObserverInterface } from '@internetarchive/shared-resize-observer';
+import type { CollectionDisplayMode } from './models';
+import '@internetarchive/infinite-scroller';
+import '@internetarchive/histogram-date-range';
+import './tiles/tile-dispatcher';
+import './tiles/loading-tile';
+import './sort-filter-bar/sort-filter-bar';
+import './collection-facets';
+import { CollectionFacets } from './collection-facets';
+import './circular-activity-indicator';
+export declare class CollectionBrowser extends LitElement implements InfiniteScrollerCellProviderInterface {
+    baseNavigationUrl?: string;
+    searchService?: SearchServiceInterface;
+    baseQuery?: string;
+    showDeleteButtons: boolean;
+    displayMode: CollectionDisplayMode;
+    sortParam?: SortParam;
+    additionalQueryClause?: string;
+    dateRangeQueryClause?: string;
+    pageSize: number;
+    resizeObserver?: SharedResizeObserverInterface;
+    collectionFacets: CollectionFacets;
+    /**
+     * The page that the consumer wants to load.
+     */
+    private initialPageNumber;
+    /**
+     * This the the number of pages that we want to show.
+     *
+     * The data isn't necessarily loaded for all of the pages, but this lets us
+     * know how many cells we should render.
+     */
+    private pagesToRender;
+    private searchResultsLoading;
+    private selectedFacets;
+    private facetsLoading;
+    private fullYearAggregationLoading;
+    private aggregations?;
+    private fullYearsHistogramAggregation;
+    /**
+     * When we're animated scrolling to the page, we don't want to fetch
+     * all of the pages as it scrolls so this lets us know if we're scrolling
+     */
+    private isScrollingToCell;
+    /**
+     * When we've reached the end of the data, stop trying to fetch more
+     */
+    private endOfDataReached;
+    private placeholderCellTemplate;
+    private tileModelAtCellIndex;
+    private get estimatedTileCount();
+    private get actualTileCount();
+    /**
+     * The results per page so we can paginate.
+     *
+     * This allows us to start in the middle of the search results and
+     * fetch data before or after the current page. If we don't have a key
+     * for the previous/next page, we'll fetch the next/previous page to populate it
+     */
+    private dataSource;
+    private infiniteScroller;
+    /**
+     *
+     * @param pageNumber
+     * @param scroll
+     */
+    goToPage(pageNumber: number): void;
+    render(): TemplateResult<1>;
+    private get loadingTemplate();
+    private get currentYearsHistogramAggregation();
+    private get histogramDataLoading();
+    private get histogramTemplate();
+    private histogramDateRangeUpdated;
+    updated(changed: PropertyValues): void;
+    /**
+     * When the visible cells change from the infinite scroller, we want to emit
+     * which page is currently visible so the consumer can update its UI or the URL
+     *
+     * @param e
+     * @returns
+     */
+    private visibleCellsChanged;
+    private initialQueryChangeHappened;
+    private previousQueryKey?;
+    private handleQueryChange;
+    private doInitialPageFetch;
+    private get fullQuery();
+    private get fullQueryWithoutDate();
+    private get facetQuery();
+    facetsChanged(e: CustomEvent<Record<string, string[]>>): void;
+    private fetchFacets;
+    /**
+     * If we haven't changed the query, we don't need to fetch the full year histogram
+     *
+     * @private
+     * @type {string}
+     * @memberof CollectionBrowser
+     */
+    private previousFullQueryNoDate?;
+    /**
+     * The query key is a string that uniquely identifies the current query
+     * without the date range.
+     *
+     * If this doesn't change, we don't need to re-fetch the histogram date range
+     */
+    private get fullQueryNoDateKey();
+    /**
+     * This method is similar to fetching the facets above,
+     * but only fetching the year histogram. There is a subtle difference
+     * in how you have to fetch the year histogram where you can't use the
+     * advanced JSON syntax like the other aggregations. It's a special
+     * case that @ximm put it place.
+     */
+    private fetchFullYearHistogram;
+    private scrollToPage;
+    /**
+     * The query key is a string that uniquely identifies the current query
+     *
+     * This lets us keep track of queries so we don't persist data that's
+     * no longer relevant.
+     */
+    private get pageFetchQueryKey();
+    private pageFetchesInProgress;
+    fetchPage(pageNumber: number): Promise<void>;
+    /**
+     * This is useful for determining whether we need to reload the scroller.
+     *
+     * When the fetch completes, we need to reload the scroller if the cells for that
+     * page are visible, but if the page is not currenlty visible, we don't need to reload
+     */
+    private get currentVisiblePageNumbers();
+    /**
+     * Update the datasource from the fetch response
+     *
+     * @param pageNumber
+     * @param docs
+     */
+    private updateDataSource;
+    private etreeTitle;
+    cellForIndex(index: number): TemplateResult | undefined;
+    /**
+     * When the user scrolls near to the bottom of the page, fetch the next page
+     * increase the number of pages to render and start fetching data for the new page
+     */
+    private scrollThresholdReached;
+    static styles: import("lit").CSSResult;
+}