dbf-mirador 4.2.3

package/src/state/selectors/auth.js

@@ -0,0 +1,100 @@
+import { createSelector } from 'reselect';
+import { Utils } from 'manifesto.js';
+import { miradorSlice, EMPTY_ARRAY, EMPTY_OBJECT } from './utils';
+import { getConfig } from './config';
+import { getVisibleCanvases, selectInfoResponses } from './canvases';
+import { getMiradorCanvasWrapper } from './wrappers';
+import { getIiifResourceImageService } from '../../lib/iiif';
+
+/**
+ * Returns the authentification profile from the configuration
+ * @param {object} state
+ * @returns {Array}
+ */
+export const getAuthProfiles = createSelector([getConfig], ({ auth: { serviceProfiles = [] } = {} }) => serviceProfiles);
+
+/**
+ * Returns access tokens from the state
+ * @param {object} state
+ * @returns {object}
+ */
+export const getAccessTokens = (state) => miradorSlice(state).accessTokens || EMPTY_OBJECT;
+
+/**
+ * Return the authentification data from the state
+ * @param {object} state
+ * @returns {object}
+ */
+export const getAuth = (state) => miradorSlice(state).auth || EMPTY_OBJECT;
+
+/**
+ * Returns current authentification services based on state and windowId
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const selectCurrentAuthServices = createSelector(
+  [
+    getVisibleCanvases,
+    selectInfoResponses,
+    getAuthProfiles,
+    getAuth,
+    getMiradorCanvasWrapper,
+    (state, { iiifResources }) => iiifResources,
+  ],
+  // eslint-disable-next-line max-params
+  (canvases, infoResponses = {}, serviceProfiles, auth, getMiradorCanvas, iiifResources) => {
+    let currentAuthResources = iiifResources;
+
+    if (!currentAuthResources && canvases) {
+      currentAuthResources = canvases.flatMap((c) => {
+        const miradorCanvas = getMiradorCanvas(c);
+        const images = miradorCanvas.iiifImageResources;
+
+        return images.map((i) => {
+          const iiifImageService = getIiifResourceImageService(i);
+
+          const infoResponse = infoResponses[iiifImageService.id];
+          if (infoResponse && infoResponse.json) {
+            return { ...infoResponse.json, options: {} };
+          }
+
+          return iiifImageService;
+        });
+      });
+    }
+
+    if (!currentAuthResources) return EMPTY_ARRAY;
+    if (currentAuthResources.length === 0) return EMPTY_ARRAY;
+
+    const currentAuthServices = currentAuthResources.map((resource) => {
+      let lastAttemptedService;
+      const services = Utils.getServices(resource);
+
+      for (const authProfile of serviceProfiles) {
+        const profiledAuthServices = services.filter((p) => authProfile.profile === p.getProfile());
+
+        for (const service of profiledAuthServices) {
+          lastAttemptedService = service;
+
+          if (!auth[service.id] || auth[service.id].isFetching || auth[service.id].ok) {
+            return service;
+          }
+        }
+      }
+
+      return lastAttemptedService;
+    });
+
+    return Object.values(
+      currentAuthServices.reduce((h, service) => {
+        if (service && !h[service.id]) {
+          // eslint-disable-next-line no-param-reassign
+          h[service.id] = service;
+        }
+
+        return h;
+      }, {}),
+    );
+  },
+);

package/src/state/selectors/canvases.js

@@ -0,0 +1,260 @@
+import { createSelector } from 'reselect';
+import CanvasGroupings from '../../lib/CanvasGroupings';
+import { getIiifResourceImageService } from '../../lib/iiif';
+import { getMiradorCanvasWrapper } from './wrappers';
+import { miradorSlice, EMPTY_ARRAY } from './utils';
+import { getWindow } from './getters';
+import { getSequence } from './sequences';
+import { getWindowViewType } from './windows';
+import { getManifestLocale, getDestructuredMetadata } from './manifests';
+
+/**
+ * Returns the info response.
+ * @param {object} state
+ * @returns {object}
+ */
+export const selectInfoResponses = (state) => miradorSlice(state).infoResponses;
+
+export const getCanvases = createSelector([getSequence], (sequence) => (sequence && sequence.getCanvases()) || EMPTY_ARRAY);
+
+/**
+ * Return the canvas selected by an id
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.canvasId
+ * @returns {object}
+ */
+export const getCanvas = createSelector([getSequence, (state, { canvasId }) => canvasId], (sequence, canvasId) => {
+  if (!sequence || !canvasId) return undefined;
+
+  return sequence.getCanvasById(canvasId);
+});
+
+/**
+ * Returns the current canvas.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {object|undefined}
+ */
+export const getCurrentCanvas = createSelector([getSequence, getWindow], (sequence, window) => {
+  if (!sequence || !window) return undefined;
+
+  if (!window.canvasId) return sequence.getCanvasByIndex(0);
+
+  return sequence.getCanvasById(window.canvasId);
+});
+
+/**
+ * Returns the visible canvas ids.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getVisibleCanvasIds = createSelector(
+  [getWindow],
+  (window) => (window && (window.visibleCanvases || (window.canvasId && [window.canvasId]))) || EMPTY_ARRAY,
+);
+
+/**
+ * Returns the visible canvses.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getVisibleCanvases = createSelector([getVisibleCanvasIds, getCanvases], (canvasIds, canvases) =>
+  (canvases || []).filter((c) => canvasIds.includes(c.id)),
+);
+
+/**
+ * Return the current canvases grouped by how they'll appear in the viewer.
+ * For book view returns groups of 2, for single returns 1.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getCanvasGroupings = createSelector(
+  [getCanvases, getWindowViewType],
+  (canvases, view) => canvases && new CanvasGroupings(canvases, view).groupings(),
+);
+
+/**
+ * Return the current canvases selected in a window.
+ * For book view returns 2, for single returns 1.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @param {string} props.canvasId
+ * @returns {Array}
+ */
+export const getCanvasGrouping = createSelector(
+  [getCanvasGroupings, (state, { canvasId }) => canvasId],
+  (groupings, canvasId) => (groupings && groupings.find((group) => group.some((c) => c.id === canvasId))) || EMPTY_ARRAY,
+);
+
+/**
+ * Return the next canvas(es) for a window.
+ * For book view returns 2, for single returns 1.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getNextCanvasGrouping = createSelector([getCanvasGroupings, getCurrentCanvas], (groupings, canvas, view) => {
+  if (!groupings || !canvas) return undefined;
+  const currentGroupIndex = groupings.findIndex((group) => group.some((c) => c.id === canvas.id));
+
+  if (currentGroupIndex < 0 || currentGroupIndex + 1 >= groupings.length) return undefined;
+  const newGroup = groupings[currentGroupIndex + 1];
+
+  return newGroup;
+});
+
+/**
+ * Return the previous canvas(es) for a window.
+ * For book view returns 2, for single returns 1.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.manifestId
+ * @param {string} props.windowId
+ * @returns {Array}
+ */
+export const getPreviousCanvasGrouping = createSelector([getCanvasGroupings, getCurrentCanvas], (groupings, canvas, view) => {
+  if (!groupings || !canvas) return undefined;
+
+  const currentGroupIndex = groupings.findIndex((group) => group.some((c) => c.id === canvas.id));
+
+  if (currentGroupIndex < 1) return undefined;
+  const newGroup = groupings[currentGroupIndex - 1];
+
+  return newGroup;
+});
+
+/**
+ * Return canvas label, or alternatively return the given index + 1 to be displayed.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.canvasId
+ * @param {string} props.manifestId
+ * @returns {string|number}
+ */
+export const getCanvasLabel = createSelector(
+  [getCanvas, getManifestLocale],
+  (canvas, locale) => canvas && (canvas.getLabel().length > 0 ? canvas.getLabel().getValue(locale) : String(canvas.index + 1)),
+);
+
+/**
+ * Return canvas metadata in a label / value structure
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.canvasId
+ * @param {string} props.windowId
+ * @returns {Array[Object]}
+ */
+export const getCanvasMetadata = createSelector(
+  [getCanvas, getManifestLocale],
+  (canvas, locale) => canvas && getDestructuredMetadata(canvas, locale),
+);
+
+/**
+ * Return canvas description.
+ * @param {object} canvas
+ * @param {string} companionWindowId
+ */
+export const getCanvasDescription = createSelector([getCanvas], (canvas) => canvas && canvas.getProperty('description'));
+
+/**
+ * Return visible non tiled canvas resources.
+ * @param {object}
+ * @param {string} windowId
+ * @returns {Array}
+ */
+export const getVisibleCanvasNonTiledResources = createSelector(
+  [getVisibleCanvases, getMiradorCanvasWrapper],
+  (canvases, getMiradorCanvas) =>
+    canvases
+      .flatMap((canvas) => getMiradorCanvas(canvas).imageResources)
+      .filter((resource) => !getIiifResourceImageService(resource)),
+);
+
+/**
+ * Returns visible canvas text resources.
+ * @param {object} state
+ * @param {string} windowId
+ * @return {Array}
+ */
+export const getVisibleCanvasTextResources = createSelector(
+  [getVisibleCanvases, getMiradorCanvasWrapper],
+  (canvases, getMiradorCanvas) => canvases.flatMap((canvas) => getMiradorCanvas(canvas).textResources),
+);
+
+/**
+ * Returns visible canvas video resources.
+ * @param {object} state
+ * @param {string} windowId
+ * @return {Array}
+ */
+export const getVisibleCanvasVideoResources = createSelector(
+  [getVisibleCanvases, getMiradorCanvasWrapper],
+  (canvases, getMiradorCanvas) => canvases.flatMap((canvas) => getMiradorCanvas(canvas).videoResources),
+);
+
+/**
+ * Returns visible canvas captions.
+ * @param {object} state
+ * @param {string} windowId
+ * @return {Array}
+ */
+export const getVisibleCanvasCaptions = createSelector(
+  [getVisibleCanvases, getMiradorCanvasWrapper],
+  (canvases, getMiradorCanvas) =>
+    canvases.flatMap((canvas) => {
+      const miradorCanvas = getMiradorCanvas(canvas);
+      // prefer v3, fallback to v2, which can also be an empty array if no captions exist.
+      if (miradorCanvas.v3VttContent.length) return miradorCanvas.v3VttContent;
+      return miradorCanvas.v2VttContent;
+    }),
+);
+
+/**
+ * Returns visible canvas audio resources.
+ * @param {object} state
+ * @param {string} windowId
+ * @return {Array}
+ */
+export const getVisibleCanvasAudioResources = createSelector(
+  [getVisibleCanvases, getMiradorCanvasWrapper],
+  (canvases, getMiradorCanvas) => canvases.flatMap((canvas) => getMiradorCanvas(canvas).audioResources),
+);
+
+/**
+ * Returns info response.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @param {string} props.canvasId
+ * @param {string} props.infoId
+ * @returns {object|undefined}
+ */
+export const selectInfoResponse = createSelector(
+  [(state, { infoId }) => infoId, getCanvas, getMiradorCanvasWrapper, selectInfoResponses],
+  (infoId, canvas, getMiradorCanvas, infoResponses) => {
+    let iiifServiceId = infoId;
+
+    if (!infoId) {
+      if (!canvas) return undefined;
+      const image = getMiradorCanvas(canvas).iiifImageResources[0];
+      iiifServiceId = image && getIiifResourceImageService(image)?.id;
+    }
+
+    return (
+      iiifServiceId && infoResponses[iiifServiceId] && !infoResponses[iiifServiceId].isFetching && infoResponses[iiifServiceId]
+    );
+  },
+);

package/src/state/selectors/companionWindows.js

@@ -0,0 +1,182 @@
+import { createSelector } from 'reselect';
+import groupBy from 'lodash/groupBy';
+import { miradorSlice, EMPTY_ARRAY, EMPTY_OBJECT } from './utils';
+import { getWindow, getWindows } from './getters';
+
+/**
+ * Returns companion windows.
+ * @param {object} state
+ * @returns {object}
+ */
+export function getCompanionWindows(state) {
+  return miradorSlice(state).companionWindows || EMPTY_OBJECT;
+}
+
+/**
+ * Returns the companion window.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @returns {object|undefined}
+ */
+export const getCompanionWindow = createSelector(
+  [getCompanionWindows, (state, { companionWindowId }) => companionWindowId],
+  (companionWindows, companionWindowId) => companionWindowId && companionWindows[companionWindowId],
+);
+
+/**
+ * Returns the companion window locale.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.companionWindowId
+ * @returns {string|undefined}
+ */
+export const getCompanionWindowLocale = createSelector(
+  [getCompanionWindow],
+  (companionWindow) => companionWindow && companionWindow.locale,
+);
+
+/**
+ * Return position of thumbnail navigation in a certain window.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @returns {string|undefined}
+ */
+export const getThumbnailNavigationPosition = createSelector(
+  [getWindow, getCompanionWindows],
+  (window, companionWindows) =>
+    window && companionWindows[window.thumbnailNavigationId] && companionWindows[window.thumbnailNavigationId].position,
+);
+
+/**
+ * Return companion window ids from a window.
+ * @param {string} windowId
+ * @returns {Array}
+ */
+const getCompanionWindowIndexByWindowAndPosition = createSelector(
+  [getWindows, getCompanionWindows],
+  (windows, companionWindows) =>
+    (Object.keys(windows) || []).reduce(
+      (obj, id) => ({
+        ...obj,
+        [id]: groupBy(
+          windows[id].companionWindowIds || EMPTY_ARRAY,
+          (cwid) => companionWindows[cwid] && companionWindows[cwid].position,
+        ),
+      }),
+      {},
+    ),
+);
+
+/**
+ * Return companion window ids from a window.
+ * @param {string} windowId
+ * @returns {Array}
+ */
+const getCompanionWindowsByWindowAndPosition = createSelector([getWindows, getCompanionWindows], (windows, companionWindows) =>
+  (Object.keys(windows) || []).reduce(
+    (obj, id) => ({
+      ...obj,
+      [id]: groupBy(
+        (windows[id].companionWindowIds || EMPTY_ARRAY).map((cwid) => companionWindows[cwid]),
+        (cw) => cw.position,
+      ),
+    }),
+    {},
+  ),
+);
+
+/**
+ * Return companion windows of a window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+const getCompanionWindowsOfWindow = createSelector(
+  [(state, { windowId }) => windowId, getCompanionWindowsByWindowAndPosition],
+  (windowId, companionWindows) => companionWindows[windowId] || EMPTY_OBJECT,
+);
+
+/**
+ * Return companion windows ids of a window.
+ * @param {object} state
+ * @param {string} windowId
+ * @returns {Array}
+ */
+const getCompanionWindowIdsOfWindow = createSelector(
+  [(state, { windowId }) => windowId, getCompanionWindowIndexByWindowAndPosition],
+  (windowId, companionWindowIds) => companionWindowIds[windowId] || EMPTY_OBJECT,
+);
+
+/**
+ * Return the companion window string from state in a given windowId and position.
+ * @param {object} state
+ * @param {string} windowId
+ * @param {string} position
+ * @returns {string}
+ */
+export const getCompanionWindowsForPosition = createSelector(
+  [getCompanionWindowsOfWindow, (state, { position }) => position],
+  (companionWindows, position) => companionWindows[position] || EMPTY_ARRAY,
+);
+
+/**
+ * Return the companion window string from state in a given windowId and content type.
+ * @param {object} state
+ * @param {string} windowId
+ * @param {string} position
+ * @returns {string}
+ */
+export const getCompanionWindowsForContent = createSelector(
+  [getCompanionWindowsOfWindow, (state, { content }) => content],
+  (companionWindows, content) => [].concat(...Object.values(companionWindows)).filter((w) => w.content === content),
+);
+
+/**
+ * Returns companion window ids for position.
+ * @param {object} state
+ * @param {object} props
+ * @param {string} props.windowId
+ * @param {string} props.position
+ * @returns {Array}
+ */
+export const getCompanionWindowIdsForPosition = createSelector(
+  [getCompanionWindowIdsOfWindow, (state, { position }) => position],
+  (companionWindowIds, position) => companionWindowIds[position] || EMPTY_ARRAY,
+);
+
+/**
+ * Returns the visibility of the companion area.
+ * @param {object} state
+ * @param {string} position
+ * @returns {boolean}
+ */
+export const getCompanionAreaVisibility = createSelector([(state, { position }) => position, getWindow], (position, window) => {
+  if (!window) return false;
+  const { companionAreaOpen, sideBarOpen } = window;
+  if (position !== 'left') return true;
+  return !!(companionAreaOpen && sideBarOpen);
+});
+
+/**
+ * Returns the dimensions.
+ * @param {object} state
+ * @param {string} companionWindowId
+ * @returns {object} containing height and width
+ */
+export const selectCompanionWindowDimensions = createSelector([getCompanionWindowsOfWindow], (companionWindows) => {
+  let width = 0;
+  let height = 0;
+  [].concat(...Object.values(companionWindows)).forEach((cw) => {
+    if (cw.position.match(/right/)) {
+      width += 235;
+    }
+
+    if (cw.position.match(/bottom/)) {
+      height += 201;
+    }
+  });
+
+  return { height, width };
+});

package/src/state/selectors/config.js

@@ -0,0 +1,100 @@
+import { createSelector } from 'reselect';
+import deepmerge from 'deepmerge';
+import { miradorSlice, EMPTY_ARRAY, EMPTY_OBJECT } from './utils';
+import { getWorkspace } from './getters';
+
+/**
+ * Returns the config from the redux state.
+ * @param {object} state
+ * @returns {object} containing config
+ */
+export function getConfig(state) {
+  const slice = miradorSlice(state || {});
+  return slice.config || EMPTY_OBJECT;
+}
+
+/**
+ * Extract an exportable version of state using the configuration from the config.
+ * @param {object} state
+ * @returns {object} containing exportable state
+ */
+export function getExportableState(state) {
+  const exportConfig = getConfig(state).export;
+
+  return Object.entries(exportConfig).reduce((acc, [stem, value]) => {
+    if (value === true) {
+      // eslint-disable-next-line no-param-reassign
+      acc[stem] = state[stem];
+    } else if (value.filter) {
+      // eslint-disable-next-line no-param-reassign
+      acc[stem] = Object.entries(state[stem])
+        .filter(value.filter)
+        .reduce((stemAcc, [k, v]) => {
+          // eslint-disable-next-line no-param-reassign
+          stemAcc[k] = v;
+          return stemAcc;
+        }, {});
+    }
+    return acc;
+  }, {});
+}
+
+/**
+ * Return languages from config (in state) and indicate which is currently set.
+ * @param {object} state
+ * @returns {Array} [ {locale: 'de', label: 'Deutsch', current: true}, ... ]
+ */
+export const getLanguagesFromConfigWithCurrent = createSelector([getConfig], ({ availableLanguages, language }) =>
+  Object.keys(availableLanguages).map((key) => ({
+    current: key === language,
+    label: availableLanguages[key],
+    locale: key,
+  })),
+);
+
+/**
+ * Returns if showZoomControls is set in the config.
+ * @param {object} state
+ * @returns {boolean}
+ */
+export const getShowZoomControlsConfig = createSelector([getWorkspace, getConfig], (workspace, config) =>
+  workspace.showZoomControls === undefined ? config.workspace.showZoomControls : workspace.showZoomControls,
+);
+
+/**
+ * Returns the theme from the config.
+ * @param {object} state
+ * @returns {object} {palette: {...}, typography: {...}, overrides: {...}, ...}
+ */
+export const getTheme = createSelector([getConfig], ({ theme, themes, selectedTheme }) =>
+  deepmerge(theme, themes[selectedTheme] || {}),
+);
+
+/**
+ * Returns the theme ids from the config.
+ * @param {object} state
+ * @returns {Array} ['dark', 'light']
+ */
+export const getThemeIds = createSelector([getConfig], ({ themes }) => Object.keys(themes));
+
+/* @deprecated */
+export const getContainerId = createSelector([getConfig], ({ id }) => id);
+
+/**
+ * Returns the theme direction from the config.
+ * @param {object} state
+ * @returns {string}
+ */
+export const getThemeDirection = createSelector([getConfig], ({ theme }) => theme.direction || 'ltr');
+/**
+ * Returns the requests configurations from the config.
+ * @param {object} state
+ * @returns {object} {preprocessor: [...], postprocessor: [...]}
+ */
+export const getRequestsConfig = createSelector([getConfig], ({ requests }) => requests || EMPTY_OBJECT);
+/**
+ * Returns the thumbnails configurations from the config.
+ * @param {object} state
+ * @returns {object} {preprocessor: [...], postprocessor: [...]}
+ */
+export const getThumbnailsConfig = createSelector([getConfig], ({ thumbnails }) => thumbnails || EMPTY_OBJECT);