dbf-mirador 4.2.3

package/src/state/actions/search.js

@@ -0,0 +1,97 @@
+import ActionTypes from './action-types';
+
+/**
+ * requestSearch - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} searchId
+ * @param  {String} query
+ * @memberof ActionCreators
+ */
+export function requestSearch(windowId, companionWindowId, searchId, query) {
+  return {
+    companionWindowId,
+    query,
+    searchId,
+    type: ActionTypes.REQUEST_SEARCH,
+    windowId,
+  };
+}
+
+/**
+ * receiveSearch - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} searchId
+ * @param  {Object} searchJson
+ * @memberof ActionCreators
+ */
+export function receiveSearch(windowId, companionWindowId, searchId, searchJson) {
+  return {
+    companionWindowId,
+    searchId,
+    searchJson,
+    type: ActionTypes.RECEIVE_SEARCH,
+    windowId,
+  };
+}
+
+/**
+ * receiveSearchFailure - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} searchId
+ * @param  {String} error
+ * @memberof ActionCreators
+ */
+export function receiveSearchFailure(windowId, companionWindowId, searchId, error) {
+  return {
+    companionWindowId,
+    error,
+    searchId,
+    type: ActionTypes.RECEIVE_SEARCH_FAILURE,
+    windowId,
+  };
+}
+
+/**
+ * removeSearch - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} companionWindowId
+ * @memberof ActionCreators
+ */
+export function removeSearch(windowId, companionWindowId) {
+  return {
+    companionWindowId,
+    type: ActionTypes.REMOVE_SEARCH,
+    windowId,
+  };
+}
+
+/**
+ * fetchSearch - action creator
+ *
+ * @param  {String} searchId
+ * @param  {String} query
+ * @memberof ActionCreators
+ */
+export function fetchSearch(windowId, companionWindowId, searchId, query) {
+  return requestSearch(windowId, companionWindowId, searchId, query);
+}
+
+/**
+ * setContentSearchCurrentAnnotation - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} annotationId
+ * @memberof ActionCreators
+ */
+export function setContentSearchCurrentAnnotation(windowId, companionWindowId, annotationIds) {
+  return {
+    annotationIds,
+    companionWindowId,
+    type: ActionTypes.SET_CONTENT_SEARCH_CURRENT_ANNOTATIONS,
+    windowId,
+  };
+}

package/src/state/actions/window.js

@@ -0,0 +1,209 @@
+import { v4 as uuid } from 'uuid';
+import ActionTypes from './action-types';
+import { miradorSlice } from '../selectors/utils';
+
+/**
+ * focusWindow - action creator
+ *
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function focusWindow(windowId, pan = false) {
+  return {
+    pan,
+    type: ActionTypes.FOCUS_WINDOW,
+    windowId,
+  };
+}
+
+/**
+ * addWindow - action creator
+ *
+ * @param  {Object} options
+ * @memberof ActionCreators
+ */
+export function addWindow({ companionWindows, manifest, ...options }) {
+  return (dispatch, getState) => {
+    const {
+      config,
+      workspace: { windowIds = [] },
+    } = miradorSlice(getState());
+    const numWindows = windowIds.length;
+
+    const windowId = options.id || `window-${uuid()}`;
+    const cwThumbs = `cw-${uuid()}`;
+
+    const defaultCompanionWindows = [
+      {
+        content: 'thumbnailNavigation',
+        default: true,
+        id: cwThumbs,
+        position: options.thumbnailNavigationPosition || config.thumbnailNavigation.defaultPosition,
+        windowId,
+      },
+      ...(companionWindows || []).map((cw, i) => ({ ...cw, id: `cw-${uuid()}` })),
+    ];
+
+    if (options.sideBarPanel || config.window.defaultSideBarPanel || config.window.sideBarPanel) {
+      defaultCompanionWindows.unshift({
+        content:
+          options.sideBarPanel ||
+          (options.defaultSearchQuery && 'search') ||
+          config.window.defaultSideBarPanel ||
+          config.window.sideBarPanel,
+
+        default: true,
+        id: `cw-${uuid()}`,
+        position: 'left',
+        windowId,
+      });
+    }
+
+    const defaultOptions = {
+      canvasId: undefined,
+      collectionIndex: 0,
+      companionAreaOpen: true,
+      companionWindowIds: defaultCompanionWindows.map((cw) => cw.id),
+      draggingEnabled: true,
+      highlightAllAnnotations: config.window.highlightAllAnnotations || false,
+      id: windowId,
+      manifestId: null,
+      maximized: false,
+      rangeId: null,
+      rotation: null,
+      selectedAnnotations: {},
+      sideBarOpen:
+        config.window.sideBarOpenByDefault !== undefined
+          ? config.window.sideBarOpenByDefault || !!options.defaultSearchQuery
+          : config.window.sideBarOpen || !!options.defaultSearchQuery,
+      sideBarPanel: options.sideBarPanel || config.window.defaultSideBarPanel || config.window.sideBarPanel,
+      thumbnailNavigationId: cwThumbs,
+    };
+
+    const elasticLayout = {
+      ...(config.window.elastic || { height: 400, width: 480 }),
+      x: 200 + (Math.floor(numWindows / 10) * 50 + ((numWindows * 30) % 300)),
+      y: 200 + ((numWindows * 50) % 300),
+    };
+
+    dispatch({
+      companionWindows: defaultCompanionWindows,
+      elasticLayout,
+      manifest,
+      type: ActionTypes.ADD_WINDOW,
+      window: { ...defaultOptions, ...options },
+    });
+  };
+}
+
+/** */
+export function updateWindow(id, payload) {
+  return {
+    id,
+    payload,
+    type: ActionTypes.UPDATE_WINDOW,
+  };
+}
+
+/**
+ * maximizeWindow
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function maximizeWindow(windowId) {
+  return { type: ActionTypes.MAXIMIZE_WINDOW, windowId };
+}
+
+/**
+ * minimizeWindow
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function minimizeWindow(windowId) {
+  return { type: ActionTypes.MINIMIZE_WINDOW, windowId };
+}
+
+/** */
+export function setCompanionAreaOpen(id, companionAreaOpen) {
+  return {
+    id,
+    payload: { companionAreaOpen },
+    type: ActionTypes.UPDATE_WINDOW,
+  };
+}
+
+/**
+ * removeWindow - action creator
+ *
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function removeWindow(windowId) {
+  return {
+    type: ActionTypes.REMOVE_WINDOW,
+    windowId,
+  };
+}
+
+/**
+ * toggleWindowSideBar - action creator
+ *
+ * @param  {String} windowId
+ * @memberof ActionCreators
+ */
+export function toggleWindowSideBar(windowId) {
+  return { type: ActionTypes.TOGGLE_WINDOW_SIDE_BAR, windowId };
+}
+
+/**
+ * setWindowThumbnailPosition - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} position
+ * @memberof ActionCreators
+ */
+export function setWindowThumbnailPosition(windowId, position) {
+  return (dispatch, getState) => {
+    const { windows } = getState();
+    const { thumbnailNavigationId } = windows[windowId];
+
+    dispatch({
+      id: thumbnailNavigationId,
+      payload: { position },
+      type: ActionTypes.UPDATE_COMPANION_WINDOW,
+    });
+  };
+}
+
+/**
+ * setWindowViewType - action creator
+ *
+ * @param  {String} windowId
+ * @param  {String} viewType
+ * @memberof ActionCreators
+ */
+export function setWindowViewType(windowId, viewType) {
+  return {
+    type: ActionTypes.SET_WINDOW_VIEW_TYPE,
+    viewType,
+    windowId,
+  };
+}
+
+/** */
+export function showCollectionDialog(manifestId, dialogCollectionPath = [], windowId) {
+  return {
+    dialogCollectionPath,
+    manifestId,
+    type: ActionTypes.SHOW_COLLECTION_DIALOG,
+    windowId,
+  };
+}
+
+/** */
+export function hideCollectionDialog(windowId) {
+  return {
+    type: ActionTypes.HIDE_COLLECTION_DIALOG,
+    windowId,
+  };
+}

package/src/state/actions/workspace.js

@@ -0,0 +1,84 @@
+import ActionTypes from './action-types';
+
+/**
+ * updateWorkspace - action creator
+ *
+ * @param {Object} config
+ */
+export function updateWorkspace(config) {
+  return { config, type: ActionTypes.UPDATE_WORKSPACE };
+}
+
+/**
+ * toggleZoomControls - action creator
+ * @param {Boolean} showZoomControls
+ * @memberof ActionCreators
+ */
+export function toggleZoomControls(showZoomControls) {
+  return { showZoomControls, type: ActionTypes.TOGGLE_ZOOM_CONTROLS };
+}
+
+/**
+ * updateWorkspaceMosaicLayout - action creator
+ *
+ * @param  {Object} layout
+ * @memberof ActionCreators
+ */
+export function updateWorkspaceMosaicLayout(layout) {
+  return { layout, type: ActionTypes.UPDATE_WORKSPACE_MOSAIC_LAYOUT };
+}
+
+/**
+ * updateWorkspaceMosaicLayout - action creator
+ *
+ * @param  {Object} isWorkspaceAddVisible
+ * @memberof ActionCreators
+ */
+export function setWorkspaceAddVisibility(isWorkspaceAddVisible) {
+  return { isWorkspaceAddVisible, type: ActionTypes.SET_WORKSPACE_ADD_VISIBILITY };
+}
+
+/**
+ * setWorkspaceViewportPosition - action creator
+ *
+ * @param  {Object} position
+ * @memberof ActionCreators
+ */
+export function setWorkspaceViewportPosition({ x, y }) {
+  return {
+    payload: {
+      position: {
+        x,
+        y,
+      },
+    },
+    type: ActionTypes.SET_WORKSPACE_VIEWPORT_POSITION,
+  };
+}
+
+/**
+ * setWorkspaceViewportDimensions - action creator
+ *
+ * @param  {Object} position
+ * @memberof ActionCreators
+ */
+export function setWorkspaceViewportDimensions({ width, height }) {
+  return {
+    payload: {
+      position: {
+        height,
+        width,
+      },
+    },
+    type: ActionTypes.SET_WORKSPACE_VIEWPORT_POSITION,
+  };
+}
+
+/**
+ * toggleDraggingEnabled - action creator
+ */
+export function toggleDraggingEnabled() {
+  return {
+    type: ActionTypes.TOGGLE_DRAGGING,
+  };
+}

package/src/state/createPluggableStore.js

@@ -0,0 +1,24 @@
+import deepmerge from 'deepmerge';
+import createStore from './createStore';
+import { importConfig } from './actions/config';
+import {
+  filterValidPlugins,
+  getConfigFromPlugins,
+  getReducersFromPlugins,
+  getSagasFromPlugins,
+} from '../extend/pluginPreprocessing';
+
+/**
+ * Configure Store
+ */
+function createPluggableStore(config, plugins = []) {
+  const filteredPlugins = filterValidPlugins(plugins);
+
+  const store = createStore(getReducersFromPlugins(filteredPlugins), getSagasFromPlugins(filteredPlugins));
+
+  store.dispatch(importConfig(deepmerge(getConfigFromPlugins(filteredPlugins), config)));
+
+  return store;
+}
+
+export default createPluggableStore;

package/src/state/createStore.js

@@ -0,0 +1,33 @@
+// Topics for understanding
+// redux modules for nested stores
+// state normalisation
+// (normalizer library)
+
+import { thunk } from 'redux-thunk';
+import createSagaMiddleware from 'redux-saga';
+import { combineReducers, createStore, applyMiddleware } from 'redux';
+import { composeWithDevTools } from '@redux-devtools/extension';
+import createRootReducer from './reducers/rootReducer';
+import getRootSaga from './sagas';
+import settings from '../config/settings';
+
+/**
+ * Configure Store
+ */
+function configureStore(pluginReducers, pluginSagas = []) {
+  const miradorReducer = createRootReducer(pluginReducers);
+
+  const rootReducer = settings.state.slice ? combineReducers({ [settings.state.slice]: miradorReducer }) : miradorReducer;
+
+  // create the saga middleware
+  const sagaMiddleware = createSagaMiddleware();
+
+  const store = createStore(rootReducer, composeWithDevTools(applyMiddleware(thunk, sagaMiddleware)));
+
+  // then run the saga
+  sagaMiddleware.run(getRootSaga(pluginSagas));
+
+  return store;
+}
+
+export default configureStore;

package/src/state/index.js

@@ -0,0 +1,21 @@
+import * as actions from './actions';
+import * as reducers from './reducers';
+import * as sagas from './sagas';
+import * as selectors from './selectors';
+import createStore from './createStore';
+
+export default {
+  actions,
+  createStore,
+  reducers,
+  sagas,
+  selectors,
+};
+
+export * from './actions';
+export * from './reducers';
+export { default as rootReducer } from './reducers/rootReducer';
+export { default as rootSaga } from './sagas';
+export * from './selectors';
+export { default as createStore } from './createStore';
+export { default as createPluggableStore } from './createPluggableStore';

package/src/state/reducers/accessTokens.js

@@ -0,0 +1,59 @@
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/** */
+export function accessTokensReducer(state = {}, action) {
+  switch (action.type) {
+    case ActionTypes.RESOLVE_AUTHENTICATION_REQUEST:
+      return {
+        ...state,
+        [action.tokenServiceId]: {
+          authId: action.id,
+          id: action.tokenServiceId,
+          isFetching: true,
+        },
+      };
+    case ActionTypes.REQUEST_ACCESS_TOKEN:
+      return {
+        ...state,
+        [action.serviceId]: {
+          authId: action.authId,
+          id: action.serviceId,
+          isFetching: true,
+        },
+      };
+    case ActionTypes.RECEIVE_ACCESS_TOKEN:
+      return {
+        ...state,
+        [action.serviceId]: {
+          ...state[action.serviceId],
+          isFetching: false,
+          json: action.json,
+        },
+      };
+    case ActionTypes.RECEIVE_ACCESS_TOKEN_FAILURE:
+      return {
+        ...state,
+        [action.serviceId]: {
+          ...state[action.serviceId],
+          error: action.error,
+          isFetching: false,
+        },
+      };
+    case ActionTypes.RESET_AUTHENTICATION_STATE:
+      return omit(state, action.tokenServiceId);
+    case ActionTypes.RECEIVE_INFO_RESPONSE:
+      if (!action.tokenServiceId) return state;
+      if (state[action.tokenServiceId].success) return state;
+
+      return {
+        ...state,
+        [action.tokenServiceId]: {
+          ...state[action.tokenServiceId],
+          success: true,
+        },
+      };
+    default:
+      return state;
+  }
+}

package/src/state/reducers/annotations.js

@@ -0,0 +1,48 @@
+import ActionTypes from '../actions/action-types';
+
+/**
+ * annotationReducer
+ */
+export const annotationsReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.REQUEST_ANNOTATION:
+      return {
+        ...state,
+        [action.targetId]: {
+          ...state[action.targetId],
+          [action.annotationId]: {
+            id: action.annotationId,
+            isFetching: true,
+          },
+        },
+      };
+    case ActionTypes.RECEIVE_ANNOTATION:
+      return {
+        ...state,
+        [action.targetId]: {
+          ...state[action.targetId],
+          [action.annotationId]: {
+            id: action.annotationId,
+            isFetching: false,
+            json: action.annotationJson,
+          },
+        },
+      };
+    case ActionTypes.RECEIVE_ANNOTATION_FAILURE:
+      return {
+        ...state,
+        [action.targetId]: {
+          ...state[action.targetId],
+          [action.annotationId]: {
+            error: action.error,
+            id: action.annotationId,
+            isFetching: false,
+          },
+        },
+      };
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return {};
+    default:
+      return state;
+  }
+};

package/src/state/reducers/auth.js

@@ -0,0 +1,43 @@
+import omit from 'lodash/omit';
+import ActionTypes from '../actions/action-types';
+
+/**
+ * authReducer
+ */
+export const authReducer = (state = {}, action) => {
+  switch (action.type) {
+    case ActionTypes.ADD_AUTHENTICATION_REQUEST:
+      return {
+        ...state,
+        [action.id]: {
+          id: action.id,
+          isFetching: true,
+          profile: action.profile,
+          windowId: action.windowId,
+        },
+      };
+    case ActionTypes.RESOLVE_AUTHENTICATION_REQUEST:
+      return {
+        ...state,
+        [action.id]: {
+          ...state[action.id],
+          isFetching: false,
+          ok: action.ok,
+        },
+      };
+    case ActionTypes.RECEIVE_ACCESS_TOKEN:
+      if (!action.authId) return state;
+
+      return {
+        ...state,
+        [action.authId]: {
+          ...state[action.authId],
+          ok: true,
+        },
+      };
+    case ActionTypes.RESET_AUTHENTICATION_STATE:
+      return omit(state, action.id);
+    default:
+      return state;
+  }
+};

package/src/state/reducers/catalog.js

@@ -0,0 +1,30 @@
+import ActionTypes from '../actions/action-types';
+
+/**
+ * catalogReducer
+ */
+export const catalogReducer = (state = [], action) => {
+  switch (action.type) {
+    case ActionTypes.ADD_RESOURCE:
+      if (state.some((m) => m.manifestId === action.manifestId)) return state;
+
+      return [{ manifestId: action.manifestId, ...action.payload }, ...state];
+    case ActionTypes.ADD_WINDOW:
+      if (state.some((m) => m.manifestId === action.window.manifestId)) return state;
+
+      return [{ manifestId: action.window.manifestId }, ...state];
+    case ActionTypes.UPDATE_WINDOW:
+      if (!action.payload.manifestId) return state;
+      if (state.some((m) => m.manifestId === action.payload.manifestId)) return state;
+
+      return [{ manifestId: action.payload.manifestId }, ...state];
+    case ActionTypes.REMOVE_RESOURCE:
+      return state.filter((r) => r.manifestId !== action.manifestId);
+    case ActionTypes.IMPORT_CONFIG:
+      return action.config.catalog || [];
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.catalog || [];
+    default:
+      return state;
+  }
+};

package/src/state/reducers/companionWindows.js

@@ -0,0 +1,49 @@
+import omit from 'lodash/omit';
+import set from 'lodash/fp/set';
+import update from 'lodash/fp/update';
+import ActionTypes from '../actions/action-types';
+
+/** */
+export function companionWindowsReducer(state = {}, action) {
+  switch (action.type) {
+    case ActionTypes.ADD_COMPANION_WINDOW:
+      return set([action.id], action.payload, state);
+
+    case ActionTypes.ADD_WINDOW:
+      return {
+        ...state,
+        ...(action.companionWindows || []).reduce((newState, cw) => {
+          // eslint-disable-next-line no-param-reassign
+          newState[cw.id] = {
+            ...state[cw.id],
+            ...cw,
+            windowId: action.id,
+          };
+          return newState;
+        }, {}),
+      };
+
+    case ActionTypes.REMOVE_WINDOW:
+      return Object.keys(state).reduce((object, key) => {
+        if (state[key].windowId !== action.windowId) {
+          // eslint-disable-next-line no-param-reassign
+          object[key] = state[key];
+        }
+        return object;
+      }, {});
+
+    case ActionTypes.UPDATE_COMPANION_WINDOW:
+      return update([action.id], (orig) => ({ ...(orig || {}), ...action.payload }), state);
+
+    case ActionTypes.REMOVE_COMPANION_WINDOW:
+      return omit(state, action.id);
+
+    case ActionTypes.IMPORT_MIRADOR_STATE:
+      return action.state.companionWindows || [];
+
+    case ActionTypes.TOGGLE_TOC_NODE:
+      return update([action.id, 'tocNodes'], (orig) => ({ ...(orig || {}), ...action.payload }), state);
+    default:
+      return state;
+  }
+}