@cu-mkp/editioncrafter 0.0.4

package/dist/es/src/action/CommentActions.js

@@ -0,0 +1,13 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var CommentsActions = {};
+CommentsActions.loadComments = function loadComments(state, commentData) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    loaded: true,
+    comments: commentData
+  });
+};
+export default CommentsActions;

package/dist/es/src/action/DiplomaticActions.js

@@ -0,0 +1,12 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var DiplomaticActions = {};
+DiplomaticActions.setFixedFrameMode = function setFixedFrameMode(state, mode) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    fixedFrameMode: mode
+  });
+};
+export default DiplomaticActions;

package/dist/es/src/action/DocumentActions.js

@@ -0,0 +1,181 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var DocumentActions = {};
+
+// Profile ID for EditionCrafter text partials
+var textPartialResourceProfileID = 'https://github.com/cu-mkp/editioncrafter-project/text-partial-resource.md';
+DocumentActions.loadDocument = function loadDocument(state, manifestData) {
+  var folios = parseManifest(manifestData, state.transcriptionTypes);
+  var _createFolioIndex = createFolioIndex(folios),
+    folioIndex = _createFolioIndex.folioIndex,
+    folioByName = _createFolioIndex.folioByName;
+  return _objectSpread(_objectSpread({}, state), {}, {
+    loaded: true,
+    folios: folios,
+    folioIndex: folioIndex,
+    folioByName: folioByName
+  });
+};
+DocumentActions.loadFolio = function loadFolio(state, folio) {
+  var oldFolio = state.folioIndex[folio.id];
+  var folioIdx = state.folios.indexOf(oldFolio);
+  state.folios[folioIdx] = folio;
+  state.folioIndex[folio.id] = folio;
+  state.folioByName[folio.name] = folio;
+  return _objectSpread({}, state);
+};
+function createFolioIndex(folios) {
+  // Store an ordered array of folio ids, used for next/prev navigation purposes later
+  var folioIndex = {};
+  var folioByName = {};
+  for (var idx = 0; idx < folios.length; idx++) {
+    var folio = folios[idx];
+    folioIndex[folio.id] = folio;
+    folioByName[folio.name] = folio;
+  }
+  return {
+    folioIndex: folioIndex,
+    folioByName: folioByName
+  };
+}
+function throwError(message) {
+  throw new Error("IIIF manifest parser error: ".concat(message));
+}
+function displayWarning(message) {
+  console.warn("IIIF manifest parser warning: ".concat(message));
+}
+function parseImageURLs(canvas) {
+  var _iterator = _createForOfIteratorHelper(canvas.items),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var annotationPage = _step.value;
+      if (annotationPage.type !== 'AnnotationPage') throwError("Expected AnnotationPage in items property of ".concat(canvas.id));
+      if (!annotationPage.items) throwError("Expected items property in AnnotationPage ".concat(annotationPage.id));
+      var _iterator2 = _createForOfIteratorHelper(annotationPage.items),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var annotation = _step2.value;
+          if (annotation.type !== 'Annotation') throwError("Expected Annotation in items property of ".concat(annotationPage.id));
+          if (annotation.motivation === 'painting') {
+            if (!annotation.body) throwError("Expected body property in Annotation ".concat(annotation.id));
+            if (!annotation.body.thumbnail) throwError("Expected body.thumbnail property in Annotation ".concat(annotation.id));
+            var thumbnailURL = annotation.body.thumbnail[0].id;
+            if (!thumbnailURL) throwError("Unable to find thumbnail for resource: ".concat(annotation.body.id));
+            return {
+              imageURL: "".concat(annotation.body.id, "/info.json"),
+              thumbnailURL: thumbnailURL
+            };
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  throwError("Unable to find painting Annotation for canvas: ".concat(canvas.id));
+  return null;
+}
+function parseLabel(parent) {
+  // TODO support labels in different languages, multiple labels in same language
+  if (!parent.label) {
+    displayWarning("".concat(parent.id, " does not have a label property."));
+    return '';
+  }
+  return parent.label.none[0];
+}
+function parseAnnotationURLs(canvas, transcriptionTypes) {
+  var annos = {};
+  if (canvas.annotations) {
+    var _iterator3 = _createForOfIteratorHelper(canvas.annotations),
+      _step3;
+    try {
+      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+        var annotationPage = _step3.value;
+        if (annotationPage.type !== 'AnnotationPage') throwError("Expected AnnotationPage in annotations property of ".concat(canvas.id));
+        if (!annotationPage.items) throwError("Expected items property in AnnotationPage ".concat(annotationPage.id));
+        var _iterator4 = _createForOfIteratorHelper(annotationPage.items),
+          _step4;
+        try {
+          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+            var annotation = _step4.value;
+            if (annotation.type !== 'Annotation') throwError("Expected Annotation in items property of ".concat(annotationPage.id));
+            if (annotation.motivation === 'supplementing') {
+              if (!annotation.body) throwError("Expected body property in Annotation ".concat(annotation.id));
+              var annotationBody = annotation.body;
+              if (annotationBody.profile === textPartialResourceProfileID && annotationBody.type === 'TextPartial') {
+                if (!annotationBody.id) throwError("Expected id property in TextPartial in ".concat(annotation.id));
+                if (!annotationBody.format) throwError("Expected format property in TextPartial in ".concat(annotation.id));
+                var id = annotationBody.id,
+                  format = annotationBody.format;
+                var idParts = id.split('/');
+                if (idParts.length < 5) throwError("TextPartial id property is in the wrong format: ".concat(id));
+                var transcriptionTypeID = idParts[idParts.length - 2];
+                if (transcriptionTypes[transcriptionTypeID]) {
+                  if (!annos[transcriptionTypeID]) annos[transcriptionTypeID] = {};
+                  if (format === 'text/html') annos[transcriptionTypeID].htmlURL = id;
+                  if (format === 'text/xml') annos[transcriptionTypeID].xmlURL = id;
+                }
+              }
+            }
+          }
+        } catch (err) {
+          _iterator4.e(err);
+        } finally {
+          _iterator4.f();
+        }
+      }
+    } catch (err) {
+      _iterator3.e(err);
+    } finally {
+      _iterator3.f();
+    }
+  }
+  return annos;
+}
+function parseManifest(manifest, transcriptionTypes) {
+  var folios = [];
+
+  // make sure this is a IIIF Presentation API v3 Manifest
+  if (!manifest['@context'] || !manifest['@context'].includes('http://iiif.io/api/presentation/3/context.json')) {
+    throwError('Expected root object to have a @context containing: http://iiif.io/api/presentation/3/context.json');
+  }
+  if (manifest.type !== 'Manifest') throwError("Expected root object of type 'Manifest'.");
+  if (!manifest.items) throwError('Expected manifest to have an items property.');
+  var canvases = manifest.items;
+  for (var i = 0; i < canvases.length; i++) {
+    var canvas = canvases[i];
+    if (canvas.type !== 'Canvas') throwError("Expected items[".concat(i, "] to be of type 'Canvas'."));
+    if (!canvas.id) throwError("Expected items[".concat(i, "] to have an id property."));
+    var folioID = canvas.id.substr(canvas.id.lastIndexOf('/') + 1);
+    var canvasLabel = parseLabel(canvas);
+    var _parseImageURLs = parseImageURLs(canvas),
+      imageURL = _parseImageURLs.imageURL,
+      thumbnailURL = _parseImageURLs.thumbnailURL;
+    var annotationURLs = parseAnnotationURLs(canvas, transcriptionTypes);
+    var folio = {
+      id: folioID,
+      name: canvasLabel,
+      pageNumber: i,
+      image_zoom_url: imageURL,
+      image_thumbnail_url: thumbnailURL,
+      annotationURLs: annotationURLs
+    };
+    folios.push(folio);
+  }
+  return folios;
+}
+export default DocumentActions;

package/dist/es/src/action/GlossaryActions.js

@@ -0,0 +1,13 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+var GlossaryActions = {};
+GlossaryActions.loadGlossary = function loadAuthors(state, glossaryData) {
+  return _objectSpread(_objectSpread({}, state), {}, {
+    loaded: true,
+    glossary: glossaryData
+  });
+};
+export default GlossaryActions;

package/dist/es/src/action/initialState/commentInitialState.js

@@ -0,0 +1,7 @@
+export default function commentInitialState(commentsURL) {
+  return {
+    commentsURL: commentsURL,
+    comments: {},
+    loaded: false
+  };
+}

package/dist/es/src/action/initialState/diplomaticInitialState.js

@@ -0,0 +1,3 @@
+export default {
+  fixedFrameMode: false
+};

package/dist/es/src/action/initialState/documentInitialState.js

@@ -0,0 +1,11 @@
+export default function documentInitalState(iiifManifest, documentName, transcriptionTypes) {
+  return {
+    documentName: documentName,
+    manifestURL: iiifManifest,
+    transcriptionTypes: transcriptionTypes,
+    folios: [],
+    loaded: false,
+    folioIndex: {},
+    folioByName: {}
+  };
+}

package/dist/es/src/action/initialState/glossaryInitialState.js

@@ -0,0 +1,7 @@
+export default function glossaryInitialState(glossaryURL) {
+  return {
+    glossaryURL: glossaryURL,
+    glossary: {},
+    loaded: false
+  };
+}

package/dist/es/src/action/rootReducer.js

@@ -0,0 +1,23 @@
+import { combineReducers } from 'redux';
+import { createReducer } from '../model/ReduxStore';
+import GlossaryActions from './GlossaryActions';
+import DocumentActions from './DocumentActions';
+import DiplomaticActions from './DiplomaticActions';
+import diplomaticInitialState from './initialState/diplomaticInitialState';
+import glossaryInitialState from './initialState/glossaryInitialState';
+import documentInitialState from './initialState/documentInitialState';
+import CommentActions from './CommentActions';
+import commentInitialState from './initialState/commentInitialState';
+export default function rootReducer(config) {
+  var iiifManifest = config.iiifManifest,
+    documentName = config.documentName,
+    commentsURL = config.commentsURL,
+    glossaryURL = config.glossaryURL,
+    transcriptionTypes = config.transcriptionTypes;
+  return combineReducers({
+    diplomatic: createReducer('DiplomaticActions', DiplomaticActions, diplomaticInitialState),
+    document: createReducer('DocumentActions', DocumentActions, documentInitialState(iiifManifest, documentName, transcriptionTypes)),
+    glossary: createReducer('GlossaryActions', GlossaryActions, glossaryInitialState(glossaryURL)),
+    comments: createReducer('CommentActions', CommentActions, commentInitialState(commentsURL))
+  });
+}

package/dist/es/src/component/AlphabetLinks.js

@@ -0,0 +1,67 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React, { Component } from 'react';
+import { Link } from 'react-scroll';
+export var alpha = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'Z'];
+var AlphabetLinks = /*#__PURE__*/function (_Component) {
+  _inherits(AlphabetLinks, _Component);
+  var _super = _createSuper(AlphabetLinks);
+  function AlphabetLinks() {
+    _classCallCheck(this, AlphabetLinks);
+    return _super.apply(this, arguments);
+  }
+  _createClass(AlphabetLinks, [{
+    key: "renderAlphaLinks",
+    value: function renderAlphaLinks() {
+      var letterLinks = [];
+      for (var i = 0; i < alpha.length; i++) {
+        var letter = alpha[i];
+        var alphaID = "alpha-".concat(i);
+        letterLinks.push( /*#__PURE__*/React.createElement("span", {
+          key: "link-".concat(alphaID)
+        }, /*#__PURE__*/React.createElement(Link, {
+          to: alphaID,
+          offset: -120,
+          containerId: "glossaryViewInner",
+          smooth: "true"
+        }, letter), ' '));
+      }
+      return /*#__PURE__*/React.createElement("div", {
+        style: {
+          display: 'inline'
+        }
+      }, /*#__PURE__*/React.createElement("input", {
+        id: "glossary-filter",
+        className: "searchBox",
+        placeholder: "Filter by Entry",
+        onChange: this.props.onFilterChange,
+        value: this.props.filterTerm
+      }), /*#__PURE__*/React.createElement("div", {
+        className: "alphaNav"
+      }, /*#__PURE__*/React.createElement("span", {
+        style: {
+          color: 'black'
+        }
+      }, "Go to: "), letterLinks));
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      return /*#__PURE__*/React.createElement("div", {
+        className: "glossaryNav"
+      }, this.renderAlphaLinks());
+    }
+  }]);
+  return AlphabetLinks;
+}(Component);
+export { AlphabetLinks as default };

package/dist/es/src/component/CustomizedTooltops.js

@@ -0,0 +1,165 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import React from 'react';
+import { withStyles } from '@material-ui/core/styles';
+import Tooltip from '@material-ui/core/Tooltip';
+function arrowGenerator(color) {
+  return {
+    '&[x-placement*="bottom"] $arrow': {
+      top: 0,
+      left: 0,
+      marginTop: '-0.95em',
+      width: '3em',
+      height: '1em',
+      '&::before': {
+        borderWidth: '0 1em 1em 1em',
+        borderColor: "transparent transparent ".concat(color, " transparent")
+      }
+    },
+    '&[x-placement*="top"] $arrow': {
+      bottom: 0,
+      left: 0,
+      marginBottom: '-0.95em',
+      width: '3em',
+      height: '1em',
+      '&::before': {
+        borderWidth: '1em 1em 0 1em',
+        borderColor: "".concat(color, " transparent transparent transparent")
+      }
+    },
+    '&[x-placement*="right"] $arrow': {
+      left: 0,
+      marginLeft: '-0.95em',
+      height: '3em',
+      width: '1em',
+      '&::before': {
+        borderWidth: '1em 1em 1em 0',
+        borderColor: "transparent ".concat(color, " transparent transparent")
+      }
+    },
+    '&[x-placement*="left"] $arrow': {
+      right: 0,
+      marginRight: '-0.95em',
+      height: '3em',
+      width: '1em',
+      '&::before': {
+        borderWidth: '1em 0 1em 1em',
+        borderColor: "transparent transparent transparent ".concat(color)
+      }
+    }
+  };
+}
+var styles = function styles(theme) {
+  return {
+    button: {
+      margin: theme.spacing()
+    },
+    lightTooltip: {
+      backgroundColor: theme.palette.common.white,
+      color: 'rgba(0, 0, 0, 0.87)',
+      boxShadow: theme.shadows[1],
+      fontSize: 11
+    },
+    arrowPopper: arrowGenerator(theme.palette.grey[700]),
+    arrow: {
+      position: 'absolute',
+      fontSize: 6,
+      width: '3em',
+      height: '3em',
+      '&::before': {
+        content: '""',
+        margin: 'auto',
+        display: 'block',
+        width: 0,
+        height: 0,
+        borderStyle: 'solid'
+      }
+    },
+    bootstrapPopper: arrowGenerator(theme.palette.common.black),
+    bootstrapTooltip: {
+      backgroundColor: theme.palette.common.black
+    },
+    bootstrapPlacementLeft: {
+      margin: '0 8px'
+    },
+    bootstrapPlacementRight: {
+      margin: '0 8px'
+    },
+    bootstrapPlacementTop: {
+      margin: '8px 0'
+    },
+    bootstrapPlacementBottom: {
+      margin: '8px 0'
+    },
+    htmlPopper: arrowGenerator('#dadde9'),
+    htmlTooltip: {
+      backgroundColor: '#f5f5f9',
+      color: 'rgba(0, 0, 0, 0.87)',
+      maxWidth: 220,
+      fontSize: theme.typography.pxToRem(12),
+      border: '1px solid #dadde9',
+      '& b': {
+        fontWeight: theme.typography.fontWeightMedium
+      }
+    }
+  };
+};
+var CustomizedTooltips = /*#__PURE__*/function (_React$Component) {
+  _inherits(CustomizedTooltips, _React$Component);
+  var _super = _createSuper(CustomizedTooltips);
+  function CustomizedTooltips() {
+    var _this;
+    _classCallCheck(this, CustomizedTooltips);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _super.call.apply(_super, [this].concat(args));
+    _this.state = {
+      arrowRef: null
+    };
+    _this.handleArrowRef = function (node) {
+      _this.setState({
+        arrowRef: node
+      });
+    };
+    return _this;
+  }
+  _createClass(CustomizedTooltips, [{
+    key: "render",
+    value: function render() {
+      var classes = this.props.classes;
+      return /*#__PURE__*/React.createElement(Tooltip, {
+        classes: {
+          popper: classes.htmlPopper,
+          tooltip: classes.htmlTooltip
+        },
+        PopperProps: {
+          popperOptions: {
+            modifiers: {
+              arrow: {
+                enabled: Boolean(this.state.arrowRef),
+                element: this.state.arrowRef
+              }
+            }
+          }
+        },
+        title: /*#__PURE__*/React.createElement(React.Fragment, null, this.props.htmlFragment, /*#__PURE__*/React.createElement("span", {
+          className: classes.arrow,
+          ref: this.handleArrowRef
+        }))
+      }, this.props.inner);
+    }
+  }]);
+  return CustomizedTooltips;
+}(React.Component);
+export default withStyles(styles)(CustomizedTooltips);

package/dist/es/src/component/DiploMatic.js

@@ -0,0 +1,80 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+import withWidth from '@material-ui/core/withWidth';
+import { createBrowserHistory } from 'history';
+import React, { Component } from 'react';
+import { connect, Provider } from 'react-redux';
+import { HashRouter, Route, Navigate, Routes } from 'react-router-dom';
+import DocumentView from './DocumentView';
+import RouteListener from './RouteListener';
+var DiploMatic = /*#__PURE__*/function (_Component) {
+  _inherits(DiploMatic, _Component);
+  var _super = _createSuper(DiploMatic);
+  function DiploMatic() {
+    _classCallCheck(this, DiploMatic);
+    return _super.apply(this, arguments);
+  }
+  _createClass(DiploMatic, [{
+    key: "componentDidMount",
+    value: function componentDidMount() {
+      var history = createBrowserHistory();
+      history.listen(function () {
+        window.scrollTo(0, 0);
+      });
+    }
+  }, {
+    key: "render",
+    value: function render() {
+      var fixedFrameMode = this.props.diplomatic.fixedFrameMode;
+      var fixedFrameModeClass = fixedFrameMode ? 'fixed' : 'sticky';
+      return /*#__PURE__*/React.createElement(Provider, {
+        store: this.props.store
+      }, /*#__PURE__*/React.createElement(HashRouter, null, /*#__PURE__*/React.createElement("div", {
+        id: "diplomatic",
+        className: fixedFrameModeClass
+      }, /*#__PURE__*/React.createElement(RouteListener, null), /*#__PURE__*/React.createElement("div", {
+        id: "content"
+      }, /*#__PURE__*/React.createElement(Routes, null, /*#__PURE__*/React.createElement(Route, {
+        path: "/ec/:folioID/:transcriptionType/:folioID2/:transcriptionType2",
+        element: /*#__PURE__*/React.createElement(DocumentView, this.props),
+        exact: true
+      }), /*#__PURE__*/React.createElement(Route, {
+        path: "/ec/:folioID/:transcriptionType",
+        element: /*#__PURE__*/React.createElement(DocumentView, this.props),
+        exact: true
+      }), /*#__PURE__*/React.createElement(Route, {
+        path: "/ec/:folioID",
+        element: /*#__PURE__*/React.createElement(DocumentView, this.props),
+        exact: true
+      }), /*#__PURE__*/React.createElement(Route, {
+        path: "/ec",
+        element: /*#__PURE__*/React.createElement(DocumentView, this.props),
+        exact: true
+      }), /*#__PURE__*/React.createElement(Route, {
+        path: "/",
+        element: /*#__PURE__*/React.createElement(Navigate, {
+          to: "/ec"
+        }),
+        exact: true
+      }))))));
+    }
+  }]);
+  return DiploMatic;
+}(Component);
+function mapStateToProps(state) {
+  return {
+    diplomatic: state.diplomatic,
+    documentView: state.documentView
+  };
+}
+export default withWidth()(connect(mapStateToProps)(DiploMatic));