dbf-mirador 4.2.3

package/src/state/reducers/config.js

@@ -0,0 +1,39 @@
+import deepmerge from 'deepmerge';
+import settings from '../../config/settings';
+import ActionTypes from '../actions/action-types';
+
+const initialState = { ...settings };
+
+/** Overwrite arrays when deep merging */
+const overwriteMerge = (destinationArray, sourceArray, options) => sourceArray;
+
+/**
+ * configReducer - does a deep merge of the config
+ */
+export const configReducer = (state = initialState, action) => {
+  switch (action.type) {
+    case ActionTypes.UPDATE_CONFIG:
+    case ActionTypes.IMPORT_CONFIG:
+      return deepmerge(state, action.config, { arrayMerge: overwriteMerge });
+    case ActionTypes.SET_CONFIG:
+      return action.config;
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return {
+        ...(action.state.config || {}),
+        export: deepmerge(state.export || {}, action.state.config?.export || {}, {
+          arrayMerge: overwriteMerge,
+        }),
+        requests: deepmerge(state.requests || {}, action.state.config?.requests || {}, {
+          arrayMerge: overwriteMerge,
+        }),
+        theme: deepmerge(state.theme || {}, action.state.config?.theme || {}, {
+          arrayMerge: overwriteMerge,
+        }),
+        themes: deepmerge(state.themes || {}, action.state.config?.themes || {}, {
+          arrayMerge: overwriteMerge,
+        }),
+      };
+    default:
+      return state;
+  }
+};

package/src/state/reducers/elasticLayout.js

@@ -0,0 +1,29 @@
+import update from 'lodash/fp/update';
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * elasticLayoutReducer
+ */
+export const elasticLayoutReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.ADD_WINDOW:
+      return {
+        ...state,
+        [action.window.id]: {
+          windowId: action.window.id,
+          ...action.elasticLayout,
+        },
+      };
+
+    case ActionTypes.UPDATE_ELASTIC_WINDOW_LAYOUT:
+      return update([action.windowId], (orig) => ({ ...(orig || {}), ...action.payload }), state);
+
+    case ActionTypes.REMOVE_WINDOW:
+      return omit(state, action.windowId);
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.elasticLayout || {};
+    default:
+      return state;
+  }
+};

package/src/state/reducers/errors.js

@@ -0,0 +1,51 @@
+import without from 'lodash/without';
+import ActionTypes from '../actions/action-types';
+
+const defaultState = { items: [] };
+
+/**
+ * errorsReducer
+ */
+export const errorsReducer = (state = defaultState, action) => {
+  let ret;
+  switch (action.type) {
+    case ActionTypes.ADD_ERROR:
+      return {
+        ...state,
+        [action.id]: { id: action.id, message: action.message },
+        items: [...state.items, action.id],
+      };
+    case ActionTypes.RECEIVE_INFO_RESPONSE_FAILURE:
+      return {
+        ...state,
+        [action.infoId]: {
+          id: action.infoId,
+          message: action.error,
+        },
+        items: [...state.items, action.infoId],
+      };
+    case ActionTypes.RECEIVE_SEARCH_FAILURE:
+      return {
+        ...state,
+        [action.searchId]: {
+          id: action.searchId,
+          message: action.error,
+        },
+        items: [...state.items, action.searchId],
+      };
+    case ActionTypes.REMOVE_ERROR:
+      ret = Object.keys(state).reduce((object, key) => {
+        if (key !== action.id) {
+          // eslint-disable-next-line no-param-reassign
+          object[key] = state[key];
+        }
+        return object;
+      }, {});
+      ret.items = without(ret.items, action.id);
+      return ret;
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return defaultState;
+    default:
+      return state;
+  }
+};

package/src/state/reducers/index.js

@@ -0,0 +1,15 @@
+export * from './accessTokens';
+export * from './companionWindows';
+export * from './errors';
+export * from './workspace';
+export * from './windows';
+export * from './manifests';
+export * from './infoResponses';
+export * from './config';
+export * from './viewers';
+export * from './annotations';
+export * from './auth';
+export * from './elasticLayout';
+export * from './search';
+export * from './layers';
+export * from './catalog';

package/src/state/reducers/infoResponses.js

@@ -0,0 +1,61 @@
+import ActionTypes from '../actions/action-types';
+
+/**
+ * infoResponsesReducer
+ */
+export const infoResponsesReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.REQUEST_INFO_RESPONSE:
+      return {
+        ...state,
+        [action.infoId]: {
+          id: action.infoId,
+          isFetching: true,
+        },
+      };
+    case ActionTypes.RECEIVE_INFO_RESPONSE:
+      return {
+        ...state,
+        [action.infoId]: {
+          degraded: false,
+          id: action.infoId,
+          isFetching: false,
+          json: action.infoJson,
+          tokenServiceId: action.tokenServiceId,
+        },
+      };
+    case ActionTypes.RECEIVE_DEGRADED_INFO_RESPONSE:
+      return {
+        ...state,
+        [action.infoId]: {
+          degraded: true,
+          id: action.infoId,
+          isFetching: false,
+          json: action.infoJson,
+          tokenServiceId: action.tokenServiceId,
+        },
+      };
+    case ActionTypes.RECEIVE_INFO_RESPONSE_FAILURE:
+      return {
+        ...state,
+        [action.infoId]: {
+          error: action.error,
+          id: action.infoId,
+          isFetching: false,
+          tokenServiceId: action.tokenServiceId,
+        },
+      };
+    case ActionTypes.REMOVE_INFO_RESPONSE:
+      return Object.keys(state).reduce((object, key) => {
+        if (key !== action.infoId) {
+          // eslint-disable-next-line no-param-reassign
+          object[key] = state[key];
+        }
+        return object;
+      }, {});
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return {};
+    default:
+      return state;
+  }
+};

package/src/state/reducers/layers.js

@@ -0,0 +1,23 @@
+import omit from 'lodash/omit';
+import deepmerge from 'deepmerge';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * configReducer - does a deep merge of the config
+ */
+export const layersReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.UPDATE_LAYERS:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          [action.canvasId]: deepmerge((state[action.windowId] || {})[action.canvasId] || {}, action.payload),
+        },
+      };
+    case ActionTypes.REMOVE_WINDOW:
+      return omit(state, [action.windowId]);
+    default:
+      return state;
+  }
+};

package/src/state/reducers/manifests.js

@@ -0,0 +1,52 @@
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * manifestsReducer
+ */
+export const manifestsReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.REQUEST_MANIFEST:
+      return {
+        [action.manifestId]: {
+          ...state[action.manifestId],
+          ...action.properties,
+          id: action.manifestId,
+        },
+        ...omit(state, action.manifestId),
+      };
+    case ActionTypes.RECEIVE_MANIFEST:
+      return {
+        ...state,
+        [action.manifestId]: {
+          ...state[action.manifestId],
+          error: null, // Explicitly set the error to null in case this is a re-fetch
+          id: action.manifestId,
+          isFetching: false,
+          json: action.manifestJson,
+        },
+      };
+    case ActionTypes.RECEIVE_MANIFEST_FAILURE:
+      return {
+        ...state,
+        [action.manifestId]: {
+          ...state[action.manifestId],
+          error: action.error,
+          id: action.manifestId,
+          isFetching: false,
+        },
+      };
+    case ActionTypes.REMOVE_MANIFEST:
+      return Object.keys(state).reduce((object, key) => {
+        if (key !== action.manifestId) {
+          // eslint-disable-next-line no-param-reassign
+          object[key] = state[key];
+        }
+        return object;
+      }, {});
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.manifests || {};
+    default:
+      return state;
+  }
+};

package/src/state/reducers/rootReducer.js

@@ -0,0 +1,44 @@
+import { combineReducers } from 'redux';
+import {
+  accessTokensReducer,
+  authReducer,
+  companionWindowsReducer,
+  configReducer,
+  elasticLayoutReducer,
+  errorsReducer,
+  infoResponsesReducer,
+  manifestsReducer,
+  viewersReducer,
+  windowsReducer,
+  workspaceReducer,
+  annotationsReducer,
+  searchesReducer,
+  layersReducer,
+  catalogReducer,
+} from '.';
+
+/**
+ * Function to create root reducer
+ * from plugin reducers.
+ * @namespace CreateRootReducer
+ */
+export default function createRootReducer(pluginReducers) {
+  return combineReducers({
+    accessTokens: accessTokensReducer,
+    annotations: annotationsReducer,
+    auth: authReducer,
+    catalog: catalogReducer,
+    companionWindows: companionWindowsReducer,
+    config: configReducer,
+    elasticLayout: elasticLayoutReducer,
+    errors: errorsReducer,
+    infoResponses: infoResponsesReducer,
+    layers: layersReducer,
+    manifests: manifestsReducer,
+    searches: searchesReducer,
+    viewers: viewersReducer,
+    windows: windowsReducer,
+    workspace: workspaceReducer,
+    ...pluginReducers,
+  });
+}

package/src/state/reducers/search.js

@@ -0,0 +1,145 @@
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * searchReducer
+ */
+export const searchesReducer = (state = {}, action) => {
+  const searchStruct = (state[action.windowId] || {})[action.companionWindowId] || {};
+  switch (action.type) {
+    case ActionTypes.REQUEST_SEARCH:
+      if (searchStruct.query !== action.query) {
+        // new query
+        return {
+          ...state,
+          [action.windowId]: {
+            ...state[action.windowId],
+            [action.companionWindowId]: {
+              ...searchStruct,
+              data: {
+                [action.searchId]: {
+                  isFetching: true,
+                },
+              },
+              query: action.query,
+              selectedContentSearchAnnotation: [],
+            },
+          },
+        };
+      }
+
+      // paginating through a query
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          [action.companionWindowId]: {
+            ...searchStruct,
+            data: {
+              ...searchStruct.data,
+              [action.searchId]: {
+                isFetching: true,
+              },
+            },
+          },
+        },
+      };
+    case ActionTypes.RECEIVE_SEARCH:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          [action.companionWindowId]: {
+            ...searchStruct,
+            data: {
+              ...searchStruct.data,
+              [action.searchId]: {
+                isFetching: false,
+                json: action.searchJson,
+              },
+            },
+          },
+        },
+      };
+    case ActionTypes.RECEIVE_SEARCH_FAILURE:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          [action.companionWindowId]: {
+            ...searchStruct,
+            data: {
+              ...searchStruct.data,
+              [action.searchId]: {
+                error: action.error,
+                isFetching: false,
+              },
+            },
+          },
+        },
+      };
+    case ActionTypes.REMOVE_SEARCH:
+      return {
+        ...state,
+        [action.windowId]: Object.keys(state[action.windowId]).reduce((object, key) => {
+          if (key !== action.companionWindowId) {
+            // eslint-disable-next-line no-param-reassign
+            object[key] = state[action.windowId][key];
+          }
+          return object;
+        }, {}),
+      };
+    case ActionTypes.SET_CONTENT_SEARCH_CURRENT_ANNOTATIONS:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          [action.companionWindowId]: {
+            ...searchStruct,
+            selectedContentSearchAnnotationIds: action.annotationIds,
+          },
+        },
+      };
+    case ActionTypes.SELECT_ANNOTATION:
+      if (!state[action.windowId]) return state;
+
+      return {
+        ...state,
+        [action.windowId]: Object.keys(state[action.windowId]).reduce((object, key) => {
+          const search = state[action.windowId][key];
+          const searchHasAnnotation =
+            search.data &&
+            Object.values(search.data)
+              .filter((resp) => resp.json && resp.json.resources)
+              .some((resp) => [resp.json.resources].flat().some((r) => r['@id'] === action.annotationId));
+
+          if (searchHasAnnotation) {
+            // eslint-disable-next-line no-param-reassign
+            object[key] = {
+              ...search,
+              selectedContentSearchAnnotationIds: [action.annotationId],
+            };
+          } else {
+            // eslint-disable-next-line no-param-reassign
+            object[key] = search;
+          }
+          return object;
+        }, {}),
+      };
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return {};
+    case ActionTypes.REMOVE_WINDOW:
+      return omit(state, action.windowId);
+    case ActionTypes.REMOVE_COMPANION_WINDOW:
+      if (!state[action.windowId]) return state;
+
+      return {
+        ...state,
+        [action.windowId]: {
+          ...omit(state[action.windowId], action.id),
+        },
+      };
+    default:
+      return state;
+  }
+};

package/src/state/reducers/utils.js

@@ -0,0 +1,45 @@
+import _set from 'lodash/fp/set';
+import _update from 'lodash/fp/update';
+import _unset from 'lodash/fp/unset';
+
+/**
+ * Sets the value at path of object.
+ * If a portion of `path` doesn't exist, it's created.
+ *
+ * @param {Object} object
+ * @param {String|String[]} path
+ * @param {any} value
+ * @return {Object}
+ */
+export function set(object, path, value) {
+  return _set(path, value, object);
+}
+
+/**
+ * Updates the value at path of object.
+ * If a portion of `path` doesn't exist, it's created.
+ * If `value` is a function it should have this signature: (currentValue) => newValue.
+ * If `value` is an object it is assumed that the current value is also an object
+ * and the new value will crated by: { ...currentValue, ...value }.
+ *
+ * @param {Object} object
+ * @param {String|String[]} path
+ * @param {Object|Function} value
+ * @return {Object}
+ */
+export function update(object, path, value) {
+  return typeof value === 'function'
+    ? _update(path, value, object)
+    : _update(path, (current) => ({ ...current, ...value }), object);
+}
+
+/**
+ * Removes the property at path of object.
+ *
+ * @param {Object} object
+ * @param {String|String[]} path
+ * @param {Object}
+ */
+export function unset(object, path) {
+  return _unset(path, object);
+}

package/src/state/reducers/viewers.js

@@ -0,0 +1,42 @@
+import set from 'lodash/fp/set';
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * viewersReducer
+ */
+export const viewersReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.UPDATE_VIEWPORT:
+      return {
+        ...state,
+        [action.windowId]: {
+          ...state[action.windowId],
+          ...action.payload,
+        },
+      };
+    case ActionTypes.ADD_WINDOW:
+      if (!action.window.initialViewerConfig) return state;
+
+      return {
+        ...state,
+        [action.window.id]: {
+          ...state[action.window.id],
+          ...action.window.initialViewerConfig,
+        },
+      };
+    case ActionTypes.REMOVE_WINDOW:
+      return omit(state, action.windowId);
+    case ActionTypes.SET_WINDOW_VIEW_TYPE:
+      return set([action.windowId], null, state);
+    case ActionTypes.SET_CANVAS:
+      if (!action.preserveViewport) {
+        return set([action.windowId], null, state);
+      }
+      return state;
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.viewers || {};
+    default:
+      return state;
+  }
+};