dbf-mirador 4.2.3

package/src/state/selectors/getters.js

@@ -0,0 +1,90 @@
+import { createSelector } from 'reselect';
+import { miradorSlice, EMPTY_ARRAY, EMPTY_OBJECT } from './utils';
+
+/**
+ * Returns the manifest titles for all open windows.
+ * @param {object} state
+ * @returns {Array} containing manifests ids.
+ */
+export function getWindowManifests(state) {
+  return Object.values(miradorSlice(state).windows).map((window) => window.manifestId);
+}
+
+/**
+ * Returns the opened windows.
+ * @param {object} state
+ * @returns {object} {id: {canvasId: {...}, ...}, ...}
+ */
+export function getWindows(state) {
+  return miradorSlice(state).windows || EMPTY_OBJECT;
+}
+
+/**
+ * Returns a window based on a given windowId.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object|undefined}
+ */
+export function getWindow(state, { windowId }) {
+  return getWindows(state)[windowId];
+}
+
+/**
+ * Returns the viewer for a given window.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object|undefined} {flip: false, rotation: 0, x: 1, y: 2, zoom: 0.5}
+ */
+export const getViewer = createSelector(
+  [(state) => miradorSlice(state).viewers, (state, { windowId }) => windowId],
+  (viewers, windowId) => viewers[windowId],
+);
+
+/**
+ * Returns the workspace.
+ * @param {object} state
+ * @returns {object}
+ */
+export function getWorkspace(state) {
+  return miradorSlice(state).workspace;
+}
+
+/**
+ * Returns the windowIds.
+ * @param {object} state
+ * @returns {Array}
+ */
+export const getWindowIds = createSelector([getWorkspace], ({ windowIds }) => windowIds || EMPTY_ARRAY);
+
+/**
+ * Returns all manifests including manifest information.
+ * @param {object} state
+ * @returns {object}
+ */
+export function getManifests(state) {
+  return miradorSlice(state).manifests || EMPTY_OBJECT;
+}
+
+/**
+ * Get the relevant manifest information for a given manifest.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {object}
+ */
+export function getManifest(state, { manifestId, windowId }) {
+  const manifests = getManifests(state);
+  return manifests && manifests[manifestId || (windowId && (getWindow(state, { windowId }) || EMPTY_OBJECT).manifestId)];
+}
+
+/**
+ * Get the opened catalog.
+ * @param {object} state
+ * @returns {object} containing manifestIds for the manifests in the catalog
+ */
+export function getCatalog(state) {
+  return miradorSlice(state).catalog || EMPTY_OBJECT;
+}

package/src/state/selectors/index.js

@@ -0,0 +1,17 @@
+export * from './annotations';
+export * from './canvases';
+export * from './companionWindows';
+export * from './config';
+export * from './getters';
+export * from './manifests';
+export * from './windows';
+export * from './workspace';
+export * from './searches';
+export * from './ranges';
+export * from './layers';
+export * from './sequences';
+export * from './auth';
+export * from './utils';
+export * from './viewer';
+export * from './thumbnails';
+export * from './wrappers';

package/src/state/selectors/layers.js

@@ -0,0 +1,79 @@
+import { createSelector } from 'reselect';
+import { getMiradorCanvasWrapper } from './wrappers';
+import { getCanvas, getVisibleCanvasIds } from './canvases';
+import { miradorSlice, EMPTY_ARRAY } from './utils';
+
+/**
+ * Get the image layers from a canvas.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.canvasId
+ * @param {string} props.windowId
+ * @param {string} props.companionWindowId
+ * @returns {Array}
+ */
+export const getCanvasLayers = createSelector([getCanvas, getMiradorCanvasWrapper], (canvas, getMiradorCanvas) => {
+  if (!canvas) return [];
+  return getMiradorCanvas(canvas).imageResources;
+});
+
+export const getLayersForWindow = createSelector(
+  [(state) => miradorSlice(state).layers, (state, { windowId }) => windowId],
+  (layers, windowId) => (layers ? layers[windowId] || EMPTY_ARRAY : EMPTY_ARRAY),
+);
+
+/**
+ * Get the layer state for a particular canvas.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {object}
+ */
+export const getLayers = createSelector(
+  [getLayersForWindow, (state, { canvasId }) => canvasId],
+  (layers, canvasId) => layers[canvasId],
+);
+
+/**
+ * Returns a list of canvas layers, sorted by the layer state configuration.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @returns {Array}
+ */
+export const getSortedLayers = createSelector([getCanvasLayers, getLayers], (canvasLayers, layerConfig) => {
+  if (!layerConfig) return canvasLayers;
+
+  const sorted = canvasLayers.sort((a, b) => {
+    if (
+      layerConfig[a.id] &&
+      layerConfig[a.id].index !== undefined &&
+      layerConfig[b.id] &&
+      layerConfig[b.id].index !== undefined
+    ) {
+      return layerConfig[a.id].index - layerConfig[b.id].index;
+    }
+
+    // sort a layer with index data above layers without
+    if (layerConfig[a.id] && layerConfig[a.id].index !== undefined) return -1;
+    if (layerConfig[b.id] && layerConfig[b.id].index !== undefined) return 1;
+
+    return 0;
+  });
+
+  return sorted;
+});
+
+/**
+ * Get all the layer configuration for visible canvases.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object}
+ */
+export const getLayersForVisibleCanvases = createSelector([getVisibleCanvasIds, getLayersForWindow], (canvasIds, layers) =>
+  canvasIds.reduce((acc, canvasId) => {
+    // eslint-disable-next-line no-param-reassign
+    acc[canvasId] = layers[canvasId];
+    return acc;
+  }, {}),
+);

package/src/state/selectors/manifests.js

@@ -0,0 +1,433 @@
+import { createSelector } from 'reselect';
+import { PropertyValue, Utils, Resource } from 'manifesto.js';
+import asArray from '../../lib/asArray';
+import { getCompanionWindowLocale } from './companionWindows';
+import { getManifest } from './getters';
+import { getConfig } from './config';
+import { getThumbnailFactory } from './thumbnails';
+
+/** */
+function createManifestoInstance(json, locale) {
+  if (!json) return undefined;
+  // Use structuredClone to create a deep copy and prevent Manifesto from mutating the json
+  const manifestoObject = Utils.parseManifest(structuredClone(json), locale ? { locale } : undefined);
+  if (manifestoObject) {
+    // Local patching of Manifesto so that when its a Collection, it behaves similarly
+    if (typeof manifestoObject.getSequences != 'function') {
+      manifestoObject.getSequences = () => [];
+    }
+    return manifestoObject;
+  }
+  return undefined;
+}
+
+/** */
+export const getLocale = createSelector(
+  [getCompanionWindowLocale, getConfig, (state, { locale }) => locale],
+  (companionWindowLocale, config = {}, locale) => locale || companionWindowLocale || config.language || config.fallbackLanguages,
+);
+
+const defaultManifestStatus = Object.freeze({ missing: true });
+
+/**
+ * Convenience selector to get a manifest (or placeholder).
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object} {error: null: id: string, isFetching: boolean, json: {...}}
+ */
+export const getManifestStatus = createSelector([getManifest], (manifest) => manifest || defaultManifestStatus);
+
+/**
+ * Convenience selector to get a manifest loading error
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @returns {string|null}
+ */
+export const getManifestError = createSelector([getManifest], (manifest) => manifest && manifest.error);
+
+/** Instantiate a manifesto instance */
+const getContextualManifestoInstance = createSelector(
+  getManifest,
+  (manifest) => manifest && createManifestoInstance(manifest.json),
+);
+
+/**
+ * Instantiate a manifesto instance
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @returns {object}
+ */
+export const getManifestoInstance = createSelector(
+  getContextualManifestoInstance,
+  (state, { json }) => json,
+  (manifesto, manifestJson) => (manifestJson && createManifestoInstance(manifestJson)) || manifesto,
+);
+
+export const getManifestLocale = createSelector(
+  [getManifestoInstance, getLocale],
+  (manifest, locale) =>
+    locale ?? (manifest && manifest.options && manifest.options.locale && manifest.options.locale.replace(/-.*$/, '')),
+);
+
+/** */
+function getProperty(property) {
+  return createSelector([getManifestoInstance], (manifest) => manifest && manifest.getProperty(property));
+}
+
+/**
+ * Return the IIIF v3 provider of a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestProviderName = createSelector(
+  [getProperty('provider'), getManifestLocale],
+  (provider, locale) => provider && provider[0].label && PropertyValue.parse(provider[0].label).getValue(locale),
+);
+
+const EMPTY_LOGO_OPTS = Object.freeze({});
+
+/**
+ * Return the IIIF v3 provider logo.
+ * @param {object} state
+ * @param {object} props
+ * @returns {string|null}
+ */
+export const getProviderLogo = createSelector(
+  [getProperty('provider'), (state) => getThumbnailFactory(state, EMPTY_LOGO_OPTS)],
+  (provider, thumbnailFactory) => {
+    const logo = provider && provider[0] && provider[0].logo && provider[0].logo[0];
+    if (!logo) return null;
+    return thumbnailFactory.get(new Resource(logo))?.url;
+  },
+);
+
+/**
+ * Get the logo for a manifest.
+ * @param {object} state
+ * @param {object} props
+ * @returns {string|null}
+ */
+export const getManifestLogo = createSelector(
+  [getManifestoInstance, getProviderLogo],
+  (manifest, v3logo) => v3logo || (manifest && manifest.getLogo()),
+);
+
+/**
+ * Return the IIIF v3 homepage of a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestHomepage = createSelector(
+  [getProperty('homepage'), getManifestLocale],
+  (homepages, locale) =>
+    homepages &&
+    asArray(homepages).map((homepage) => ({
+      label: PropertyValue.parse(homepage.label).getValue(locale),
+      value: homepage.id || homepage['@id'],
+    })),
+);
+
+/**
+ * Return the IIIF v3 renderings of a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestRenderings = createSelector(
+  [getManifestoInstance, getManifestLocale],
+  (manifest, locale) =>
+    manifest &&
+    manifest.getRenderings().map((rendering) => ({
+      label: rendering.getLabel().getValue(locale),
+      value: rendering.id,
+    })),
+);
+
+/**
+ * Return the IIIF v2/v3 seeAlso data from a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestSeeAlso = createSelector(
+  [getProperty('seeAlso'), getManifestLocale],
+  (seeAlso, locale) =>
+    seeAlso &&
+    asArray(seeAlso).map((related) => ({
+      format: related.format,
+      label: PropertyValue.parse(related.label).getValue(locale),
+      value: related.id || related['@id'],
+    })),
+);
+
+/**
+ * Return the IIIF v2/v3 seeAlso data from a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ * @deprecated This does not actually return the content of "related" and
+ * might be removed in a future version.
+ * @see getManifestSeeAlso
+ */
+export const getManifestRelatedContent = getManifestSeeAlso;
+
+/**
+ * Return the IIIF v2 realated links manifest or null
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestRelated = createSelector(
+  [getProperty('related'), getManifestLocale],
+  (relatedLinks, locale) =>
+    relatedLinks &&
+    asArray(relatedLinks).map((related) =>
+      typeof related === 'string'
+        ? {
+            value: related,
+          }
+        : {
+            format: related.format,
+            label: PropertyValue.parse(related.label).getValue(locale),
+            value: related.id || related['@id'],
+          },
+    ),
+);
+
+/**
+ * Return the IIIF requiredStatement (v3) or attribution (v2) data from a manifest or null
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getRequiredStatement = createSelector(
+  [getLocale, getManifestoInstance],
+  (locale, manifest) =>
+    manifest &&
+    asArray(manifest.getRequiredStatement()).flatMap((labelValuePair) => {
+      const values = labelValuePair?.getValues(locale) ?? [];
+      if (!values.length) {
+        return [];
+      }
+      const labels = labelValuePair?.getLabels(locale) ?? [];
+      return Array.from({ length: Math.max(labels.length, values.length) }, (_, idx) => idx)
+        .filter((idx) => values[idx])
+        .map((idx) => ({
+          label: labels[idx] ?? null,
+          values: [values[idx]],
+        }));
+    }),
+);
+
+/**
+ * Return the IIIF v2 rights (v3) or license (v2) data from a manifest or null
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getRights = createSelector(
+  [getProperty('rights'), getProperty('license'), getManifestLocale],
+  (rights, license, locale) => {
+    const data = rights || license;
+    return asArray(PropertyValue.parse(data).getValues(locale));
+  },
+);
+
+/**
+ * Return the supplied thumbnail for a manifest or null.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export function getManifestThumbnail(state, props) {
+  const manifest = getManifestoInstance(state, props);
+  const thumbnailFactory = getThumbnailFactory(state, 80, 120);
+  if (!manifest) return undefined;
+  const thumbnail = thumbnailFactory.get(manifest);
+  return thumbnail && thumbnail.url;
+}
+
+/**
+ * Return manifest title.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string}
+ */
+export const getManifestTitle = createSelector(
+  [getManifestoInstance, getManifestLocale],
+  (manifest, locale) => manifest && manifest.getLabel().getValue(locale),
+);
+
+/**
+ * Return manifest description (IIIF v2) -- distinct from any description field nested under metadata.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string|null}
+ */
+export const getManifestDescription = createSelector(
+  [getLocale, getManifestoInstance],
+  (locale, manifest) => manifest && manifest.getDescription().getValue(locale),
+);
+
+/**
+ * Return manifest summary (IIIF v3).
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @return {string|null}
+ */
+export const getManifestSummary = createSelector(
+  [getProperty('summary'), getManifestLocale],
+  (summary, locale) => summary && PropertyValue.parse(summary).getValue(locale),
+);
+
+/**
+ * Return manifest title.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {string}
+ */
+export const getManifestUrl = createSelector([getManifestoInstance], (manifest) => manifest && manifest.id);
+
+/**
+ * Return metadata in a label / value structure
+ * This is a potential seam for pulling the i18n locale from
+ * state and plucking out the appropriate language.
+ * For now we're just getting the first.
+ * @param {object} Manifesto IIIF Resource (e.g. canvas, manifest)
+ * @param iiifResource
+ * @returns {Array[Object]}
+ */
+export function getDestructuredMetadata(iiifResource, locale = undefined) {
+  return (
+    iiifResource &&
+    iiifResource.getMetadata().map((labelValuePair) => ({
+      label: labelValuePair.getLabel(locale),
+      values: labelValuePair.getValues(locale),
+    }))
+  );
+}
+
+/**
+ * Return manifest metadata in a label / value structure
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {Array[Object]}
+ */
+export const getManifestMetadata = createSelector(
+  [getManifestoInstance, getManifestLocale],
+  (manifest, locale) => manifest && getDestructuredMetadata(manifest, locale),
+);
+
+/** */
+function getLocalesForStructure(item) {
+  const languages = new Set([]);
+
+  /** Extract language indicators from IIIF v2 or v3 manifests */
+  const extractLanguage = (i) => {
+    if (!(i && typeof i === 'object')) return;
+
+    // IIIF v2 pattern
+    if (i['@language'] && i['@value']) {
+      languages.add(i['@language']);
+      return;
+    }
+
+    // IIIF v3 pattern
+    Object.keys(i).forEach((key) => {
+      languages.add(key);
+    });
+  };
+
+  if (Array.isArray(item)) {
+    item.forEach((i) => extractLanguage(i));
+  } else {
+    extractLanguage(item);
+  }
+
+  return [...languages];
+}
+
+/** */
+function getLocales(resource) {
+  if (!resource) return [];
+
+  const metadata = resource.getProperty('metadata') || [];
+  const languages = {};
+
+  for (let i = 0; i < metadata.length; i += 1) {
+    const item = metadata[i];
+    getLocalesForStructure(item.label).forEach((l) => {
+      languages[l] = true;
+    });
+    getLocalesForStructure(item.value).forEach((l) => {
+      languages[l] = true;
+    });
+  }
+  return Object.keys(languages);
+}
+
+export const getMetadataLocales = createSelector([getManifestoInstance], (manifest) => getLocales(manifest));
+
+/**
+ * Returns manifest search service.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @returns {string|null}
+ */
+export const getManifestSearchService = createSelector([getManifestoInstance], (manifest) => {
+  if (!manifest) return null;
+  const searchService =
+    manifest.getService('http://iiif.io/api/search/0/search') || manifest.getService('http://iiif.io/api/search/1/search');
+  if (searchService) return searchService;
+  return null;
+});
+
+/**
+ * Returns manifest autocomplete service.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @returns {string|null}
+ */
+export const getManifestAutocompleteService = createSelector([getManifestSearchService], (searchService) => {
+  const autocompleteService =
+    searchService &&
+    (searchService.getService('http://iiif.io/api/search/0/autocomplete') ||
+      searchService.getService('http://iiif.io/api/search/1/autocomplete'));
+
+  return autocompleteService && autocompleteService;
+});