@mjhls/mjh-framework 1.0.445 → 1.0.446

package/dist/esm/PageFilter.js

@@ -0,0 +1,67 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import './_to-object-16fd8b46.js';
+import './core.get-iterator-method-f5c0d66a.js';
+import './web.dom.iterable-46c95e52.js';
+import React, { useState, useEffect, useRef } from 'react';
+import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
+import { Dropdown } from 'react-bootstrap';
+
+var PageFilter = function PageFilter(props) {
+  var getParams = props.getParams,
+      filters = props.filters,
+      defaultFilter = props.defaultFilter;
+
+  var _useState = useState(''),
+      _useState2 = _slicedToArray(_useState, 2),
+      filter = _useState2[0],
+      setFilter = _useState2[1];
+
+  var usePrevious = function usePrevious(value) {
+    var ref = useRef();
+    useEffect(function () {
+      ref.current = value;
+    });
+    return ref.current;
+  };
+
+  var sortAttr = usePrevious({ filter: filter });
+
+  useEffect(function () {
+    if (sortAttr && sortAttr.filter !== filter) {
+      getParams(filter);
+    }
+  }, [filter, sortAttr, getParams]);
+
+  if (filters.length) {
+    return React.createElement(
+      Dropdown,
+      { alignRight: true },
+      React.createElement(
+        Dropdown.Toggle,
+        { className: 'filter-dropdown', id: 'filter-dropdown' },
+        filter || defaultFilter
+      ),
+      React.createElement(
+        Dropdown.Menu,
+        { className: 'select-dropdown' },
+        filters.map(function (filter, index) {
+          return React.createElement(
+            Dropdown.Item,
+            { key: index, onClick: function onClick() {
+                return setFilter(filter);
+              } },
+            filter
+          );
+        })
+      ),
+      React.createElement(
+        'style',
+        { jsx: 'true' },
+        '\n          .filter-dropdown {\n            float: right;\n          }\n          .select-dropdown > a {\n            color: #8e8c84;\n          }\n        '
+      )
+    );
+  }
+  return null;
+};
+
+export default PageFilter;

package/dist/esm/PdfDownload.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import './iconBase-6ee2f2fb.js';
+import { b as MdPictureAsPdf } from './index.esm-9d6faf80.js';
+
+var PdfDownload = function PdfDownload(props) {
+  return React.createElement(
+    'div',
+    { className: 'pdf-download', style: { textAlign: 'center', padding: '1rem 0', borderTop: '1px solid #eee', marginTop: '1rem' } },
+    React.createElement(
+      'a',
+      { href: props.issueInfo.asset.url, target: '_blank' },
+      React.createElement(MdPictureAsPdf, { style: { fontSize: '65px', color: '#ff0000' } }),
+      React.createElement(
+        'span',
+        null,
+        'Click to download this publication issue.'
+      )
+    )
+  );
+};
+
+export default PdfDownload;

package/dist/esm/PopUpModal.js

@@ -0,0 +1,52 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import './_to-object-16fd8b46.js';
+import './core.get-iterator-method-f5c0d66a.js';
+import './web.dom.iterable-46c95e52.js';
+import React, { useState } from 'react';
+import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
+import Modal from 'react-bootstrap/Modal';
+
+var PopUpModal = function PopUpModal(props) {
+  var _ref = props.ModalImage ? useState(true) : useState(false),
+      _ref2 = _slicedToArray(_ref, 2),
+      show = _ref2[0],
+      setShow = _ref2[1];
+
+  var launchModalButton = function launchModalButton(e) {
+    window.open(props.landingURL, '_blank');
+    setShow(false);
+  };
+
+  return React.createElement(
+    Modal,
+    { show: show, onHide: function onHide() {
+        return setShow(false);
+      }, 'aria-labelledby': 'Popup-Modal' },
+    React.createElement(Modal.Title, null),
+    React.createElement(
+      Modal.Body,
+      null,
+      React.createElement(
+        'div',
+        { className: 'modalImageHolder' },
+        React.createElement('img', { className: 'modalImage', src: props.ModalImage, onClick: function onClick() {
+            return launchModalButton();
+          } }),
+        React.createElement(
+          'div',
+          { className: 'modalClose', onClick: function onClick() {
+              return setShow(false);
+            } },
+          'X'
+        )
+      )
+    ),
+    React.createElement(
+      'style',
+      { jsx: 'true' },
+      '\n          .modalImageHolder {\n            display: flex;\n            justify-content: center;\n          }\n          .modalClose {\n            display: flex;\n            justify-content: center;\n            width: 25px;\n            height: 25px;\n            font-size: 1.25rem;\n            color: #fff;\n            cursor: pointer;\n          }\n          .modalImage {\n            cursor: pointer;\n          }\n        '
+    )
+  );
+};
+
+export default PopUpModal;

package/dist/esm/PublicationLanding.js

@@ -0,0 +1,546 @@
+import { c as createCommonjsModule, u as unwrapExports } from './_commonjsHelpers-0c4b6f40.js';
+import { _ as _isObject, a as _ctx, b as _descriptors, c as _objectDp, d as _toObject, e as _iobject, f as _toLength, g as _global, h as _fails, i as _hide, j as _export, k as _aFunction, l as _core } from './_to-object-16fd8b46.js';
+import { _ as _objectCreate, a as _iterDefine, b as _wks, c as _setToStringTag, d as _classof } from './core.get-iterator-method-f5c0d66a.js';
+import './_iter-detect-6e099a34.js';
+import './from-2c0a5f49.js';
+import { _ as _toConsumableArray } from './toConsumableArray-8712d678.js';
+import { _ as _iterStep } from './web.dom.iterable-46c95e52.js';
+import { _ as _meta, a as _isArray } from './_is-array-dd5523d6.js';
+import React, { useState, useEffect } from 'react';
+import Row from 'react-bootstrap/Row';
+import Col from 'react-bootstrap/Col';
+import Card from 'react-bootstrap/Card';
+import { useRouter } from 'next/router';
+import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
+import { _ as _anInstance, a as _forOf, b as _redefineAll, c as _setSpecies } from './_set-species-6f64f1c1.js';
+import Dropdown from 'react-bootstrap/Dropdown';
+
+var _validateCollection = function (it, TYPE) {
+  if (!_isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
+  return it;
+};
+
+var dP = _objectDp.f;
+
+
+
+
+
+
+
+
+
+var fastKey = _meta.fastKey;
+
+var SIZE = _descriptors ? '_s' : 'size';
+
+var getEntry = function (that, key) {
+  // fast case
+  var index = fastKey(key);
+  var entry;
+  if (index !== 'F') return that._i[index];
+  // frozen object case
+  for (entry = that._f; entry; entry = entry.n) {
+    if (entry.k == key) return entry;
+  }
+};
+
+var _collectionStrong = {
+  getConstructor: function (wrapper, NAME, IS_MAP, ADDER) {
+    var C = wrapper(function (that, iterable) {
+      _anInstance(that, C, NAME, '_i');
+      that._t = NAME;         // collection type
+      that._i = _objectCreate(null); // index
+      that._f = undefined;    // first entry
+      that._l = undefined;    // last entry
+      that[SIZE] = 0;         // size
+      if (iterable != undefined) _forOf(iterable, IS_MAP, that[ADDER], that);
+    });
+    _redefineAll(C.prototype, {
+      // 23.1.3.1 Map.prototype.clear()
+      // 23.2.3.2 Set.prototype.clear()
+      clear: function clear() {
+        for (var that = _validateCollection(this, NAME), data = that._i, entry = that._f; entry; entry = entry.n) {
+          entry.r = true;
+          if (entry.p) entry.p = entry.p.n = undefined;
+          delete data[entry.i];
+        }
+        that._f = that._l = undefined;
+        that[SIZE] = 0;
+      },
+      // 23.1.3.3 Map.prototype.delete(key)
+      // 23.2.3.4 Set.prototype.delete(value)
+      'delete': function (key) {
+        var that = _validateCollection(this, NAME);
+        var entry = getEntry(that, key);
+        if (entry) {
+          var next = entry.n;
+          var prev = entry.p;
+          delete that._i[entry.i];
+          entry.r = true;
+          if (prev) prev.n = next;
+          if (next) next.p = prev;
+          if (that._f == entry) that._f = next;
+          if (that._l == entry) that._l = prev;
+          that[SIZE]--;
+        } return !!entry;
+      },
+      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
+      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
+      forEach: function forEach(callbackfn /* , that = undefined */) {
+        _validateCollection(this, NAME);
+        var f = _ctx(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);
+        var entry;
+        while (entry = entry ? entry.n : this._f) {
+          f(entry.v, entry.k, this);
+          // revert to the last existing entry
+          while (entry && entry.r) entry = entry.p;
+        }
+      },
+      // 23.1.3.7 Map.prototype.has(key)
+      // 23.2.3.7 Set.prototype.has(value)
+      has: function has(key) {
+        return !!getEntry(_validateCollection(this, NAME), key);
+      }
+    });
+    if (_descriptors) dP(C.prototype, 'size', {
+      get: function () {
+        return _validateCollection(this, NAME)[SIZE];
+      }
+    });
+    return C;
+  },
+  def: function (that, key, value) {
+    var entry = getEntry(that, key);
+    var prev, index;
+    // change existing entry
+    if (entry) {
+      entry.v = value;
+    // create new entry
+    } else {
+      that._l = entry = {
+        i: index = fastKey(key, true), // <- index
+        k: key,                        // <- key
+        v: value,                      // <- value
+        p: prev = that._l,             // <- previous entry
+        n: undefined,                  // <- next entry
+        r: false                       // <- removed
+      };
+      if (!that._f) that._f = entry;
+      if (prev) prev.n = entry;
+      that[SIZE]++;
+      // add to index
+      if (index !== 'F') that._i[index] = entry;
+    } return that;
+  },
+  getEntry: getEntry,
+  setStrong: function (C, NAME, IS_MAP) {
+    // add .keys, .values, .entries, [@@iterator]
+    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
+    _iterDefine(C, NAME, function (iterated, kind) {
+      this._t = _validateCollection(iterated, NAME); // target
+      this._k = kind;                     // kind
+      this._l = undefined;                // previous
+    }, function () {
+      var that = this;
+      var kind = that._k;
+      var entry = that._l;
+      // revert to the last existing entry
+      while (entry && entry.r) entry = entry.p;
+      // get next entry
+      if (!that._t || !(that._l = entry = entry ? entry.n : that._t._f)) {
+        // or finish the iteration
+        that._t = undefined;
+        return _iterStep(1);
+      }
+      // return step by kind
+      if (kind == 'keys') return _iterStep(0, entry.k);
+      if (kind == 'values') return _iterStep(0, entry.v);
+      return _iterStep(0, [entry.k, entry.v]);
+    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
+
+    // add [@@species], 23.1.2.2, 23.2.2.2
+    _setSpecies(NAME);
+  }
+};
+
+var SPECIES = _wks('species');
+
+var _arraySpeciesConstructor = function (original) {
+  var C;
+  if (_isArray(original)) {
+    C = original.constructor;
+    // cross-realm fallback
+    if (typeof C == 'function' && (C === Array || _isArray(C.prototype))) C = undefined;
+    if (_isObject(C)) {
+      C = C[SPECIES];
+      if (C === null) C = undefined;
+    }
+  } return C === undefined ? Array : C;
+};
+
+// 9.4.2.3 ArraySpeciesCreate(originalArray, length)
+
+
+var _arraySpeciesCreate = function (original, length) {
+  return new (_arraySpeciesConstructor(original))(length);
+};
+
+// 0 -> Array#forEach
+// 1 -> Array#map
+// 2 -> Array#filter
+// 3 -> Array#some
+// 4 -> Array#every
+// 5 -> Array#find
+// 6 -> Array#findIndex
+
+
+
+
+
+var _arrayMethods = function (TYPE, $create) {
+  var IS_MAP = TYPE == 1;
+  var IS_FILTER = TYPE == 2;
+  var IS_SOME = TYPE == 3;
+  var IS_EVERY = TYPE == 4;
+  var IS_FIND_INDEX = TYPE == 6;
+  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
+  var create = $create || _arraySpeciesCreate;
+  return function ($this, callbackfn, that) {
+    var O = _toObject($this);
+    var self = _iobject(O);
+    var f = _ctx(callbackfn, that, 3);
+    var length = _toLength(self.length);
+    var index = 0;
+    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
+    var val, res;
+    for (;length > index; index++) if (NO_HOLES || index in self) {
+      val = self[index];
+      res = f(val, index, O);
+      if (TYPE) {
+        if (IS_MAP) result[index] = res;   // map
+        else if (res) switch (TYPE) {
+          case 3: return true;             // some
+          case 5: return val;              // find
+          case 6: return index;            // findIndex
+          case 2: result.push(val);        // filter
+        } else if (IS_EVERY) return false; // every
+      }
+    }
+    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
+  };
+};
+
+var dP$1 = _objectDp.f;
+var each = _arrayMethods(0);
+
+
+var _collection = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
+  var Base = _global[NAME];
+  var C = Base;
+  var ADDER = IS_MAP ? 'set' : 'add';
+  var proto = C && C.prototype;
+  var O = {};
+  if (!_descriptors || typeof C != 'function' || !(IS_WEAK || proto.forEach && !_fails(function () {
+    new C().entries().next();
+  }))) {
+    // create collection constructor
+    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
+    _redefineAll(C.prototype, methods);
+    _meta.NEED = true;
+  } else {
+    C = wrapper(function (target, iterable) {
+      _anInstance(target, C, NAME, '_c');
+      target._c = new Base();
+      if (iterable != undefined) _forOf(iterable, IS_MAP, target[ADDER], target);
+    });
+    each('add,clear,delete,forEach,get,has,set,keys,values,entries,toJSON'.split(','), function (KEY) {
+      var IS_ADDER = KEY == 'add' || KEY == 'set';
+      if (KEY in proto && !(IS_WEAK && KEY == 'clear')) _hide(C.prototype, KEY, function (a, b) {
+        _anInstance(this, C, KEY);
+        if (!IS_ADDER && IS_WEAK && !_isObject(a)) return KEY == 'get' ? undefined : false;
+        var result = this._c[KEY](a === 0 ? 0 : a, b);
+        return IS_ADDER ? this : result;
+      });
+    });
+    IS_WEAK || dP$1(C.prototype, 'size', {
+      get: function () {
+        return this._c.size;
+      }
+    });
+  }
+
+  _setToStringTag(C, NAME);
+
+  O[NAME] = C;
+  _export(_export.G + _export.W + _export.F, O);
+
+  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
+
+  return C;
+};
+
+var SET = 'Set';
+
+// 23.2 Set Objects
+var es6_set = _collection(SET, function (get) {
+  return function Set() { return get(this, arguments.length > 0 ? arguments[0] : undefined); };
+}, {
+  // 23.2.3.1 Set.prototype.add(value)
+  add: function add(value) {
+    return _collectionStrong.def(_validateCollection(this, SET), value = value === 0 ? 0 : value, value);
+  }
+}, _collectionStrong);
+
+var _arrayFromIterable = function (iter, ITERATOR) {
+  var result = [];
+  _forOf(iter, false, result.push, result, ITERATOR);
+  return result;
+};
+
+// https://github.com/DavidBruant/Map-Set.prototype.toJSON
+
+
+var _collectionToJson = function (NAME) {
+  return function toJSON() {
+    if (_classof(this) != NAME) throw TypeError(NAME + "#toJSON isn't generic");
+    return _arrayFromIterable(this);
+  };
+};
+
+// https://github.com/DavidBruant/Map-Set.prototype.toJSON
+
+
+_export(_export.P + _export.R, 'Set', { toJSON: _collectionToJson('Set') });
+
+// https://tc39.github.io/proposal-setmap-offrom/
+
+
+var _setCollectionOf = function (COLLECTION) {
+  _export(_export.S, COLLECTION, { of: function of() {
+    var length = arguments.length;
+    var A = new Array(length);
+    while (length--) A[length] = arguments[length];
+    return new this(A);
+  } });
+};
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-set.of
+_setCollectionOf('Set');
+
+// https://tc39.github.io/proposal-setmap-offrom/
+
+
+
+
+
+var _setCollectionFrom = function (COLLECTION) {
+  _export(_export.S, COLLECTION, { from: function from(source /* , mapFn, thisArg */) {
+    var mapFn = arguments[1];
+    var mapping, A, n, cb;
+    _aFunction(this);
+    mapping = mapFn !== undefined;
+    if (mapping) _aFunction(mapFn);
+    if (source == undefined) return new this();
+    A = [];
+    if (mapping) {
+      n = 0;
+      cb = _ctx(mapFn, arguments[2], 2);
+      _forOf(source, false, function (nextItem) {
+        A.push(cb(nextItem, n++));
+      });
+    } else {
+      _forOf(source, false, A.push, A);
+    }
+    return new this(A);
+  } });
+};
+
+// https://tc39.github.io/proposal-setmap-offrom/#sec-set.from
+_setCollectionFrom('Set');
+
+var set = _core.Set;
+
+var set$1 = createCommonjsModule(function (module) {
+module.exports = { "default": set, __esModule: true };
+});
+
+var _Set = unwrapExports(set$1);
+
+/* usage & query
+const Publication = (props) => {
+  const { cache, pub, year } = props
+
+  const targeting = {
+    content_placement: [`/journals/${pub.identifier.current}`],
+    document_url: [`/journals/${pub.identifier.current}`],
+  }
+
+  return (
+    <Shell title={pub.name} cache={cache} settings={Settings} targeting={targeting} ads={Ads} layout='3'>
+      <PublicationLanding publication={pub} year={year} href={'journals'} />
+    </Shell>
+  )
+}
+
+Publication.getInitialProps = async (ctx) => {
+  const { query } = ctx
+  const {
+    query: { year },
+  } = ctx
+  const pub = await client.fetch(getQuery('publication'), query)
+  const builder = imageUrlBuilder(client)
+  const urlFor = (source) => {
+    return builder.image(source)
+  }
+  pub.issues.map((issue) => {
+    issue.thumbnail = urlFor(issue.thumbnail).url()
+  })
+  return { pub, year }
+}
+
+export default Publication
+*/
+
+var PublicationLanding = function PublicationLanding(props) {
+  var publication = props.publication,
+      year = props.year,
+      href = props.href,
+      pdf = props.pdf;
+
+
+  var router = useRouter();
+  var years = [].concat(_toConsumableArray(new _Set(publication.issues.map(function (issue) {
+    return issue.year;
+  })))).sort().reverse();
+
+  var _useState = useState(publication.issues),
+      _useState2 = _slicedToArray(_useState, 2),
+      issueData = _useState2[0],
+      setIssueData = _useState2[1];
+
+  var _useState3 = useState(year ? year : years[0]),
+      _useState4 = _slicedToArray(_useState3, 2),
+      activeYear = _useState4[0],
+      setActiveYear = _useState4[1];
+
+  useEffect(function () {
+    router.push(router.pathname, '/' + (href ? href : 'publications') + '/' + publication.identifier.current + '?year=' + activeYear, { shallow: true });
+    setIssueData(function () {
+      return publication.issues.filter(function (issue) {
+        return issue.year === activeYear;
+      });
+    });
+  }, [activeYear]);
+
+  return React.createElement(
+    'div',
+    { id: 'publicationLanding' },
+    React.createElement(
+      'style',
+      { jsx: true },
+      '\n          #pubYearFilter .dropdown-menu.show {\n            max-height: 25vh;\n          }\n        '
+    ),
+    React.createElement(
+      Row,
+      { style: { marginBottom: '1rem' } },
+      React.createElement(
+        Col,
+        null,
+        React.createElement(
+          Dropdown,
+          { id: 'pubYearFilter' },
+          React.createElement(
+            Dropdown.Toggle,
+            null,
+            activeYear
+          ),
+          React.createElement(
+            Dropdown.Menu,
+            null,
+            years.map(function (yr, key) {
+              return React.createElement(
+                Dropdown.Item,
+                { key: key, onClick: function onClick() {
+                    return setActiveYear(yr);
+                  } },
+                yr
+              );
+            })
+          )
+        )
+      )
+    ),
+    issueData && issueData.length > 0 ? issueData.map(function (issue, key) {
+      return React.createElement(
+        Card,
+        { key: key, className: 'issueCard' },
+        React.createElement(
+          Row,
+          null,
+          React.createElement(
+            Col,
+            { md: 3, id: 'issueThumbnail' },
+            React.createElement(Card.Img, { src: issue.thumbnail })
+          ),
+          React.createElement(
+            Col,
+            { md: 9, id: 'issueDetail' },
+            React.createElement(
+              Card.Body,
+              null,
+              React.createElement(
+                Card.Title,
+                null,
+                issue.name
+              ),
+              issue.displayLabel && React.createElement(
+                'p',
+                { className: 'badge badge-primary' },
+                issue.displayLabel
+              ),
+              issue.volume && issue.number && React.createElement(
+                'p',
+                null,
+                'Volume: ',
+                issue.volume,
+                React.createElement('br', null),
+                'Issue: ',
+                issue.number
+              ),
+              React.createElement(
+                'a',
+                { href: publication.identifier.current + '/' + issue.identifier.current, className: 'btn btn-primary', style: { marginTop: '20px', marginLeft: '1rem' } },
+                'View Issue'
+              ),
+              issue.pdf && issue.pdf.asset && issue.pdf.asset.url && React.createElement(
+                'a',
+                { href: issue.pdf.asset.url, target: '_blank', className: 'btn btn-primary', style: { marginTop: '20px', marginLeft: '1rem' } },
+                'Download Issue'
+              )
+            )
+          )
+        )
+      );
+    }) : React.createElement(
+      'div',
+      null,
+      React.createElement(
+        'h5',
+        null,
+        React.createElement(
+          'em',
+          { className: 'pl-3' },
+          'New content coming soon, please check back later.'
+        )
+      )
+    ),
+    React.createElement(
+      'style',
+      { jsx: 'true' },
+      '\n        .issueCard.card:hover {\n          cursor: default;\n        }\n      '
+    )
+  );
+};
+
+export default PublicationLanding;