dbf-mirador 4.2.3

package/src/state/reducers/windows.js

@@ -0,0 +1,185 @@
+import update from 'lodash/fp/update';
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * windowsReducer
+ */
+// eslint-disable-next-line complexity
+export const windowsReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.ADD_WINDOW:
+      return { ...state, [action.window.id]: action.window };
+
+    case ActionTypes.MAXIMIZE_WINDOW:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          maximized: true,
+        },
+      };
+    case ActionTypes.MINIMIZE_WINDOW:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          maximized: false,
+        },
+      };
+
+    case ActionTypes.UPDATE_WINDOW:
+      if (!state[action.id]) return state;
+
+      return update(
+        [action.id],
+        (orig) => ({
+          ...(orig || {}),
+          // drop explicit `undefined` values so they can't clobber existing keys on spread (#3930)
+          ...Object.fromEntries(Object.entries(action.payload).filter(([, value]) => value !== undefined)),
+        }),
+        state,
+      );
+
+    case ActionTypes.REMOVE_WINDOW:
+      return omit(state, [action.windowId]);
+    case ActionTypes.TOGGLE_WINDOW_SIDE_BAR:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          sideBarOpen: !state[action.windowId].sideBarOpen,
+        },
+      };
+    case ActionTypes.SET_WINDOW_VIEW_TYPE:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          view: action.viewType,
+        },
+      };
+    case ActionTypes.UPDATE_WINDOW_POSITION:
+      return {
+        ...state,
+        [action.payload.windowId]: {
+          ...state[action.payload.windowId],
+          x: action.payload.position.x,
+          y: action.payload.position.y,
+        },
+      };
+    case ActionTypes.SET_WINDOW_SIZE:
+      return {
+        ...state,
+        [action.payload.windowId]: {
+          ...state[action.payload.windowId],
+          height: action.payload.size.height,
+          width: action.payload.size.width,
+          x: action.payload.size.x,
+          y: action.payload.size.y,
+        },
+      };
+    case ActionTypes.SET_CANVAS:
+      if (!state[action.windowId]) return state;
+
+      return update(
+        [action.windowId],
+        (orig) => ({
+          ...(orig || {}),
+          canvasId: action.canvasId,
+          visibleCanvases: action.visibleCanvases || [],
+        }),
+        state,
+      );
+    case ActionTypes.ADD_COMPANION_WINDOW:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          companionWindowIds: state[action.windowId].companionWindowIds.concat([action.id]),
+          ...(action.payload.position === 'left' ? { companionAreaOpen: true, sideBarPanel: action.payload.content } : {}),
+        },
+      };
+    case ActionTypes.UPDATE_COMPANION_WINDOW:
+      if (action.payload.position !== 'left') return state;
+
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          companionAreaOpen: true,
+        },
+      };
+    case ActionTypes.REMOVE_COMPANION_WINDOW:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          companionWindowIds: state[action.windowId].companionWindowIds.filter((id) => id !== action.id),
+        },
+      };
+    case ActionTypes.SELECT_ANNOTATION:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          selectedAnnotationId: action.annotationId,
+        },
+      };
+    case ActionTypes.DESELECT_ANNOTATION: {
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          selectedAnnotationId: undefined,
+        },
+      };
+    }
+    case ActionTypes.HOVER_ANNOTATION:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          hoveredAnnotationIds: action.annotationIds,
+        },
+      };
+    case ActionTypes.TOGGLE_ANNOTATION_DISPLAY:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          highlightAllAnnotations: !state[action.windowId].highlightAllAnnotations,
+        },
+      };
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.windows || [];
+    case ActionTypes.REQUEST_SEARCH:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          suggestedSearches: undefined,
+        },
+      };
+    case ActionTypes.SHOW_COLLECTION_DIALOG:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          collectionDialogOn: true,
+          collectionManifestId: action.manifestId,
+          dialogCollectionPath: action.dialogCollectionPath,
+        },
+      };
+    case ActionTypes.HIDE_COLLECTION_DIALOG:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          collectionDialogOn: false,
+        },
+      };
+    default:
+      return state;
+  }
+};

package/src/state/reducers/workspace.js

@@ -0,0 +1,111 @@
+import settings from '../../config/settings';
+import ActionTypes from '../actions/action-types';
+
+/** Check if the viewport dimensions are fully specified */
+function hasViewportPosition(viewportPosition) {
+  return (
+    viewportPosition.x !== undefined &&
+    viewportPosition.y !== undefined &&
+    viewportPosition.width !== undefined &&
+    viewportPosition.height !== undefined
+  );
+}
+
+/** Check if the containee is fully within the bounds on the container */
+function contains(container, containee) {
+  return (
+    containee.x - containee.width / 2 > container.x - container.width / 2 &&
+    containee.y - containee.height / 2 > container.y - container.height / 2 &&
+    containee.x + containee.width / 2 < container.x + container.width / 2 &&
+    containee.y + containee.height / 2 < container.y + container.height / 2
+  );
+}
+
+/**
+ * workspaceReducer
+ */
+export const workspaceReducer = (state = { ...settings.workspace, windowIds: [] }, action) => {
+  let newWorkspaceDimensions;
+  let viewportPosition;
+  let newWindowIds;
+  switch (action.type) {
+    case ActionTypes.UPDATE_WORKSPACE:
+      return {
+        ...state,
+        ...action.config,
+      };
+    case ActionTypes.FOCUS_WINDOW:
+      return {
+        ...state,
+        focusedWindowId: action.windowId,
+        viewportPosition: {
+          ...state.viewportPosition,
+          ...action.position,
+        },
+      };
+    case ActionTypes.ADD_WINDOW:
+      return {
+        ...state,
+        focusedWindowId: action.window.id,
+        windowIds: [...(state.windowIds || []), action.window.id],
+      };
+    case ActionTypes.REMOVE_WINDOW:
+      newWindowIds = (state.windowIds || []).filter((v) => v !== action.windowId);
+
+      return {
+        ...state,
+        focusedWindowId:
+          action.windowId === state.focusedWindowId ? newWindowIds[newWindowIds.length - 1] : state.focusedWindowId,
+        windowIds: newWindowIds,
+      };
+    case ActionTypes.SET_WORKSPACE_FULLSCREEN:
+      return { ...state, isFullscreenEnabled: action.isFullscreenEnabled };
+    case ActionTypes.TOGGLE_ZOOM_CONTROLS:
+      return { ...state, showZoomControls: action.showZoomControls };
+    case ActionTypes.UPDATE_WORKSPACE_MOSAIC_LAYOUT:
+      return { ...state, layout: action.layout };
+    case ActionTypes.SET_WORKSPACE_ADD_VISIBILITY:
+      return { ...state, isWorkspaceAddVisible: action.isWorkspaceAddVisible };
+    case ActionTypes.SET_WORKSPACE_VIEWPORT_POSITION:
+      newWorkspaceDimensions = {};
+
+      viewportPosition = {
+        ...state.viewportPosition,
+        ...action.payload.position,
+      };
+
+      if (
+        hasViewportPosition(viewportPosition) &&
+        !contains(
+          {
+            height: state.height,
+            width: state.width,
+            x: 0,
+            y: 0,
+          },
+          viewportPosition,
+        )
+      ) {
+        newWorkspaceDimensions = {
+          height: state.height * 2,
+          width: state.width * 2,
+        };
+      }
+
+      return {
+        ...state,
+        ...newWorkspaceDimensions,
+        viewportPosition,
+      };
+    case ActionTypes.SET_CONFIG:
+    case ActionTypes.IMPORT_CONFIG:
+    case ActionTypes.UPDATE_CONFIG:
+      return { ...state, ...action.config.workspace };
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.workspace || {};
+    case ActionTypes.TOGGLE_DRAGGING:
+      return { ...state, draggingEnabled: !state.draggingEnabled };
+    default:
+      return state;
+  }
+};

package/src/state/sagas/annotations.js

@@ -0,0 +1,48 @@
+import { all, put, select, takeEvery } from 'redux-saga/effects';
+import { requestCanvasAnnotations, receiveAnnotation, requestAnnotation } from '../actions';
+import { getAnnotations, getCanvas, getMiradorCanvasWrapper } from '../selectors';
+import ActionTypes from '../actions/action-types';
+import MiradorCanvas from '../../lib/MiradorCanvas';
+
+/** Fetch annotations for a given canvas */
+export function* fetchCanvasAnnotations({ canvasId, windowId }) {
+  const canvas = yield select(getCanvas, { canvasId, windowId });
+  const annotations = yield select(getAnnotations);
+  const getMiradorCanvas = yield select(getMiradorCanvasWrapper);
+  const miradorCanvas = getMiradorCanvas(canvas);
+
+  return yield all([
+    // IIIF v2
+    ...miradorCanvas.annotationListUris
+      .filter((uri) => !(annotations[canvas.id] && annotations[canvas.id][uri]))
+      .map((uri) => put(requestAnnotation(canvas.id, uri))),
+    // IIIF v3
+    ...miradorCanvas.canvasAnnotationPages
+      .filter((annotation) => !(annotations[canvas.id] && annotations[canvas.id][annotation.id]))
+      .map((annotation) => {
+        // If there are no items, try to retrieve the referenced resource.
+        // otherwise the resource should be embedded and just add to the store.
+        if (!annotation.items) {
+          return put(requestAnnotation(canvas.id, annotation.id));
+        }
+
+        return put(receiveAnnotation(canvas.id, annotation.id, annotation));
+      }),
+  ]);
+}
+
+/**
+ * Fetch annotations for the visible canvases.
+ */
+export function* fetchAnnotations({ visibleCanvases = [], windowId }) {
+  // this little indirection allows plugins to also handle the request
+  return yield all(visibleCanvases.map((canvasId) => put(requestCanvasAnnotations(windowId, canvasId))));
+}
+
+/** */
+export default function* appSaga() {
+  yield all([
+    takeEvery(ActionTypes.REQUEST_CANVAS_ANNOTATIONS, fetchCanvasAnnotations),
+    takeEvery(ActionTypes.SET_CANVAS, fetchAnnotations),
+  ]);
+}

package/src/state/sagas/app.js

@@ -0,0 +1,56 @@
+import { all, call, put, takeEvery } from 'redux-saga/effects';
+import { v4 as uuid } from 'uuid';
+import { fetchManifests } from './iiif';
+import { fetchWindowManifest } from './windows';
+import { addWindow } from '../actions';
+import ActionTypes from '../actions/action-types';
+
+/** */
+export function* importState(action) {
+  yield all([
+    ...Object.entries(action.state.windows || {}).map(([_, window]) =>
+      call(fetchWindowManifest, { id: window.id, payload: window }),
+    ),
+    ...Object.entries(action.state.manifests || {})
+      .filter(([_, manifest]) => !manifest.json)
+      .map(([_, manifest]) => call(fetchManifests, manifest.id)),
+  ]);
+}
+
+/** Add windows from the imported config */
+export function* importConfig({ config: { thumbnailNavigation, windows } }) {
+  if (!windows || windows.length === 0) return;
+
+  const thunks = yield all(
+    windows.map((miradorWindow) => {
+      const windowId = `window-${uuid()}`;
+      const manifestId = miradorWindow.manifestId || miradorWindow.loadedManifest;
+
+      return call(addWindow, {
+        // these are default values ...
+        id: windowId,
+        manifestId,
+        thumbnailNavigationPosition: thumbnailNavigation && thumbnailNavigation.defaultPosition,
+        // ... overridden by values from the window configuration ...
+        ...miradorWindow,
+      });
+    }),
+  );
+
+  yield all(thunks.map((thunk) => put(thunk)));
+}
+
+/** */
+export function* fetchCollectionManifests(action) {
+  const { dialogCollectionPath, manifestId } = action;
+  yield call(fetchManifests, manifestId, ...dialogCollectionPath);
+}
+
+/** */
+export default function* appSaga() {
+  yield all([
+    takeEvery(ActionTypes.IMPORT_MIRADOR_STATE, importState),
+    takeEvery(ActionTypes.IMPORT_CONFIG, importConfig),
+    takeEvery(ActionTypes.SHOW_COLLECTION_DIALOG, fetchCollectionManifests),
+  ]);
+}

package/src/state/sagas/auth.js

@@ -0,0 +1,151 @@
+import { all, call, put, select, takeEvery, delay } from 'redux-saga/effects';
+import { Utils } from 'manifesto.js';
+import ActionTypes from '../actions/action-types';
+import { addAuthenticationRequest, resolveAuthenticationRequest, requestAccessToken, resetAuthenticationState } from '../actions';
+import {
+  selectInfoResponses,
+  getVisibleCanvases,
+  getWindows,
+  getConfig,
+  getAuth,
+  getAccessTokens,
+  getMiradorCanvasWrapper,
+} from '../selectors';
+import { fetchInfoResponse } from './iiif';
+
+/** */
+export function* refetchInfoResponsesOnLogout({ tokenServiceId }) {
+  // delay logout actions to give the cookie service a chance to invalidate our cookies
+  // before we reinitialize openseadragon and rerequest images.
+
+  yield delay(2000);
+  yield call(refetchInfoResponses, { serviceId: tokenServiceId });
+}
+
+/**
+ * Figure out what info responses could have used the access token service and:
+ *   - refetch, if they are currently visible
+ *   - throw them out (and lazy re-fetch) otherwise
+ */
+export function* refetchInfoResponses({ serviceId }) {
+  const windows = yield select(getWindows);
+
+  const canvases = yield all(Object.keys(windows).map((windowId) => select(getVisibleCanvases, { windowId })));
+
+  const getMiradorCanvas = yield select(getMiradorCanvasWrapper);
+
+  const visibleImageApiIds = canvases.flat().flatMap((canvas) => getMiradorCanvas(canvas).imageServiceIds);
+
+  const infoResponses = yield select(selectInfoResponses);
+  /** */
+  const haveThisTokenService = (infoResponse) => {
+    const services = Utils.getServices(infoResponse);
+    return services.some((e) => {
+      const infoTokenService =
+        Utils.getService(e, 'http://iiif.io/api/auth/1/token') || Utils.getService(e, 'http://iiif.io/api/auth/0/token');
+      return infoTokenService && infoTokenService.id === serviceId;
+    });
+  };
+
+  const obsoleteInfoResponses = Object.values(infoResponses).filter((i) => i.json && haveThisTokenService(i.json));
+
+  yield all(
+    obsoleteInfoResponses.map(({ id: infoId }) => {
+      if (visibleImageApiIds.includes(infoId)) {
+        return call(fetchInfoResponse, { infoId });
+      }
+      return put({ infoId, type: ActionTypes.REMOVE_INFO_RESPONSE });
+    }),
+  );
+}
+
+/** try to start any non-interactive auth flows */
+export function* doAuthWorkflow({ infoJson, windowId }) {
+  const auths = yield select(getAuth);
+  const { auth: { serviceProfiles = [] } = {} } = yield select(getConfig);
+  const nonInteractiveAuthFlowProfiles = serviceProfiles.filter((p) => p.external || p.kiosk);
+
+  // try to get an untried, non-interactive auth service
+  const authService = Utils.getServices(infoJson)
+    .filter((s) => !auths[s.id])
+    .find((e) => nonInteractiveAuthFlowProfiles.some((p) => p.profile === e.getProfile()));
+  if (!authService) return;
+
+  const profileConfig = nonInteractiveAuthFlowProfiles.find((p) => p.profile === authService.getProfile());
+
+  if (profileConfig.kiosk) {
+    // start the auth
+    yield put(addAuthenticationRequest(windowId, authService.id, authService.getProfile()));
+  } else if (profileConfig.external) {
+    const tokenService =
+      Utils.getService(authService, 'http://iiif.io/api/auth/1/token') ||
+      Utils.getService(authService, 'http://iiif.io/api/auth/0/token');
+
+    if (!tokenService) return;
+    // start the auth
+    yield put(addAuthenticationRequest(windowId, authService.id, authService.getProfile()));
+    // resolve the auth
+    yield put(resolveAuthenticationRequest(authService.id, tokenService.id, { ok: true }));
+    // start access tokens
+    yield put(requestAccessToken(tokenService.id, authService.id));
+  }
+}
+
+/** */
+export function* rerequestOnAccessTokenFailure({ infoJson, windowId, tokenServiceId }) {
+  if (!tokenServiceId) return;
+
+  // make sure we have an auth service to try
+  const authService = Utils.getServices(infoJson).find((service) => {
+    const tokenService =
+      Utils.getService(service, 'http://iiif.io/api/auth/1/token') ||
+      Utils.getService(service, 'http://iiif.io/api/auth/0/token');
+
+    return tokenService && tokenService.id === tokenServiceId;
+  });
+
+  if (!authService) return;
+
+  // make sure the token ever worked (and might have expired or needs to be re-upped)
+  const accessTokenServices = yield select(getAccessTokens);
+  const service = accessTokenServices[tokenServiceId];
+  if (!(service && service.success)) return;
+
+  yield put(requestAccessToken(tokenServiceId, authService.id));
+}
+
+/** */
+export function* invalidateInvalidAuth({ serviceId }) {
+  const accessTokenServices = yield select(getAccessTokens);
+  const authServices = yield select(getAuth);
+
+  const accessTokenService = accessTokenServices[serviceId];
+  if (!accessTokenService) return;
+  const authService = authServices[accessTokenService.authId];
+  if (!authService) return;
+
+  if (accessTokenService.success) {
+    // if the token ever worked, reset things so we try to get a new cookie
+    yield put(
+      resetAuthenticationState({
+        authServiceId: authService.id,
+        tokenServiceId: accessTokenService.id,
+      }),
+    );
+  } else {
+    // if the token never worked, mark the auth service as bad so we could
+    // try to pick a different service
+    yield put(resolveAuthenticationRequest(authService.id, accessTokenService.id, { ok: false }));
+  }
+}
+
+/** */
+export default function* authSaga() {
+  yield all([
+    takeEvery(ActionTypes.RECEIVE_DEGRADED_INFO_RESPONSE, rerequestOnAccessTokenFailure),
+    takeEvery(ActionTypes.RECEIVE_ACCESS_TOKEN_FAILURE, invalidateInvalidAuth),
+    takeEvery(ActionTypes.RECEIVE_DEGRADED_INFO_RESPONSE, doAuthWorkflow),
+    takeEvery(ActionTypes.RECEIVE_ACCESS_TOKEN, refetchInfoResponses),
+    takeEvery(ActionTypes.RESET_AUTHENTICATION_STATE, refetchInfoResponsesOnLogout),
+  ]);
+}