mirador-annotation-editor-video 1.1.5 → 1.1.6

package/es/plugins/annotationCreationCompanionWindow.js

@@ -10,10 +10,9 @@ var _canvases = require("mirador/dist/es/src/state/selectors/canvases");
 var _annotations = require("mirador/dist/es/src/state/selectors/annotations");
 var _OSDReferences = require("mirador/dist/es/src/plugins/OSDReferences");
 var _VideosReferences = require("mirador/dist/es/src/plugins/VideosReferences");
-var _reactI18next = require("react-i18next");
-var _AnnotationForm = _interopRequireDefault(require("../annotationForm/AnnotationForm"));
 var _playerReferences = require("../playerReferences");
 var _AnnotationFormUtils = require("../annotationForm/AnnotationFormUtils");
+var _AnnotationForm = _interopRequireDefault(require("../annotationForm/AnnotationForm"));
 var _locales = _interopRequireDefault(require("../locales/locales"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
@@ -77,12 +76,10 @@ function mapStateToProps(state, {
     playerReferences
   };
 }
-const AnnotationFormWithTranslation = (0, _reactI18next.withTranslation)()(_AnnotationForm.default);
-
-// eslint-disable-next-line import/no-anonymous-default-export
-var _default = exports.default = {
+const annotationCreationCompanionWindowPlugin = {
   companionWindowKey: 'annotationCreation',
-  component: AnnotationFormWithTranslation,
+  component: _AnnotationForm.default,
   mapDispatchToProps,
   mapStateToProps
-};
+};
+var _default = exports.default = annotationCreationCompanionWindowPlugin;

package/es/plugins/annotationSaga.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _effects = require("redux-saga/effects");
+var _actions = require("mirador/dist/es/src/state/actions");
+var _actionTypes = _interopRequireDefault(require("mirador/dist/es/src/state/actions/action-types"));
+var _selectors = require("mirador/dist/es/src/state/selectors");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** Retrieves all the annotations available in the annotation adapter */
+function* retrieveAnnotationsFormStore(canvasId) {
+  const config = yield (0, _effects.select)(_selectors.getConfig);
+  if (config && config.annotation.adapter) {
+    const storageAdapter = config.annotation.adapter(canvasId);
+    const annoPage = yield (0, _effects.call)([storageAdapter, storageAdapter.all]);
+    if (annoPage) {
+      yield (0, _effects.put)((0, _actions.receiveAnnotation)(canvasId, storageAdapter.annotationPageId, annoPage));
+    }
+  }
+}
+
+/**
+ * A generator function which takesEvery SET_CANVAS mirador action
+ * and fetches the associated annotations from the store.
+ */
+function* setAnnotations(action) {
+  const {
+    canvasId
+  } = action;
+  yield (0, _effects.call)(retrieveAnnotationsFormStore, canvasId);
+}
+
+/** Annotation saga for setting inital annotations */
+function* annotationSaga() {
+  yield (0, _effects.all)([(0, _effects.takeEvery)(_actionTypes.default.SET_CANVAS, setAnnotations)]);
+}
+const annotationSagaPlugin = {
+  mode: 'wrap',
+  saga: annotationSaga,
+  target: 'Window'
+};
+var _default = exports.default = annotationSagaPlugin;

package/es/plugins/canvasAnnotationsPlugin.js

@@ -14,11 +14,23 @@ var _CanvasListItem = _interopRequireDefault(require("../CanvasListItem"));
 var _AnnotationActionsContext = _interopRequireDefault(require("../AnnotationActionsContext"));
 var _SingleCanvasDialog = _interopRequireDefault(require("../SingleCanvasDialog"));
 var _locales = _interopRequireDefault(require("../locales/locales"));
+var _canvasAnnotationsPluginUtils = require("./canvasAnnotationsPluginUtils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-/** Functional Component */
+/**
+ * CanvasAnnotationsWrapper
+ *
+ * Re-implements "scroll to selected annotation" inside the wrapper:
+ * - Observes selectedAnnotationId and scrolls the correct container so the <li> is visible.
+ * - Robust container resolution (ancestor/descendant/window).
+ * - Retries to survive focus/reflow resetting scrollTop.
+ *
+ * Props of interest:
+ * - targetProps.selectedAnnotationId: the currently selected annotation id.
+ * - scrollOffsetTop: px reserved for sticky header inside the scroller (default 96).
+ * - scrollRetries / scrollRetryDelay / scrollBehavior: tuning for robustness.
+ */
 function CanvasAnnotationsWrapper({
   addCompanionWindow,
   annotationsOnCanvases = {},
@@ -29,37 +41,56 @@ function CanvasAnnotationsWrapper({
   TargetComponent,
   targetProps,
   windowViewType,
-  containerRef,
   annotationEditCompanionWindowIsOpened,
   t
 }) {
   const [singleCanvasDialogOpen, setSingleCanvasDialogOpen] = (0, _react.useState)(false);
-
-  /** */
-  const toggleSingleCanvasDialogOpen = () => {
-    setSingleCanvasDialogOpen(prev => !prev);
-  };
+  const wrapperRef = (0, _react.useRef)(null);
+  const bridgedScrollRef = (0, _react.useRef)(null);
+  (0, _react.useEffect)(() => {
+    const selId = targetProps?.selectedAnnotationId;
+    if (!selId) return;
+    const node = wrapperRef.current?.querySelector(`li[annotationid="${selId}"]`) || wrapperRef.current?.querySelector('li.MuiMenuItem-root.Mui-selected');
+    if (!node) return;
+    (0, _canvasAnnotationsPluginUtils.scrollToSelectedAnnotation)(node, bridgedScrollRef);
+  }, [targetProps?.selectedAnnotationId]);
+  /**
+     * Toggle the visibility state of the single canvas dialog.
+     *
+     * - Flips `singleCanvasDialogOpen` between `true` and `false`.
+     * - Used as the `handleClose` callback for the dialog and to open it.
+     *
+     * @function
+     * @returns {void}
+     */
+  const toggleSingleCanvasDialogOpen = (0, _react.useCallback)(() => setSingleCanvasDialogOpen(p => !p), []);
   const props = {
+    containerRef: bridgedScrollRef,
     ...targetProps,
     listContainerComponent: _CanvasListItem.default
   };
+  const contextValue = (0, _react.useMemo)(() => ({
+    addCompanionWindow,
+    annotationEditCompanionWindowIsOpened,
+    annotationsOnCanvases,
+    canvases,
+    config,
+    receiveAnnotation,
+    storageAdapter: config.annotation.adapter,
+    t,
+    toggleSingleCanvasDialogOpen,
+    windowId: targetProps.windowId,
+    windowViewType
+  }), [addCompanionWindow, annotationEditCompanionWindowIsOpened, annotationsOnCanvases, canvases, config, receiveAnnotation, t, toggleSingleCanvasDialogOpen, targetProps.windowId, windowViewType]);
   return /*#__PURE__*/_react.default.createElement(_AnnotationActionsContext.default.Provider, {
-    value: {
-      addCompanionWindow,
-      annotationEditCompanionWindowIsOpened,
-      annotationsOnCanvases,
-      canvases,
-      config,
-      receiveAnnotation,
-      storageAdapter: config.annotation.adapter,
-      toggleSingleCanvasDialogOpen,
-      windowId: targetProps.windowId,
-      windowViewType,
-      t
+    value: contextValue
+  }, /*#__PURE__*/_react.default.createElement("div", {
+    ref: wrapperRef,
+    style: {
+      height: '100%',
+      position: 'relative'
     }
-  }, /*#__PURE__*/_react.default.createElement(TargetComponent, _extends({}, props, {
-    ref: containerRef
-  })), windowViewType !== 'single' && /*#__PURE__*/_react.default.createElement(_SingleCanvasDialog.default, {
+  }, /*#__PURE__*/_react.default.createElement(TargetComponent, props)), windowViewType !== 'single' && /*#__PURE__*/_react.default.createElement(_SingleCanvasDialog.default, {
     handleClose: toggleSingleCanvasDialogOpen,
     open: singleCanvasDialogOpen,
     switchToSingleCanvasView: switchToSingleCanvasView
@@ -68,27 +99,8 @@ function CanvasAnnotationsWrapper({
 CanvasAnnotationsWrapper.propTypes = {
   addCompanionWindow: _propTypes.default.func.isRequired,
   annotationEditCompanionWindowIsOpened: _propTypes.default.bool.isRequired,
-  annotationsOnCanvases: _propTypes.default.shape({
-    id: _propTypes.default.string,
-    isFetching: _propTypes.default.bool,
-    json: _propTypes.default.shape({
-      id: _propTypes.default.string,
-      items: _propTypes.default.arrayOf(_propTypes.default.shape({
-        body: _propTypes.default.shape({
-          format: _propTypes.default.string,
-          id: _propTypes.default.string,
-          value: _propTypes.default.string
-        }),
-        drawingState: _propTypes.default.string,
-        id: _propTypes.default.string,
-        manifestNetwork: _propTypes.default.string,
-        motivation: _propTypes.default.string,
-        target: _propTypes.default.string,
-        type: _propTypes.default.string
-      })),
-      type: _propTypes.default.string
-    })
-  }).isRequired,
+  annotationsOnCanvases: _propTypes.default.shape({}).isRequired,
+  // eslint-disable-next-line max-len
   canvases: _propTypes.default.arrayOf(_propTypes.default.shape({
     id: _propTypes.default.string,
     index: _propTypes.default.number
@@ -98,9 +110,6 @@ CanvasAnnotationsWrapper.propTypes = {
       adapter: _propTypes.default.func
     })
   }).isRequired,
-  containerRef: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.shape({
-    current: _propTypes.default.instanceOf(Element)
-  })]),
   receiveAnnotation: _propTypes.default.func.isRequired,
   switchToSingleCanvasView: _propTypes.default.func.isRequired,
   t: _propTypes.default.func.isRequired,
@@ -110,7 +119,7 @@ CanvasAnnotationsWrapper.propTypes = {
   windowViewType: _propTypes.default.string.isRequired
 };
 
-/** TODO this logic is duplicated */
+/** mapStateToProps / mapDispatchToProps unchanged from your version */
 function mapStateToProps(state, {
   targetProps: {
     windowId
@@ -120,19 +129,14 @@ function mapStateToProps(state, {
     windowId
   });
   const annotationsOnCanvases = {};
-  const annotationCreationCompanionWindows = (0, _companionWindows.getCompanionWindowsForContent)(state, {
+  const creation = (0, _companionWindows.getCompanionWindowsForContent)(state, {
     content: 'annotationCreation',
     windowId
   });
-  let annotationEditCompanionWindowIsOpened = true;
-  if (Object.keys(annotationCreationCompanionWindows).length !== 0) {
-    annotationEditCompanionWindowIsOpened = false;
-  }
+  const annotationEditCompanionWindowIsOpened = Object.keys(creation).length === 0;
   canvases.forEach(canvas => {
     const anno = state.annotations[canvas.id];
-    if (anno) {
-      annotationsOnCanvases[canvas.id] = anno;
-    }
+    if (anno) annotationsOnCanvases[canvas.id] = anno;
   });
   return {
     annotationEditCompanionWindowIsOpened,
@@ -147,9 +151,30 @@ function mapStateToProps(state, {
     })
   };
 }
-
-/** */
-const mapDispatchToProps = (dispatch, props, annotationEditCompanionWindowIsOpened) => ({
+/**
+ * Map Redux dispatch actions to props for the CanvasAnnotationsWrapper.
+ *
+ * Provides callback props that allow the wrapped component to interact
+ * with the Mirador Redux store, including:
+ *
+ * - `addCompanionWindow`: Open a companion window for the given window ID,
+ *   with specified content and optional extra props.
+ * - `receiveAnnotation`: Add or update an annotation in the Redux store
+ *   for a specific target.
+ * - `switchToSingleCanvasView`: Change the current window's view type
+ *   to `"single"`.
+ *
+ * @function
+ * @param {Function} dispatch - Redux dispatch function.
+ * @param {object} props - The wrapper component props.
+ * @param {object} props.targetProps - Props passed down to the wrapped target component.
+ * @param {string} props.targetProps.windowId - The ID of the Mirador window.
+ * @returns {object} An object mapping action dispatchers to props.
+ * @property {function(string, object):void} addCompanionWindow
+ * @property {function(string, string, object):void} receiveAnnotation
+ * @property {function():void} switchToSingleCanvasView
+ */
+const mapDispatchToProps = (dispatch, props) => ({
   addCompanionWindow: (content, additionalProps) => dispatch(actions.addCompanionWindow(props.targetProps.windowId, {
     content,
     ...additionalProps
@@ -157,11 +182,11 @@ const mapDispatchToProps = (dispatch, props, annotationEditCompanionWindowIsOpen
   receiveAnnotation: (targetId, id, annotation) => dispatch(actions.receiveAnnotation(targetId, id, annotation)),
   switchToSingleCanvasView: () => dispatch(actions.setWindowViewType(props.targetProps.windowId, 'single'))
 });
-const CanvasAnnotationsWrapperContainer = {
+const canvasAnnotationsPlugin = {
   component: CanvasAnnotationsWrapper,
   mapDispatchToProps,
   mapStateToProps,
   mode: 'wrap',
   target: 'CanvasAnnotations'
 };
-var _default = exports.default = CanvasAnnotationsWrapperContainer;
+var _default = exports.default = canvasAnnotationsPlugin;

package/es/plugins/canvasAnnotationsPluginUtils.js

@@ -0,0 +1,202 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.closestScrollableAncestor = void 0;
+exports.computeTargetContainer = computeTargetContainer;
+exports.computeTargetWindow = computeTargetWindow;
+exports.scrollToSelectedAnnotation = exports.runScrollOnce = exports.isScrollable = exports.getWindowScroller = void 0;
+/**
+ * Utilities
+ */
+const isScrollable = el => {
+  if (!el) return false;
+  const cs = getComputedStyle(el);
+  const oy = cs.overflowY || cs.overflow || '';
+  return /(auto|scroll|overlay)/.test(oy) && el.scrollHeight > el.clientHeight;
+};
+
+/**
+ * Find the closest scrollable ancestor of a given DOM node.
+ *
+ * - Walks up the DOM tree from the node's parent using `parentElement`.
+ * - Returns the first ancestor element that is considered scrollable,
+ *   meaning:
+ *   - Its `overflowY` (or `overflow`) style is `auto`, `scroll`, or `overlay`,
+ *   - And its `scrollHeight` is greater than its `clientHeight`.
+ * - Returns `null` if no scrollable ancestor is found before reaching the root.
+ *
+ * @param {HTMLElement|null} node - The starting DOM node.
+ * @returns {HTMLElement|null} The nearest scrollable ancestor, or null if none exist.
+ */
+exports.isScrollable = isScrollable;
+const closestScrollableAncestor = node => {
+  let cur = node?.parentElement || null;
+  while (cur) {
+    if (isScrollable(cur)) return cur;
+    cur = cur.parentElement;
+  }
+  return null;
+};
+
+/**
+ * Get the primary scrollable element for the browser window.
+ *
+ * - Modern browsers expose `document.scrollingElement` (usually the `<html>` element).
+ * - As a fallback, returns `document.documentElement` (the `<html>` element).
+ * - This element's `scrollTop` and `scrollHeight` represent the window's scroll state.
+ *
+ * @function
+ * @returns {HTMLElement} The DOM element representing the window's scrolling container.
+ */
+exports.closestScrollableAncestor = closestScrollableAncestor;
+const getWindowScroller = () => document.scrollingElement || document.documentElement;
+
+/**
+ * Compute the vertical scroll position needed to bring a node into view
+ * within a given scrollable container element.
+ *
+ * - Uses bounding boxes of the node and container to calculate the node's
+ *   position relative to the container's scroll area.
+ * - Considers the container's `scrollTop`, `clientHeight`, and a custom
+ *   `offsetTop` (for sticky headers/toolbars inside the container).
+ * - If the node is already fully visible inside the container, returns `null`.
+ * - If the node is above the visible area, returns the scrollTop needed
+ *   to align its top just below the offset.
+ * - If the node is below the visible area, returns the scrollTop needed
+ *   to bring its bottom into view (but not less than aligning its top).
+ *
+ * @param {HTMLElement} container - The scrollable container element.
+ * @param {HTMLElement} node - The DOM element to bring into view.
+ * @param {number} offsetTop - Extra vertical offset in pixels to keep free at the top.
+ * @returns {number|null} The target scrollTop value for the container, or null if already visible.
+ */
+exports.getWindowScroller = getWindowScroller;
+function computeTargetContainer(container, node, offsetTop) {
+  const cRect = container.getBoundingClientRect();
+  const nRect = node.getBoundingClientRect();
+  const nodeTopInContainer = nRect.top - cRect.top + container.scrollTop;
+  const nodeBottomInContainer = nRect.bottom - cRect.top + container.scrollTop;
+  const visibleTop = container.scrollTop + offsetTop;
+  const visibleBottom = container.scrollTop + container.clientHeight;
+  const above = nodeTopInContainer < visibleTop;
+  const below = nodeBottomInContainer > visibleBottom;
+  if (!above && !below) return null;
+  return above ? nodeTopInContainer - offsetTop : Math.max(nodeBottomInContainer - container.clientHeight, nodeTopInContainer - offsetTop);
+}
+
+/**
+ * Compute the vertical scroll position needed to bring a node into view
+ * within the browser window.
+ *
+ * - Uses the node's bounding box relative to the viewport.
+ * - Considers the current `window.scrollY` and the given `offsetTop`
+ *   (to account for sticky headers or toolbars).
+ * - If the node is already fully visible, returns `null`.
+ * - If the node is above the visible viewport, returns the scrollY needed
+ *   to align its top just below the offset.
+ * - If the node is below the viewport, returns the scrollY needed to align
+ *   its bottom into view (but not less than aligning its top).
+ *
+ * @param {HTMLElement} node - The DOM element to bring into view.
+ * @param {number} offsetTop - Extra vertical offset in pixels to keep free at the top.
+ * @returns {number|null} The target scrollY for the window, or null if already visible.
+ */
+function computeTargetWindow(node, offsetTop) {
+  const rect = node.getBoundingClientRect();
+  const nodeTop = rect.top + window.scrollY;
+  const nodeBottom = rect.bottom + window.scrollY;
+  const viewTop = window.scrollY + offsetTop;
+  const viewBottom = window.scrollY + window.innerHeight;
+  const above = nodeTop < viewTop;
+  const below = nodeBottom > viewBottom;
+  if (!above && !below) return null;
+  return above ? nodeTop - offsetTop : Math.max(nodeBottom - window.innerHeight, nodeTop - offsetTop);
+}
+
+/**
+ * Attempt a single scroll operation to bring the selected annotation node into view.
+ *
+ * - Uses double `requestAnimationFrame` to wait until layout and paints have settled.
+ * - Resolves the correct scroll container (bridged ref, closest ancestor, or window).
+ * - Computes the target scroll position using `computeTargetWindow` or
+ * `computeTargetContainer`.
+ * - Performs the scroll with the configured `scrollBehavior`.
+ * - After a short delay (`scrollRetryDelay`),
+ * checks whether the scroll position actually changed.
+ *
+ * @param {HTMLElement} node - The DOM element to scroll into view.
+ * @param {React.RefObject<HTMLElement>} bridgedScrollRef - Ref to a preferred scrollable container.
+ * @param {number} scrollRetryDelay - Delay in ms before checking if the scroll succeeded.
+ * @returns {Promise<boolean>} Resolves to true if the scroll moved the container, false otherwise.
+ */
+const runScrollOnce = (node, bridgedScrollRef, scrollRetryDelay) => new Promise(resolve => {
+  const scrollBehavior = 'smooth';
+  const scrollOffsetTop = 96;
+  requestAnimationFrame(() => {
+    // eslint-disable-next-line consistent-return
+    requestAnimationFrame(() => {
+      let container = bridgedScrollRef.current;
+      if (!isScrollable(container)) container = closestScrollableAncestor(node);
+      if (!isScrollable(container)) container = getWindowScroller();
+      const isWindow = container === document.body || container === document.documentElement || container === document.scrollingElement;
+      if (isWindow) {
+        const topWindow = computeTargetWindow(node, scrollOffsetTop);
+        if (topWindow == null) return resolve(true);
+        const before = window.scrollY;
+        window.scrollTo({
+          behavior: scrollBehavior,
+          top: topWindow
+        });
+        setTimeout(() => {
+          const after = window.scrollY;
+          resolve(Math.abs(after - before) > 0.5);
+        }, scrollRetryDelay);
+        // eslint-disable-next-line consistent-return
+        return;
+      }
+      const top = computeTargetContainer(container, node, scrollOffsetTop);
+      if (top == null) return resolve(true);
+      const before = container.scrollTop;
+      if (typeof container.scrollTo === 'function') {
+        container.scrollTo({
+          behavior: scrollBehavior,
+          top
+        });
+      }
+      setTimeout(() => {
+        const after = container.scrollTop;
+        resolve(Math.abs(after - before) > 0.5);
+      }, scrollRetryDelay);
+    });
+  });
+});
+
+/**
+ * Scroll the selected annotation into view, retrying if necessary.
+ * @param node
+ * @param bridgedScrollRef
+ * @returns {Promise<void>}
+ */
+exports.runScrollOnce = runScrollOnce;
+const scrollToSelectedAnnotation = async (node, bridgedScrollRef) => {
+  const maxScrollRetries = 3;
+  const scrollRetryDelay = 24;
+
+  // eslint-disable-next-line no-plusplus
+  for (let attempt = 0; attempt <= maxScrollRetries; attempt++) {
+    // eslint-disable-next-line no-await-in-loop
+    const ok = await runScrollOnce(node, bridgedScrollRef, scrollRetryDelay);
+    if (ok) {
+      break;
+    }
+    if (attempt < maxScrollRetries) {
+      // eslint-disable-next-line no-await-in-loop
+      await new Promise(resolve => {
+        setTimeout(resolve, scrollRetryDelay);
+      });
+    }
+  }
+};
+exports.scrollToSelectedAnnotation = scrollToSelectedAnnotation;

package/es/plugins/externalStorageAnnotationPlugin.js

@@ -4,95 +4,30 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-var _react = _interopRequireWildcard(require("react"));
+var _react = _interopRequireDefault(require("react"));
 var _propTypes = _interopRequireDefault(require("prop-types"));
-var _canvases = require("mirador/dist/es/src/state/selectors/canvases");
-var actions = _interopRequireWildcard(require("mirador/dist/es/src/state/actions"));
-var _LocalStorageAdapter = _interopRequireDefault(require("../annotationAdapter/LocalStorageAdapter"));
-var _AnnototAdapter = _interopRequireDefault(require("../annotationAdapter/AnnototAdapter"));
-var _AnnotationAdapterUtils = require("../annotationAdapter/AnnotationAdapterUtils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
 /** Functional component version of ExternalStorageAnnotation */
 function ExternalStorageAnnotation({
-  canvases,
-  config,
-  receiveAnnotation,
-  PluginComponents,
+  PluginComponents = [],
   TargetComponent,
   targetProps
 }) {
-  const retrieveAnnotations = (0, _react.useCallback)(currentCanvases => {
-    currentCanvases.forEach(canvas => {
-      if (typeof config.annotation.adapter === 'string' && config.annotation.adapter === _AnnotationAdapterUtils.AnnotationAdapter.LOCAL_STORAGE) {
-        config.annotation.adapter = canvasId => new _LocalStorageAdapter.default(`localStorage://?canvasId=${canvasId}`);
-      }
-      if (typeof config.annotation.adapter === 'string' && config.annotation.adapter === _AnnotationAdapterUtils.AnnotationAdapter.ANNOTOT) {
-        const endpointUrl = 'http://127.0.0.1:3000/annotations';
-        config.annotation.adapter = canvasId => new _AnnototAdapter.default(canvasId, endpointUrl);
-      }
-      if (!config.annotation.adapter) {
-        config.annotation.adapter = canvasId => new _LocalStorageAdapter.default(`localStorage://?canvasId=${canvasId}`);
-      }
-      const storageAdapter = config.annotation.adapter(canvas.id);
-      storageAdapter.all().then(annoPage => {
-        if (annoPage) {
-          receiveAnnotation(canvas.id, storageAdapter.annotationPageId, annoPage);
-        }
-      });
-    });
-  }, [config, receiveAnnotation]);
-  (0, _react.useEffect)(() => {
-    retrieveAnnotations(canvases);
-  }, [canvases, retrieveAnnotations]);
   return /*#__PURE__*/_react.default.createElement(TargetComponent, _extends({}, targetProps, {
     // eslint-disable-line react/jsx-props-no-spreading
     PluginComponents: PluginComponents
   }));
 }
 ExternalStorageAnnotation.propTypes = {
-  canvases: _propTypes.default.arrayOf(_propTypes.default.shape({
-    id: _propTypes.default.string,
-    index: _propTypes.default.number
-  })),
-  config: _propTypes.default.shape({
-    annotation: _propTypes.default.shape({
-      adapter: _propTypes.default.func
-    })
-  }).isRequired,
-  PluginComponents: _propTypes.default.array,
+  PluginComponents: _propTypes.default.array.isRequired,
   // eslint-disable-line react/forbid-prop-types
-  receiveAnnotation: _propTypes.default.func.isRequired,
   TargetComponent: _propTypes.default.oneOfType([_propTypes.default.func, _propTypes.default.node]).isRequired,
   targetProps: _propTypes.default.object.isRequired // eslint-disable-line react/forbid-prop-types
 };
-ExternalStorageAnnotation.defaultProps = {
-  canvases: [],
-  PluginComponents: []
-};
-
-/** */
-const mapDispatchToProps = {
-  receiveAnnotation: actions.receiveAnnotation
-};
-
-/** */
-function mapStateToProps(state, {
-  targetProps
-}) {
-  return {
-    canvases: (0, _canvases.getVisibleCanvases)(state, {
-      windowId: targetProps.windowId
-    }),
-    config: state.config
-  };
-}
-var _default = exports.default = {
+const externalStorageAnnotationPlugin = {
   component: ExternalStorageAnnotation,
-  mapDispatchToProps,
-  mapStateToProps,
   mode: 'wrap',
   target: 'Window'
-};
+};
+var _default = exports.default = externalStorageAnnotationPlugin;