@internetarchive/collection-browser 1.14.17 → 2.0.0

package/src/collection-facets/facet-row.ts

@@ -7,7 +7,6 @@ import {
   nothing,
 } from 'lit';
 import { customElement, property } from 'lit/decorators.js';
-import type { CollectionNameCacheInterface } from '@internetarchive/collection-name-cache';
 import eyeIcon from '../assets/img/icons/eye';
 import eyeClosedIcon from '../assets/img/icons/eye-closed';
 import type {
@@ -16,6 +15,7 @@ import type {
   FacetEventDetails,
   FacetState,
 } from '../models';
+import type { CollectionTitles } from '../data-source/models';
 
 @customElement('facet-row')
 export class FacetRow extends LitElement {
@@ -31,7 +31,7 @@ export class FacetRow extends LitElement {
 
   /** The collection name cache for converting collection identifiers to titles */
   @property({ type: Object })
-  collectionNameCache?: CollectionNameCacheInterface;
+  collectionTitles?: CollectionTitles;
 
   //
   // COMPONENT LIFECYCLE METHODS
@@ -56,18 +56,13 @@ export class FacetRow extends LitElement {
     const showOnlyCheckboxId = `${facetType}:${bucket.key}-show-only`;
     const negativeCheckboxId = `${facetType}:${bucket.key}-negative`;
 
-    // For collections, we need to asynchronously load the collection name
-    // so we use the `async-collection-name` widget.
+    // For collections, we render the collection title as a link.
     // For other facet types, we just have a static value to use.
     const bucketTextDisplay =
       facetType !== 'collection'
         ? html`${bucket.displayText ?? bucket.key}`
         : html`<a href="/details/${bucket.key}">
-            <async-collection-name
-              .collectionNameCache=${this.collectionNameCache}
-              .identifier=${bucket.key}
-              placeholder="-"
-            ></async-collection-name>
+            ${this.collectionTitles?.get(bucket.key) ?? bucket.key}
           </a> `;
 
     const facetHidden = bucket.state === 'hidden';

package/src/collection-facets/facets-template.ts

@@ -8,7 +8,6 @@ import {
 } from 'lit';
 import { customElement, property } from 'lit/decorators.js';
 import { repeat } from 'lit/directives/repeat.js';
-import type { CollectionNameCacheInterface } from '@internetarchive/collection-name-cache';
 import {
   FacetGroup,
   FacetBucket,
@@ -16,6 +15,7 @@ import {
   getDefaultSelectedFacets,
   FacetEventDetails,
 } from '../models';
+import type { CollectionTitles } from '../data-source/models';
 import { FacetRow } from './facet-row';
 
 @customElement('facets-template')
@@ -27,7 +27,7 @@ export class FacetsTemplate extends LitElement {
   @property({ type: String }) renderOn?: string;
 
   @property({ type: Object })
-  collectionNameCache?: CollectionNameCacheInterface;
+  collectionTitles?: CollectionTitles;
 
   private facetClicked(e: CustomEvent<FacetEventDetails>) {
     const { bucket, negative } = e.detail;
@@ -126,7 +126,7 @@ export class FacetsTemplate extends LitElement {
           bucket => html`<facet-row
             .facetType=${facetGroup.key}
             .bucket=${bucket}
-            .collectionNameCache=${this.collectionNameCache}
+            .collectionTitles=${this.collectionTitles}
             @facetClick=${this.facetClicked}
           ></facet-row>`
         )}

package/src/collection-facets/more-facets-content.ts

@@ -13,13 +13,13 @@ import { customElement, property, state } from 'lit/decorators.js';
 import {
   Aggregation,
   Bucket,
+  PageType,
   SearchServiceInterface,
   SearchParams,
   SearchType,
   AggregationSortType,
   FilterMap,
 } from '@internetarchive/search-service';
-import type { CollectionNameCacheInterface } from '@internetarchive/collection-name-cache';
 import type { ModalManagerInterface } from '@internetarchive/modal-manager';
 import type { AnalyticsManagerInterface } from '@internetarchive/analytics-manager';
 import {
@@ -32,6 +32,7 @@ import {
   valueFacetSort,
   defaultFacetSort,
 } from '../models';
+import type { CollectionTitles } from '../data-source/models';
 import '@internetarchive/ia-activity-indicator/ia-activity-indicator';
 import './more-facets-pagination';
 import './facets-template';
@@ -61,7 +62,7 @@ export class MoreFacetsContent extends LitElement {
   @property({ type: String }) withinCollection?: string;
 
   @property({ type: Object })
-  collectionNameCache?: CollectionNameCacheInterface;
+  collectionTitles?: CollectionTitles;
 
   @property({ type: Object }) selectedFacets?: SelectedFacets;
 
@@ -142,7 +143,10 @@ export class MoreFacetsContent extends LitElement {
     const aggregationsSize = 65535; // todo - do we want to have all the records at once?
 
     const collectionParams = this.withinCollection
-      ? { pageType: 'collection_details', pageTarget: this.withinCollection }
+      ? {
+          pageType: 'collection_details' as PageType,
+          pageTarget: this.withinCollection,
+        }
       : null;
 
     const params: SearchParams = {
@@ -159,6 +163,13 @@ export class MoreFacetsContent extends LitElement {
 
     this.facetGroup = this.aggregationFacetGroups;
     this.facetsLoading = false;
+
+    const collectionTitles = results?.success?.response?.collectionTitles;
+    if (collectionTitles) {
+      for (const [id, title] of Object.entries(collectionTitles)) {
+        this.collectionTitles?.set(id, title);
+      }
+    }
   }
 
   private pageNumberClicked(e: CustomEvent<{ page: number }>) {
@@ -285,9 +296,6 @@ export class MoreFacetsContent extends LitElement {
             !suppressedCollections[bucketKey] && !bucketKey?.startsWith('fav-')
           );
         });
-
-        // asynchronously load the collection name
-        this.preloadCollectionNames(castedBuckets);
       }
 
       // find length and pagination size for modal pagination
@@ -320,26 +328,13 @@ export class MoreFacetsContent extends LitElement {
     return facetGroups;
   }
 
-  /**
-   * for collections, we need to asynchronously load the collection name
-   * so we use the `async-collection-name` widget and for the rest, we have a static value to use
-   *
-   * @param castedBuckets
-   */
-  private preloadCollectionNames(castedBuckets: any[]) {
-    const collectionIds = castedBuckets?.map(option => option.key);
-    const collectionIdsArray = Array.from(new Set(collectionIds)) as string[];
-
-    this.collectionNameCache?.preloadIdentifiers(collectionIdsArray);
-  }
-
   private get getMoreFacetsTemplate(): TemplateResult {
     return html`
       <facets-template
         .facetGroup=${this.mergedFacets?.shift()}
         .selectedFacets=${this.selectedFacets}
         .renderOn=${'modal'}
-        .collectionNameCache=${this.collectionNameCache}
+        .collectionTitles=${this.collectionTitles}
         @selectedFacetsChanged=${(e: CustomEvent) => {
           this.selectedFacets = e.detail;
         }}

package/src/collection-facets.ts

@@ -22,8 +22,6 @@ import type {
 } from '@internetarchive/search-service';
 import '@internetarchive/histogram-date-range';
 import '@internetarchive/feature-feedback';
-import '@internetarchive/collection-name-cache';
-import type { CollectionNameCacheInterface } from '@internetarchive/collection-name-cache';
 import {
   ModalConfig,
   ModalManagerInterface,
@@ -47,6 +45,7 @@ import {
   suppressedCollections,
   defaultFacetSort,
 } from './models';
+import type { CollectionTitles } from './data-source/models';
 import './collection-facets/more-facets-content';
 import './collection-facets/facets-template';
 import './collection-facets/facet-tombstone-row';
@@ -118,7 +117,7 @@ export class CollectionFacets extends LitElement {
   analyticsHandler?: AnalyticsManagerInterface;
 
   @property({ type: Object, attribute: false })
-  collectionNameCache?: CollectionNameCacheInterface;
+  collectionTitles?: CollectionTitles;
 
   @state() openFacets: Record<FacetOption, boolean> = {
     subject: false,
@@ -188,11 +187,7 @@ export class CollectionFacets extends LitElement {
                 data-id=${collxn}
                 @click=${this.partOfCollectionClicked}
               >
-                <async-collection-name
-                  .collectionNameCache=${this.collectionNameCache}
-                  .identifier=${collxn}
-                  placeholder=${collxn}
-                ></async-collection-name>
+                ${this.collectionTitles?.get(collxn) ?? collxn}
               </a>
             </li>`;
           })}
@@ -307,14 +302,16 @@ export class CollectionFacets extends LitElement {
 
   private get histogramTemplate() {
     const { fullYearsHistogramAggregation } = this;
+    const minDate = fullYearsHistogramAggregation?.first_bucket_key;
+    const maxDate = fullYearsHistogramAggregation?.last_bucket_key;
     return this.fullYearAggregationLoading
       ? html`<div class="histogram-loading-indicator">&hellip;</div>` // Ellipsis block
       : html`
           <histogram-date-range
-            .minDate=${fullYearsHistogramAggregation?.first_bucket_key}
-            .maxDate=${fullYearsHistogramAggregation?.last_bucket_key}
-            .minSelectedDate=${this.minSelectedDate}
-            .maxSelectedDate=${this.maxSelectedDate}
+            .minDate=${minDate}
+            .maxDate=${maxDate}
+            .minSelectedDate=${this.minSelectedDate ?? minDate}
+            .maxSelectedDate=${this.maxSelectedDate ?? maxDate}
             .updateDelay=${100}
             missingDataMessage="..."
             .width=${this.collapsableFacets && this.contentWidth
@@ -652,7 +649,7 @@ export class CollectionFacets extends LitElement {
         .modalManager=${this.modalManager}
         .searchService=${this.searchService}
         .searchType=${this.searchType}
-        .collectionNameCache=${this.collectionNameCache}
+        .collectionTitles=${this.collectionTitles}
         .selectedFacets=${this.selectedFacets}
         .sortedBy=${sortedBy}
         @facetsChanged=${(e: CustomEvent) => {
@@ -694,7 +691,7 @@ export class CollectionFacets extends LitElement {
         .facetGroup=${facetGroup}
         .selectedFacets=${this.selectedFacets}
         .renderOn=${'page'}
-        .collectionNameCache=${this.collectionNameCache}
+        .collectionTitles=${this.collectionTitles}
         @selectedFacetsChanged=${(e: CustomEvent) => {
           const event = new CustomEvent<SelectedFacets>('facetsChanged', {
             detail: e.detail,

package/src/data-source/collection-browser-data-source-interface.ts

@@ -0,0 +1,272 @@
+import type {
+  FilterMap,
+  Aggregation,
+  CollectionExtraInfo,
+  AccountExtraInfo,
+  PageElementMap,
+} from '@internetarchive/search-service';
+import type { ReactiveController } from 'lit';
+import type {
+  PrefixFilterType,
+  PrefixFilterCounts,
+  TileModel,
+} from '../models';
+import type { PageSpecifierParams, CollectionTitles } from './models';
+
+export interface CollectionBrowserDataSourceInterface
+  extends ReactiveController {
+  /**
+   * How many tile models are present in this data source
+   */
+  readonly size: number;
+
+  /**
+   * How many results there are in the full result set for the current query
+   * (not necessarily all loaded yet).
+   */
+  readonly totalResults: number;
+
+  /**
+   * Whether the host has a valid set of properties for performing a search.
+   * For instance, on the search page this requires a valid search service and a
+   * non-empty query, while collection pages allow searching with an empty query
+   * for MDS but not FTS.
+   */
+  readonly canPerformSearch: boolean;
+
+  /**
+   * Whether the end of the set of results for the current query state has been
+   * encountered (i.e., the last page of results).
+   */
+  readonly endOfDataReached: boolean;
+
+  /**
+   * True if the initial work for a new query state has been completed (i.e., firing initial
+   * page/facet requests). False otherwise.
+   */
+  readonly queryInitialized: boolean;
+
+  /**
+   * A string key compactly representing the current full search state, which can
+   * be used to determine, e.g., when a new search is required or whether an arriving
+   * response is outdated.
+   */
+  readonly pageFetchQueryKey: string;
+
+  /**
+   * Similar to `pageFetchQueryKey`, but excluding properties that do not affect
+   * the validity of a set of facets (e.g., sort).
+   */
+  readonly facetFetchQueryKey: string;
+
+  /**
+   * An object representing any collection- or profile-specific properties to be passed along
+   * to the search service, specifying the exact page/tab to fetch results for.
+   */
+  readonly pageSpecifierParams: PageSpecifierParams | null;
+
+  /**
+   * A FilterMap object representing all filters applied to the current search,
+   * including any facets, letter filters, and date ranges.
+   */
+  readonly filterMap: FilterMap;
+
+  /**
+   * The full set of aggregations retrieved for the current search.
+   */
+  readonly aggregations?: Record<string, Aggregation>;
+
+  /**
+   * The `year_histogram` aggregation retrieved for the current search.
+   */
+  readonly yearHistogramAggregation?: Aggregation;
+
+  /**
+   * A map from collection identifiers that appear on hits or aggregations for the
+   * current search, to their human-readable collection titles.
+   */
+  readonly collectionTitles: CollectionTitles;
+
+  /**
+   * The "extra info" package provided by the PPS for collection pages, including details
+   * used to populate the target collection header & About tab content.
+   */
+  readonly collectionExtraInfo?: CollectionExtraInfo;
+
+  /**
+   * The "extra info" package provided by the PPS for profile pages, including details
+   * used to populate the profile header.
+   */
+  readonly accountExtraInfo?: AccountExtraInfo;
+
+  /**
+   * The set of requested page elements for profile pages, if applicable. These represent
+   * any content specific to the current profile tab.
+   */
+  readonly pageElements?: PageElementMap;
+
+  /**
+   * An array of the current target collection's parent collections. Should include *all*
+   * ancestors in the collection hierarchy, not just the immediate parent.
+   */
+  readonly parentCollections?: string[];
+
+  /**
+   * An object storing result counts for the current search bucketed by letter prefix.
+   * Keys are the result field on which the prefixes are considered (e.g., title/creator)
+   * and values are a Record mapping letters to their counts.
+   */
+  readonly prefixFilterCountMap: Partial<
+    Record<PrefixFilterType, PrefixFilterCounts>
+  >;
+
+  /**
+   * Any error message from the most recent search results response.
+   */
+  readonly queryErrorMessage?: string;
+
+  /**
+   * An array of all the tile models whose management checkboxes are checked
+   */
+  readonly checkedTileModels: TileModel[];
+
+  /**
+   * An array of all the tile models whose management checkboxes are unchecked
+   */
+  readonly uncheckedTileModels: TileModel[];
+
+  /**
+   * A Promise which, after each query change, resolves once the fetches for the initial
+   * search have completed. Waits for *both* the hits and aggregations fetches to finish.
+   *
+   * Ensure you await this component's `updateComplete` promise before awaiting this
+   * one, to ensure you do not await an obsolete promise from the previous update.
+   */
+  readonly initialSearchComplete: Promise<boolean>;
+
+  /**
+   * Resets the data source to its empty state, with no result pages, aggregations, etc.
+   */
+  reset(): void;
+
+  /**
+   * Adds the given page of tile models to the data source.
+   * If the given page number already exists, that page will be overwritten.
+   * @param pageNum Which page number to add (indexed starting from 1)
+   * @param pageTiles The array of tile models for the new page
+   */
+  addPage(pageNum: number, pageTiles: TileModel[]): void;
+
+  /**
+   * Returns the given page of tile models from the data source.
+   * @param pageNum Which page number to get (indexed starting from 1)
+   */
+  getPage(pageNum: number): TileModel[];
+
+  /**
+   * Returns the full set of paged tile models stored in this data source.
+   */
+  getAllPages(): Record<string, TileModel[]>;
+
+  /**
+   * Whether the data source contains any tiles for the given page number.
+   * @param pageNum Which page number to query (indexed starting from 1)
+   */
+  hasPage(pageNum: number): boolean;
+
+  /**
+   * Returns the single tile model appearing at the given index in the
+   * data source, with respect to the current page size. Returns `undefined` if
+   * the corresponding page is not present on the data source or if it does not
+   * contain a tile model at the corresponding index.
+   * @param index The 0-based index (within the full data source) of the tile to get
+   */
+  getTileModelAt(index: number): TileModel | undefined;
+
+  /**
+   * Returns the first numeric tile index corresponding to the given tile model object,
+   * or -1 if the given tile model is not present.
+   * @param tile The tile model to search for in the data source
+   */
+  indexOf(tile: TileModel): number;
+
+  /**
+   * Requests that the data source fire a backend request for the given page of results.
+   * @param pageNum Which page number to fetch results for
+   * @param numInitialPages How many pages should be batched together on an initial fetch
+   */
+  fetchPage(pageNum: number, numInitialPages?: number): Promise<void>;
+
+  /**
+   * Requests that the data source update its prefix bucket result counts for the given
+   * type of prefix filter.
+   * @param filterType Which prefixable field to update the buckets for (e.g., title/creator)
+   */
+  updatePrefixFilterCounts(filterType: PrefixFilterType): Promise<void>;
+
+  /**
+   * Fetches and caches the prefix filter counts for the current sort type,
+   * provided it is one that permits prefix filtering. (If not, this does nothing).
+   */
+  updatePrefixFiltersForCurrentSort(): Promise<void>;
+
+  /**
+   * Clears the cached letter counts for both title and creator, and
+   * fetches a new set of counts for whichever of them is the currently
+   * selected sort option (which may be neither).
+   *
+   * Call this whenever the counts are invalidated (e.g., by a query change).
+   */
+  refreshLetterCounts(): void;
+
+  /**
+   * Returns the current page size of the data source.
+   */
+  getPageSize(): number;
+
+  /**
+   * Changes the page size used by the data source, discarding any previously-fetched pages.
+   *
+   * **Note: this operation will reset any data stored in the data source!**
+   * @param pageSize
+   */
+  setPageSize(pageSize: number): void;
+
+  /**
+   * Sets whether this data source should suppress further data fetches, i.e. ignore any
+   * future query changes on its host that would trigger a page/facet fetch.
+   * @param suppressed Whether further fetches for this data source should be suppressed
+   */
+  setFetchesSuppressed(suppressed: boolean): void;
+
+  /**
+   * Notifies the data source that a query change has occurred, which may trigger a data
+   * reset & new fetches.
+   */
+  handleQueryChange(): void;
+
+  /**
+   * Applies the given map function to all of the tile models in every page of the data
+   * source.
+   * @param callback A callback function to apply on each tile model, as with Array.map
+   */
+  map(
+    callback: (model: TileModel, index: number, array: TileModel[]) => TileModel
+  ): void;
+
+  /**
+   * Checks every tile's management checkbox
+   */
+  checkAllTiles(): void;
+
+  /**
+   * Unchecks every tile's management checkbox
+   */
+  uncheckAllTiles(): void;
+
+  /**
+   * Removes all tile models that are currently checked & adjusts the paging
+   * of the data source to account for any new gaps in the data.
+   */
+  removeCheckedTiles(): void;
+}