dbf-mirador 4.2.3

package/src/extend/PluginContext.js

@@ -0,0 +1,5 @@
+import { createContext } from 'react';
+
+const PluginContext = createContext();
+
+export default PluginContext;

package/src/extend/PluginProvider.jsx

@@ -0,0 +1,22 @@
+import { useEffect, useState } from 'react';
+import PropTypes from 'prop-types';
+import PluginContext from './PluginContext';
+import { connectPluginsToStore, createTargetToPluginMapping, addPluginsToCompanionWindowsRegistry } from './pluginMapping';
+
+/**  */
+export default function PluginProvider({ plugins = [], children = null }) {
+  const [pluginMap, setPluginMap] = useState({});
+
+  useEffect(() => {
+    const connectedPlugins = connectPluginsToStore(plugins);
+    addPluginsToCompanionWindowsRegistry(connectedPlugins);
+    setPluginMap(createTargetToPluginMapping(connectedPlugins));
+  }, [plugins]);
+
+  return <PluginContext.Provider value={pluginMap}>{children}</PluginContext.Provider>;
+}
+
+PluginProvider.propTypes = {
+  children: PropTypes.node,
+  plugins: PropTypes.array,
+};

package/src/extend/index.js

@@ -0,0 +1,9 @@
+import PluginContext from './PluginContext';
+import PluginProvider from './PluginProvider';
+
+export * from './pluginMapping';
+export * from './pluginPreprocessing';
+export * from './pluginValidation';
+
+export { PluginContext, PluginProvider };
+export * from './withPlugins';

package/src/extend/pluginMapping.js

@@ -0,0 +1,44 @@
+import update from 'lodash/update';
+import { connect } from 'react-redux';
+import CompanionWindowRegistry from '../lib/CompanionWindowRegistry';
+
+/**
+ * Returns a mapping from targets to plugins and modes
+ *
+ * @param {Array} plugins
+ * @return {Object} - looks like:
+ *
+ *  {
+ *    'WorkspacePanel': {
+ *      wrap:     [plugin3, ...],
+ *      add:      [plugin4, ...],
+ *    },
+ *    ...
+ *  }
+ */
+export function createTargetToPluginMapping(plugins) {
+  return plugins.reduce((map, plugin) => update(map, [plugin.target, plugin.mode], (x) => [...(x || []), plugin]), {});
+}
+
+/** */
+export function connectPluginsToStore(plugins) {
+  return plugins.map((plugin) => ({ ...plugin, component: connectPluginComponent(plugin) }));
+}
+
+/** */
+export function addPluginsToCompanionWindowsRegistry(plugins) {
+  plugins
+    .filter((p) => p.companionWindowKey)
+    .forEach((plugin) => {
+      CompanionWindowRegistry[plugin.companionWindowKey] = plugin.component;
+    });
+
+  return CompanionWindowRegistry;
+}
+
+/** Connect plugin component to state */
+function connectPluginComponent(plugin) {
+  if (!plugin.mapStateToProps && !plugin.mapDispatchToProps) return plugin.component;
+
+  return connect(plugin.mapStateToProps, plugin.mapDispatchToProps, ...(plugin.connectOptions || []))(plugin.component);
+}

package/src/extend/pluginPreprocessing.js

@@ -0,0 +1,45 @@
+import deepmerge from 'deepmerge';
+import { validatePlugin } from './pluginValidation';
+
+/** */
+export function filterValidPlugins(plugins) {
+  const { validPlugins, invalidPlugins } = splitPluginsByValidation(plugins);
+  logInvalidPlugins(invalidPlugins);
+  return validPlugins;
+}
+
+/** */
+function splitPluginsByValidation(plugins) {
+  const invalidPlugins = [];
+  const validPlugins = [];
+  plugins.forEach((plugin) => {
+    if (Array.isArray(plugin)) {
+      const allValid = plugin.every((p) => validatePlugin(p));
+
+      allValid ? validPlugins.push(...plugin) : invalidPlugins.push(...plugin);
+    } else {
+      validatePlugin(plugin) ? validPlugins.push(plugin) : invalidPlugins.push(plugin);
+    }
+  });
+  return { invalidPlugins, validPlugins };
+}
+
+/** */
+function logInvalidPlugins(plugins) {
+  plugins.forEach((plugin) => console.log(`Mirador: Plugin ${plugin.name} is not valid and was rejected.`));
+}
+
+/**  */
+export function getReducersFromPlugins(plugins) {
+  return plugins && plugins.reduce((acc, plugin) => ({ ...acc, ...plugin.reducers }), {});
+}
+
+/**  */
+export function getConfigFromPlugins(plugins) {
+  return plugins && plugins.reduce((acc, plugin) => deepmerge(acc, plugin.config || {}), {});
+}
+
+/**  */
+export function getSagasFromPlugins(plugins) {
+  return plugins && plugins.filter((plugin) => plugin.saga).map((plugin) => plugin.saga);
+}

package/src/extend/pluginValidation.js

@@ -0,0 +1,58 @@
+import isString from 'lodash/isString';
+import isUndefined from 'lodash/isUndefined';
+import isFunction from 'lodash/isFunction';
+import isObject from 'lodash/isObject';
+import isNull from 'lodash/isNull';
+import values from 'lodash/values';
+
+/** */
+export const validatePlugin = (plugin) =>
+  [checkPlugin, checkName, checkTarget, checkMode, checkMapStateToProps, checkMapDispatchToProps, checkReducers].every((check) =>
+    check(plugin),
+  );
+
+/** */
+const checkPlugin = (plugin) => isObject(plugin);
+
+/** */
+const checkName = (plugin) => {
+  const { name } = plugin;
+  return isUndefined(name) || isString(name);
+};
+
+/** */
+const checkTarget = (plugin) => {
+  const { mode, target } = plugin;
+  if (isUndefined(mode)) return isUndefined(target);
+
+  return isString(target);
+};
+
+/** */
+const checkMode = (plugin) => {
+  const { mode } = plugin;
+  return isUndefined(mode) || ['add', 'wrap'].some((s) => s === mode);
+};
+
+/** */
+const checkMapStateToProps = (plugin) => {
+  const { mapStateToProps } = plugin;
+  return isUndefined(mapStateToProps) || isNull(mapStateToProps) || isFunction(mapStateToProps);
+};
+
+/** */
+const checkMapDispatchToProps = (plugin) => {
+  const { mapDispatchToProps } = plugin;
+  return (
+    isUndefined(mapDispatchToProps) ||
+    isNull(mapDispatchToProps) ||
+    isFunction(mapDispatchToProps) ||
+    isObject(mapDispatchToProps)
+  );
+};
+
+/** */
+const checkReducers = (plugin) => {
+  const { reducers } = plugin;
+  return isUndefined(reducers) || (isObject(reducers) && values(reducers).every(isFunction));
+};

package/src/extend/usePlugins.js

@@ -0,0 +1,13 @@
+import { useContext } from 'react';
+import PluginContext from './PluginContext';
+
+/** withPlugins should be the innermost HOC */
+export function usePlugins(targetName) {
+  const pluginMap = useContext(PluginContext);
+
+  const plugins = (pluginMap || {})[targetName];
+
+  const PluginComponents = (plugins?.add || []).map((plugin) => plugin.component);
+
+  return { PluginComponents };
+}

package/src/extend/withPlugins.jsx

@@ -0,0 +1,46 @@
+import { forwardRef, useContext } from 'react';
+import curry from 'lodash/curry';
+import isEmpty from 'lodash/isEmpty';
+import PluginContext from './PluginContext';
+
+/** withPlugins should be the innermost HOC */
+function _withPlugins(targetName, TargetComponent) {
+  /** */
+  function PluginHoc(props, ref) {
+    const pluginMap = useContext(PluginContext);
+
+    const passDownProps = {
+      ...props,
+      ...(ref ? { ref } : {}),
+    };
+
+    const plugins = (pluginMap || {})[targetName];
+
+    if (isEmpty(plugins) || isEmpty(plugins.wrap)) {
+      return <TargetComponent {...passDownProps} />;
+    }
+
+    /** */
+    const pluginWrapper = (children, plugin) => {
+      const WrapPluginComponent = plugin.component;
+
+      return (
+        <WrapPluginComponent targetProps={passDownProps} {...passDownProps} TargetComponent={TargetComponent}>
+          {children}
+        </WrapPluginComponent>
+      );
+    };
+
+    return plugins.wrap
+      .slice()
+      .reverse()
+      .reduce(pluginWrapper, <TargetComponent {...passDownProps} />);
+  }
+  const whatever = forwardRef(PluginHoc);
+
+  whatever.displayName = `WithPlugins(${targetName})`;
+  return whatever;
+}
+
+/** withPlugins('MyComponent')(MyComponent) */
+export const withPlugins = curry(_withPlugins);

package/src/hooks/index.js

@@ -0,0 +1,4 @@
+import useCanvasWorldService from './useCanvasWorldService';
+import useThumbnailService from './useThumbnailService';
+
+export { useCanvasWorldService, useThumbnailService };

package/src/hooks/useCanvasWorldService.js

@@ -0,0 +1,10 @@
+import { useSelector } from 'react-redux';
+
+import CanvasWorld from '../lib/CanvasWorld';
+import { getMiradorCanvasWrapper } from '../state/selectors/wrappers';
+
+/** */
+export default function useCanvasWorldService() {
+  const getMiradorCanvas = useSelector(getMiradorCanvasWrapper);
+  return { get: (canvases) => canvases && new CanvasWorld(canvases.map(getMiradorCanvas)) };
+}

package/src/hooks/useThumbnailService.js

@@ -0,0 +1,8 @@
+import { useSelector } from 'react-redux';
+
+import { getThumbnailFactory } from '../state/selectors/thumbnails';
+
+/** */
+export default function useThumbnailService(maxHeight, maxWidth) {
+  return useSelector((state) => getThumbnailFactory(state, maxHeight, maxWidth), [maxHeight, maxWidth]);
+}

package/src/i18n.js

@@ -0,0 +1,71 @@
+import { createInstance } from 'i18next';
+import { initReactI18next } from 'react-i18next';
+import ar from './locales/ar/translation.json';
+import de from './locales/de/translation.json';
+import en from './locales/en/translation.json';
+import et from './locales/et/translation.json';
+import fa from './locales/fa/translation.json';
+import zhCn from './locales/zhCn/translation.json';
+import zhTw from './locales/zhTw/translation.json';
+import fr from './locales/fr/translation.json';
+import hr from './locales/hr/translation.json';
+import ja from './locales/ja/translation.json';
+import kr from './locales/kr/translation.json';
+import nl from './locales/nl/translation.json';
+import pl from './locales/pl/translation.json';
+import ptBr from './locales/ptBr/translation.json';
+import it from './locales/it/translation.json';
+import sr from './locales/sr/translation.json';
+import sv from './locales/sv/translation.json';
+import lt from './locales/lt/translation.json';
+import vi from './locales/vi/translation.json';
+import bg from './locales/bg/translation.json';
+import nbNo from './locales/nbNo/translation.json';
+import hu from './locales/hu/translation.json';
+import ta from './locales/ta/translation.json';
+
+/**
+ * Load translations for each language
+ */
+function createI18nInstance(i18nConfig = {}) {
+  const resources = {
+    ar,
+    bg,
+    de,
+    en,
+    et,
+    fa,
+    fr,
+    hr,
+    hu,
+    it,
+    ja,
+    kr,
+    lt,
+    'nb-NO': nbNo,
+    nl,
+    pl,
+    'pt-BR': ptBr,
+    sr,
+    sv,
+    vi,
+    'zh-CN': zhCn,
+    'zh-TW': zhTw,
+    ta,
+  };
+
+  const instance = createInstance();
+  instance.use(initReactI18next).init({
+    fallbackLng: 'en',
+    interpolation: {
+      escapeValue: false, // react is already safe from xss
+    },
+    lng: 'en',
+    resources,
+    ...i18nConfig,
+  });
+
+  return instance;
+}
+
+export default createI18nInstance;

package/src/index.js

@@ -0,0 +1,18 @@
+import init from './init';
+import state from './state';
+
+export * from './state';
+export * from './components';
+export * from './containers';
+export * from './contexts';
+export * from './extend';
+export * from './lib';
+export * from './plugins';
+export * from './config';
+export { useTranslation, withTranslation } from 'react-i18next';
+export { viewer } from './init';
+
+export default {
+  ...init,
+  ...state,
+};

package/src/init.js

@@ -0,0 +1,20 @@
+import MiradorViewer from './lib/MiradorViewer';
+
+/**
+ * Default Mirador instantiation
+ */
+export function viewer(config, pluginsOrStruct) {
+  let struct;
+
+  if (Array.isArray(pluginsOrStruct)) {
+    struct = { plugins: pluginsOrStruct };
+  } else {
+    struct = pluginsOrStruct;
+  }
+
+  return new MiradorViewer(config, struct);
+}
+
+export default {
+  viewer,
+};

package/src/lib/AnnotationFactory.js

@@ -0,0 +1,23 @@
+import AnnotationList from './AnnotationList';
+import AnnotationPage from './AnnotationPage';
+
+/**
+ * Used to determine the type of Annotation supported by a version of the IIIF
+ * Presentation API.
+ */
+export default class AnnotationFactory {
+  /** */
+  static determineAnnotation(json, target) {
+    if (!json) {
+      return null;
+    }
+
+    // IIIF Presentation API v3. AnnotationPage
+    if (json.type === 'AnnotationPage') {
+      return new AnnotationPage(json, target);
+    }
+
+    // IIIF Presentation API v2. OpenAnnotation and SharedCanvas models
+    return new AnnotationList(json, target);
+  }
+}

package/src/lib/AnnotationItem.js

@@ -0,0 +1,123 @@
+import compact from 'lodash/compact';
+import { v4 as uuid } from 'uuid';
+
+/**
+ * A modeled WebAnnotation item
+ */
+export default class AnnotationItem {
+  /** */
+  constructor(resource = {}) {
+    this.resource = resource;
+  }
+
+  /** */
+  isOnlyTag() {
+    return this.motivations.length === 1 && this.motivations[0] === 'tagging';
+  }
+
+  /** */
+  get id() {
+    this._id = this._id || this.resource.id || uuid();
+    return this._id;
+  }
+
+  /** */
+  get targetId() {
+    const target = this.target[0];
+    switch (typeof target) {
+      case 'string':
+        return target.replace(/#?xywh=(.*)$/, '');
+      case 'object':
+        return (target.source && target.source.id) || target.source || target.id;
+      default:
+        return null;
+    }
+  }
+
+  /**
+   * @return {[Array]}
+   */
+  get motivations() {
+    return compact(new Array(this.resource.motivation)).flat();
+  }
+
+  /** */
+  get body() {
+    return compact(new Array(this.resource.body)).flat();
+  }
+
+  /** */
+  get resources() {
+    return this.body;
+  }
+
+  /** */
+  get tags() {
+    if (this.isOnlyTag()) {
+      return this.body.map((r) => r.value);
+    }
+    return this.body.filter((r) => r.purpose === 'tagging').map((r) => r.value);
+  }
+
+  /** */
+  get target() {
+    return compact(new Array(this.resource.target)).flat();
+  }
+
+  /** */
+  get chars() {
+    if (this.isOnlyTag()) return null;
+    return this.body
+      .filter((r) => r.purpose !== 'tagging')
+      .map((r) => r.value)
+      .join(' ');
+  }
+
+  /** */
+  get selector() {
+    const target = this.target[0];
+    switch (typeof target) {
+      case 'string':
+        return target;
+      case 'object':
+        return compact(new Array(target.selector)).flat();
+      default:
+        return null;
+    }
+  }
+
+  /** */
+  get svgSelector() {
+    const { selector } = this;
+    switch (typeof selector) {
+      case 'string':
+        return null;
+      case 'object':
+        return selector.find((s) => s.type && s.type === 'SvgSelector');
+      default:
+        return null;
+    }
+  }
+
+  /** */
+  get fragmentSelector() {
+    const { selector } = this;
+
+    let match;
+    let fragmentSelector;
+
+    switch (typeof selector) {
+      case 'string':
+        match = selector.match(/xywh=(.*)$/);
+        break;
+      case 'object':
+        fragmentSelector = selector.find((s) => s.type && s.type === 'FragmentSelector');
+        match = fragmentSelector && fragmentSelector.value.match(/xywh=(.*)$/);
+        break;
+      default:
+        return null;
+    }
+
+    return match && match[1].split(',').map((str) => parseInt(str, 10));
+  }
+}

package/src/lib/AnnotationList.js

@@ -0,0 +1,31 @@
+import AnnotationResource from './AnnotationResource';
+/** */
+export default class AnnotationList {
+  /** */
+  constructor(json, target) {
+    this.json = json;
+    this.target = target;
+  }
+
+  /** */
+  get id() {
+    return this.json['@id'];
+  }
+
+  /** */
+  present() {
+    return this.resources && this.resources.length > 0;
+  }
+
+  /** */
+  get resources() {
+    this._resources =
+      this._resources ||
+      (() => {
+        if (!this.json || !this.json.resources) return [];
+
+        return [this.json.resources].flat().map((resource) => new AnnotationResource(resource));
+      })();
+    return this._resources;
+  }
+}

package/src/lib/AnnotationPage.js

@@ -0,0 +1,41 @@
+import AnnotationItem from './AnnotationItem';
+/**
+ * Annotation representation for IIIF Presentation v3
+ * https://iiif.io/api/presentation/3.0/#55-annotation-page
+ */
+export default class AnnotationPage {
+  /** */
+  constructor(json, target) {
+    this.json = json;
+    this.target = target;
+  }
+
+  /** */
+  get id() {
+    return this.json.id;
+  }
+
+  /** */
+  present() {
+    return this.items && this.items.length > 0;
+  }
+
+  /** */
+  get items() {
+    this._items =
+      this._items ||
+      (() => {
+        if (!this.json || !this.json.items) return [];
+
+        return [this.json.items].flat().map((resource) => new AnnotationItem(resource));
+      })();
+    return this._items;
+  }
+
+  /**
+   * Alias to items for compatibility for right now.
+   */
+  get resources() {
+    return this.items;
+  }
+}