dbf-mirador 4.2.3

package/src/state/actions/annotation.js

@@ -0,0 +1,123 @@
+import ActionTypes from './action-types';
+
+/**
+ * Request annotations on a canvas
+ *
+ * NOTE: there is no corresponding reducer; the expected API is sagas will
+ *  pick this action up and act on it accordingly.
+ */
+export function requestCanvasAnnotations(windowId, canvasId) {
+  return {
+    canvasId,
+    type: ActionTypes.REQUEST_CANVAS_ANNOTATIONS,
+    windowId,
+  };
+}
+
+/**
+ * requestAnnotation - action creator
+ *
+ * @param  {String} targetId
+ * @param  {String} annotationId
+ * @memberof ActionCreators
+ */
+export function requestAnnotation(targetId, annotationId) {
+  return {
+    annotationId,
+    targetId,
+    type: ActionTypes.REQUEST_ANNOTATION,
+  };
+}
+
+/**
+ * receiveAnnotation - action creator
+ *
+ * @param  {String} targetId
+ * @param  {String} annotationId
+ * @param  {Object} annotationJson
+ * @memberof ActionCreators
+ */
+export function receiveAnnotation(targetId, annotationId, annotationJson) {
+  return {
+    annotationId,
+    annotationJson,
+    targetId,
+    type: ActionTypes.RECEIVE_ANNOTATION,
+  };
+}
+
+/**
+ * receiveAnnotationFailure - action creator
+ *
+ * @param  {String} targetId
+ * @param  {String} annotationId
+ * @param  {String} error
+ * @memberof ActionCreators
+ */
+export function receiveAnnotationFailure(targetId, annotationId, error) {
+  return {
+    annotationId,
+    error,
+    targetId,
+    type: ActionTypes.RECEIVE_ANNOTATION_FAILURE,
+  };
+}
+
+/**
+ * selectAnnotation - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} targetId
+ * @param  {String} annotationId
+ * @memberof ActionCreators
+ */
+export function selectAnnotation(windowId, annotationId) {
+  return {
+    annotationId,
+    type: ActionTypes.SELECT_ANNOTATION,
+    windowId,
+  };
+}
+
+/**
+ * deselectAnnotation - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} targetId
+ * @param  {String} annotationId
+ * @memberof ActionCreators
+ */
+export function deselectAnnotation(windowId, annotationId) {
+  return {
+    annotationId,
+    type: ActionTypes.DESELECT_ANNOTATION,
+    windowId,
+  };
+}
+
+/**
+ * toggleAnnotationDisplay - action creator
+ *
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function toggleAnnotationDisplay(windowId) {
+  return {
+    type: ActionTypes.TOGGLE_ANNOTATION_DISPLAY,
+    windowId,
+  };
+}
+
+/**
+ * toggleAnnotationDisplay - action creator
+ *
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function hoverAnnotation(windowId, annotationIds) {
+  return {
+    annotationIds,
+    type: ActionTypes.HOVER_ANNOTATION,
+    windowId,
+  };
+}

package/src/state/actions/auth.js

@@ -0,0 +1,109 @@
+import ActionTypes from './action-types';
+
+/**
+ * addAuthenticationRequest - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} id
+ * @memberof ActionCreators
+ */
+export function addAuthenticationRequest(windowId, id, profile = undefined) {
+  return {
+    id,
+    profile,
+    type: ActionTypes.ADD_AUTHENTICATION_REQUEST,
+    windowId,
+  };
+}
+
+/**
+ * resolveAuthenticationRequest - action creator
+ * Triggered when we might have an IIIF auth cookie available (but we
+ *   can't be really sure until try the access token)
+ *
+ * @param {String} id
+ * @memberof ActionCreators
+ */
+export function resolveAuthenticationRequest(id, tokenServiceId, props) {
+  return {
+    id,
+    tokenServiceId,
+    type: ActionTypes.RESOLVE_AUTHENTICATION_REQUEST,
+    ...props,
+  };
+}
+
+/**
+ * requestAccessToken - action creator
+ * @private
+ *
+ * @param  {String} serviceId
+ * @param  {String} authId
+ * @memberof ActionCreators
+ */
+export function requestAccessToken(serviceId, authId) {
+  return {
+    authId,
+    serviceId,
+    type: ActionTypes.REQUEST_ACCESS_TOKEN,
+  };
+}
+
+/**
+ * receiveAccessToken - action creator
+ * @private
+ *
+ * @param  {String} serviceId
+ * @param  {Object} json
+ * @memberof ActionCreators
+ */
+export function receiveAccessToken(authId, serviceId, json) {
+  return {
+    authId,
+    json,
+    serviceId,
+    type: ActionTypes.RECEIVE_ACCESS_TOKEN,
+  };
+}
+
+/**
+ * receiveAccessTokenFailure - action creator
+ * @private
+ *
+ * @param  {String} serviceId
+ * @param  {Object} error
+ * @memberof ActionCreators
+ */
+export function receiveAccessTokenFailure(authId, serviceId, error) {
+  return {
+    authId,
+    error,
+    serviceId,
+    type: ActionTypes.RECEIVE_ACCESS_TOKEN_FAILURE,
+  };
+}
+
+/**
+ * resolveAccessTokenRequest - action creator
+ *
+ * @param {String} authServiceId
+ * @param {String} tokenServiceId
+ * @param {Object} json
+ * @memberof ActionCreators
+ */
+export function resolveAccessTokenRequest(authServiceId, tokenServiceId, json) {
+  if (!json.accessToken) return receiveAccessTokenFailure(authServiceId, tokenServiceId, json);
+
+  return receiveAccessToken(authServiceId, tokenServiceId, json);
+}
+
+/**
+ * Resets authentication state for a token service
+ */
+export function resetAuthenticationState({ authServiceId, tokenServiceId }) {
+  return {
+    id: authServiceId,
+    tokenServiceId,
+    type: ActionTypes.RESET_AUTHENTICATION_STATE,
+  };
+}

package/src/state/actions/canvas.js

@@ -0,0 +1,65 @@
+import ActionTypes from './action-types';
+import { getNextCanvasGrouping, getPreviousCanvasGrouping, getCanvasGrouping, getConfig } from '../selectors';
+
+/**
+ * setCanvas - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} canvasId
+ * @memberof ActionCreators
+ */
+export function setCanvas(windowId, canvasId, newGroup = undefined, options = {}) {
+  return (dispatch, getState) => {
+    const state = getState();
+    const { preserveViewport } = getConfig(state).osdConfig;
+    let visibleCanvases = newGroup;
+
+    if (!visibleCanvases) {
+      const group = getCanvasGrouping(state, { canvasId, windowId });
+      visibleCanvases = (group || []).map((c) => c.id);
+    }
+
+    dispatch({
+      canvasId,
+      preserveViewport: options?.preserveViewport ?? preserveViewport,
+      type: ActionTypes.SET_CANVAS,
+      visibleCanvases,
+      windowId,
+    });
+  };
+}
+
+/** Set the window's canvas to the next canvas grouping */
+export function setNextCanvas(windowId) {
+  return (dispatch, getState) => {
+    const state = getState();
+    const newGroup = getNextCanvasGrouping(state, { windowId });
+    const ids = (newGroup || []).map((c) => c.id);
+    newGroup && dispatch(setCanvas(windowId, ids[0], ids));
+  };
+}
+
+/** Set the window's canvas to the previous canvas grouping */
+export function setPreviousCanvas(windowId) {
+  return (dispatch, getState) => {
+    const state = getState();
+
+    const newGroup = getPreviousCanvasGrouping(state, { windowId });
+    const ids = (newGroup || []).map((c) => c.id);
+    newGroup && dispatch(setCanvas(windowId, ids[0], ids));
+  };
+}
+
+/**
+ *
+ * @param windowId
+ * @param payload
+ * @returns {{payload: *, type: string, windowId: *}}
+ */
+export function updateViewport(windowId, payload) {
+  return {
+    payload,
+    type: ActionTypes.UPDATE_VIEWPORT,
+    windowId,
+  };
+}

package/src/state/actions/catalog.js

@@ -0,0 +1,22 @@
+import ActionTypes from './action-types';
+
+/**
+ * add a manifest to the resource catalog
+ * @param {string} manifestId
+ */
+export function addResource(manifestId, manifestJson = undefined, payload) {
+  return {
+    manifestId,
+    manifestJson,
+    payload,
+    type: ActionTypes.ADD_RESOURCE,
+  };
+}
+
+/** remove a manifest from the resource catalog */
+export function removeResource(manifestId) {
+  return {
+    manifestId,
+    type: ActionTypes.REMOVE_RESOURCE,
+  };
+}

package/src/state/actions/companionWindow.js

@@ -0,0 +1,107 @@
+import { v4 as uuid } from 'uuid';
+import ActionTypes from './action-types';
+import { getCompanionWindowIdsForPosition, getManuallyExpandedNodeIds, getVisibleNodeIds } from '../selectors';
+
+const defaultProps = {
+  content: null,
+  position: null,
+};
+
+/** */
+export function addCompanionWindow(windowId, payload, defaults = defaultProps) {
+  const id = `cw-${uuid()}`;
+
+  return {
+    id,
+    payload: {
+      ...defaults,
+      ...payload,
+      id,
+      windowId,
+    },
+    type: ActionTypes.ADD_COMPANION_WINDOW,
+    windowId,
+  };
+}
+
+/** */
+export function addOrUpdateCompanionWindow(windowId, payload, defaults = defaultProps) {
+  return (dispatch, getState) => {
+    const state = getState();
+    const { position } = payload;
+
+    const updatableWindowId = position === 'left' && getCompanionWindowIdsForPosition(state, { position, windowId })[0];
+
+    if (updatableWindowId) {
+      dispatch(updateCompanionWindow(windowId, updatableWindowId, payload));
+    } else {
+      dispatch(addCompanionWindow(windowId, payload, defaults));
+    }
+  };
+}
+
+/** */
+export function updateCompanionWindow(windowId, id, payload) {
+  return {
+    id,
+    payload,
+    type: ActionTypes.UPDATE_COMPANION_WINDOW,
+    windowId,
+  };
+}
+
+/** */
+export function removeCompanionWindow(windowId, id) {
+  return {
+    id,
+    type: ActionTypes.REMOVE_COMPANION_WINDOW,
+    windowId,
+  };
+}
+
+/** */
+export function toggleNode(windowId, id, nodeId) {
+  return (dispatch, getState) => {
+    const state = getState();
+    const collapsedNodeIds = getManuallyExpandedNodeIds(state, { companionWindowId: id }, false);
+    const expandedNodeIds = getManuallyExpandedNodeIds(state, { companionWindowId: id }, true);
+    const visibleNodeIds = getVisibleNodeIds(state, { id, windowId });
+    const expand =
+      collapsedNodeIds.indexOf(nodeId) !== -1 ||
+      (expandedNodeIds.indexOf(nodeId) === -1 && visibleNodeIds.indexOf(nodeId) === -1);
+    return dispatch({
+      id,
+      payload: {
+        [nodeId]: {
+          expanded: expand,
+        },
+      },
+      type: ActionTypes.TOGGLE_TOC_NODE,
+      windowId,
+    });
+  };
+}
+
+/** Update the expanded nodes state */
+export function expandNodes(windowId, id, nodeIds) {
+  return (dispatch, getState) => {
+    const state = getState();
+    const expandedNodeIds = getManuallyExpandedNodeIds(state, { companionWindowId: id }, true);
+    const payload = {};
+
+    expandedNodeIds.forEach((nodeId) => {
+      payload[nodeId] = { expanded: false };
+    });
+
+    nodeIds.forEach((nodeId) => {
+      payload[nodeId] = { expanded: true };
+    });
+
+    return dispatch({
+      id,
+      payload,
+      type: ActionTypes.TOGGLE_TOC_NODE,
+      windowId,
+    });
+  };
+}

package/src/state/actions/config.js

@@ -0,0 +1,49 @@
+import { v4 as uuid } from 'uuid';
+import ActionTypes from './action-types';
+
+/**
+ * importConfig - action creator
+ *
+ * @param  {Object} config
+ * @memberof ActionCreators
+ */
+export function importConfig(config) {
+  return { config, type: ActionTypes.IMPORT_CONFIG };
+}
+
+/**
+ * setConfig - action creator
+ *
+ * @param  {Object} config
+ * @memberof ActionCreators
+ */
+export function setConfig(config) {
+  return { config, type: ActionTypes.SET_CONFIG };
+}
+
+/**
+ * updateConfig - action creator
+ *
+ * @param  {Object} config
+ * @memberof ActionCreators
+ */
+export function updateConfig(config) {
+  return { config, type: ActionTypes.UPDATE_CONFIG };
+}
+
+/**
+ * importMiradorState - action creator
+ *
+ * @param  {Object} config
+ * @memberof ActionCreators
+ */
+export function importMiradorState(state) {
+  const newState = {
+    ...state,
+    workspace: {
+      ...state.workspace,
+      id: uuid(),
+    },
+  };
+  return { state: newState, type: ActionTypes.IMPORT_MIRADOR_STATE };
+}

package/src/state/actions/elasticLayout.js

@@ -0,0 +1,10 @@
+import ActionTypes from './action-types';
+
+/** */
+export function updateElasticWindowLayout(windowId, payload) {
+  return {
+    payload,
+    type: ActionTypes.UPDATE_ELASTIC_WINDOW_LAYOUT,
+    windowId,
+  };
+}

package/src/state/actions/errors.js

@@ -0,0 +1,22 @@
+import { v4 as uuid } from 'uuid';
+import ActionTypes from './action-types';
+
+/**
+ * addError - action creator
+ * @param {string} error
+ */
+export function addError(error) {
+  return {
+    id: `error-${uuid()}`,
+    message: error,
+    type: ActionTypes.ADD_ERROR,
+  };
+}
+
+/**
+ * removeError - action creator
+ * @param {string} id
+ */
+export function removeError(id) {
+  return { id, type: ActionTypes.REMOVE_ERROR };
+}

package/src/state/actions/index.js

@@ -0,0 +1,19 @@
+/**
+ * Action Creators for Mirador
+ * @namespace ActionCreators
+ */
+export * from './companionWindow';
+export * from './config';
+export * from './errors';
+export * from './window';
+export * from './manifest';
+export * from './infoResponse';
+export * from './canvas';
+export * from './workspace';
+export * from './annotation';
+export * from './auth';
+export * from './elasticLayout';
+export * from './search';
+export * from './layers';
+export * from './catalog';
+export { default as ActionTypes } from './action-types';

package/src/state/actions/infoResponse.js

@@ -0,0 +1,90 @@
+import { getIiifResourceImageService } from '../../lib/iiif';
+import ActionTypes from './action-types';
+
+/**
+ * requestInfoResponse - action creator
+ *
+ * @param  {String} infoId
+ * @memberof ActionCreators
+ */
+export function requestInfoResponse(infoId, imageResource, windowId) {
+  return {
+    imageResource,
+    infoId,
+    type: ActionTypes.REQUEST_INFO_RESPONSE,
+    windowId,
+  };
+}
+
+/**
+ * receiveInfoResponse - action creator
+ *
+ * @param  {String} infoId
+ * @param  {Object} manifestJson
+ * @memberof ActionCreators
+ */
+export function receiveInfoResponse(infoId, infoJson, ok, tokenServiceId) {
+  return {
+    infoId,
+    infoJson,
+    ok,
+    tokenServiceId,
+    type: ActionTypes.RECEIVE_INFO_RESPONSE,
+  };
+}
+
+/**
+ * receiveDegradedInfoResponse - action creator
+ *
+ * @param  {String} infoId
+ * @param  {Object} manifestJson
+ * @memberof ActionCreators
+ */
+export function receiveDegradedInfoResponse(infoId, infoJson, ok, tokenServiceId, windowId) {
+  return {
+    infoId,
+    infoJson,
+    ok,
+    tokenServiceId,
+    type: ActionTypes.RECEIVE_DEGRADED_INFO_RESPONSE,
+    windowId,
+  };
+}
+
+/**
+ * receiveInfoResponseFailure - action creator
+ *
+ * @param  {String} infoId
+ * @param  {String} error
+ * @memberof ActionCreators
+ */
+export function receiveInfoResponseFailure(infoId, error, tokenServiceId) {
+  return {
+    error,
+    infoId,
+    tokenServiceId,
+    type: ActionTypes.RECEIVE_INFO_RESPONSE_FAILURE,
+  };
+}
+
+/**
+ * fetchInfoResponse - action creator
+ *
+ * @param  {String} infoId
+ * @memberof ActionCreators
+ */
+export function fetchInfoResponse({ imageId, imageResource, windowId }) {
+  const imageService = imageResource && getIiifResourceImageService(imageResource);
+  const infoId = imageId || imageService.id;
+  return requestInfoResponse(infoId, imageService, windowId);
+}
+
+/**
+ * removeInfoResponse - action creator
+ *
+ * @param  {String} infoId
+ * @memberof ActionCreators
+ */
+export function removeInfoResponse(infoId) {
+  return { infoId, type: ActionTypes.REMOVE_INFO_RESPONSE };
+}

package/src/state/actions/layers.js

@@ -0,0 +1,14 @@
+import ActionTypes from './action-types';
+
+/**
+ * updateLayers - action creator
+ * @param {string} id
+ */
+export function updateLayers(windowId, canvasId, payload) {
+  return {
+    canvasId,
+    payload,
+    type: ActionTypes.UPDATE_LAYERS,
+    windowId,
+  };
+}

package/src/state/actions/manifest.js

@@ -0,0 +1,65 @@
+import ActionTypes from './action-types';
+
+/**
+ * requestManifest - action creator
+ *
+ * @param  {String} manifestId
+ * @memberof ActionCreators
+ */
+export function requestManifest(manifestId, properties) {
+  return {
+    manifestId,
+    properties,
+    type: ActionTypes.REQUEST_MANIFEST,
+  };
+}
+
+/**
+ * receiveManifest - action creator
+ *
+ * @param  {String} manifestId
+ * @param  {Object} manifestJson
+ * @memberof ActionCreators
+ */
+export function receiveManifest(manifestId, manifestJson) {
+  return {
+    manifestId,
+    manifestJson,
+    type: ActionTypes.RECEIVE_MANIFEST,
+  };
+}
+
+/**
+ * receiveManifestFailure - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} error
+ * @memberof ActionCreators
+ */
+export function receiveManifestFailure(manifestId, error) {
+  return {
+    error,
+    manifestId,
+    type: ActionTypes.RECEIVE_MANIFEST_FAILURE,
+  };
+}
+
+/**
+ * fetchManifest - action creator
+ *
+ * @param  {String} manifestId
+ * @memberof ActionCreators
+ */
+export function fetchManifest(manifestId, properties) {
+  return requestManifest(manifestId, { ...properties, isFetching: true });
+}
+
+/**
+ * removeManifest - action creator
+ *
+ * @param  {String} manifestId
+ * @memberof ActionCreators
+ */
+export function removeManifest(manifestId) {
+  return { manifestId, type: ActionTypes.REMOVE_MANIFEST };
+}