@mjhls/mjh-framework 1.0.284 → 1.0.286

package/dist/esm/{YoutubeGroup-a87b8967.js → YoutubeGroup-562ed456.js}

@@ -2,7 +2,6 @@ import { c as createCommonjsModule, a as commonjsGlobal } from './_commonjsHelpe
 import React__default, { useEffect } from 'react';
 import 'next/link';
 import { L as LazyLoad } from './index-5f9f807a.js';
-import smoothscroll from 'smoothscroll-polyfill';
 
 var getYoutubeId = createCommonjsModule(function (module, exports) {
 (function (root, factory) {
@@ -53,6 +52,439 @@ var getYoutubeId = createCommonjsModule(function (module, exports) {
 }));
 });
 
+var smoothscroll = createCommonjsModule(function (module, exports) {
+/* smoothscroll v0.4.4 - 2019 - Dustan Kasten, Jeremias Menichelli - MIT License */
+(function () {
+
+  // polyfill
+  function polyfill() {
+    // aliases
+    var w = window;
+    var d = document;
+
+    // return if scroll behavior is supported and polyfill is not forced
+    if (
+      'scrollBehavior' in d.documentElement.style &&
+      w.__forceSmoothScrollPolyfill__ !== true
+    ) {
+      return;
+    }
+
+    // globals
+    var Element = w.HTMLElement || w.Element;
+    var SCROLL_TIME = 468;
+
+    // object gathering original scroll methods
+    var original = {
+      scroll: w.scroll || w.scrollTo,
+      scrollBy: w.scrollBy,
+      elementScroll: Element.prototype.scroll || scrollElement,
+      scrollIntoView: Element.prototype.scrollIntoView
+    };
+
+    // define timing method
+    var now =
+      w.performance && w.performance.now
+        ? w.performance.now.bind(w.performance)
+        : Date.now;
+
+    /**
+     * indicates if a the current browser is made by Microsoft
+     * @method isMicrosoftBrowser
+     * @param {String} userAgent
+     * @returns {Boolean}
+     */
+    function isMicrosoftBrowser(userAgent) {
+      var userAgentPatterns = ['MSIE ', 'Trident/', 'Edge/'];
+
+      return new RegExp(userAgentPatterns.join('|')).test(userAgent);
+    }
+
+    /*
+     * IE has rounding bug rounding down clientHeight and clientWidth and
+     * rounding up scrollHeight and scrollWidth causing false positives
+     * on hasScrollableSpace
+     */
+    var ROUNDING_TOLERANCE = isMicrosoftBrowser(w.navigator.userAgent) ? 1 : 0;
+
+    /**
+     * changes scroll position inside an element
+     * @method scrollElement
+     * @param {Number} x
+     * @param {Number} y
+     * @returns {undefined}
+     */
+    function scrollElement(x, y) {
+      this.scrollLeft = x;
+      this.scrollTop = y;
+    }
+
+    /**
+     * returns result of applying ease math function to a number
+     * @method ease
+     * @param {Number} k
+     * @returns {Number}
+     */
+    function ease(k) {
+      return 0.5 * (1 - Math.cos(Math.PI * k));
+    }
+
+    /**
+     * indicates if a smooth behavior should be applied
+     * @method shouldBailOut
+     * @param {Number|Object} firstArg
+     * @returns {Boolean}
+     */
+    function shouldBailOut(firstArg) {
+      if (
+        firstArg === null ||
+        typeof firstArg !== 'object' ||
+        firstArg.behavior === undefined ||
+        firstArg.behavior === 'auto' ||
+        firstArg.behavior === 'instant'
+      ) {
+        // first argument is not an object/null
+        // or behavior is auto, instant or undefined
+        return true;
+      }
+
+      if (typeof firstArg === 'object' && firstArg.behavior === 'smooth') {
+        // first argument is an object and behavior is smooth
+        return false;
+      }
+
+      // throw error when behavior is not supported
+      throw new TypeError(
+        'behavior member of ScrollOptions ' +
+          firstArg.behavior +
+          ' is not a valid value for enumeration ScrollBehavior.'
+      );
+    }
+
+    /**
+     * indicates if an element has scrollable space in the provided axis
+     * @method hasScrollableSpace
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function hasScrollableSpace(el, axis) {
+      if (axis === 'Y') {
+        return el.clientHeight + ROUNDING_TOLERANCE < el.scrollHeight;
+      }
+
+      if (axis === 'X') {
+        return el.clientWidth + ROUNDING_TOLERANCE < el.scrollWidth;
+      }
+    }
+
+    /**
+     * indicates if an element has a scrollable overflow property in the axis
+     * @method canOverflow
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function canOverflow(el, axis) {
+      var overflowValue = w.getComputedStyle(el, null)['overflow' + axis];
+
+      return overflowValue === 'auto' || overflowValue === 'scroll';
+    }
+
+    /**
+     * indicates if an element can be scrolled in either axis
+     * @method isScrollable
+     * @param {Node} el
+     * @param {String} axis
+     * @returns {Boolean}
+     */
+    function isScrollable(el) {
+      var isScrollableY = hasScrollableSpace(el, 'Y') && canOverflow(el, 'Y');
+      var isScrollableX = hasScrollableSpace(el, 'X') && canOverflow(el, 'X');
+
+      return isScrollableY || isScrollableX;
+    }
+
+    /**
+     * finds scrollable parent of an element
+     * @method findScrollableParent
+     * @param {Node} el
+     * @returns {Node} el
+     */
+    function findScrollableParent(el) {
+      while (el !== d.body && isScrollable(el) === false) {
+        el = el.parentNode || el.host;
+      }
+
+      return el;
+    }
+
+    /**
+     * self invoked function that, given a context, steps through scrolling
+     * @method step
+     * @param {Object} context
+     * @returns {undefined}
+     */
+    function step(context) {
+      var time = now();
+      var value;
+      var currentX;
+      var currentY;
+      var elapsed = (time - context.startTime) / SCROLL_TIME;
+
+      // avoid elapsed times higher than one
+      elapsed = elapsed > 1 ? 1 : elapsed;
+
+      // apply easing to elapsed time
+      value = ease(elapsed);
+
+      currentX = context.startX + (context.x - context.startX) * value;
+      currentY = context.startY + (context.y - context.startY) * value;
+
+      context.method.call(context.scrollable, currentX, currentY);
+
+      // scroll more if we have not reached our destination
+      if (currentX !== context.x || currentY !== context.y) {
+        w.requestAnimationFrame(step.bind(w, context));
+      }
+    }
+
+    /**
+     * scrolls window or element with a smooth behavior
+     * @method smoothScroll
+     * @param {Object|Node} el
+     * @param {Number} x
+     * @param {Number} y
+     * @returns {undefined}
+     */
+    function smoothScroll(el, x, y) {
+      var scrollable;
+      var startX;
+      var startY;
+      var method;
+      var startTime = now();
+
+      // define scroll context
+      if (el === d.body) {
+        scrollable = w;
+        startX = w.scrollX || w.pageXOffset;
+        startY = w.scrollY || w.pageYOffset;
+        method = original.scroll;
+      } else {
+        scrollable = el;
+        startX = el.scrollLeft;
+        startY = el.scrollTop;
+        method = scrollElement;
+      }
+
+      // scroll looping over a frame
+      step({
+        scrollable: scrollable,
+        method: method,
+        startTime: startTime,
+        startX: startX,
+        startY: startY,
+        x: x,
+        y: y
+      });
+    }
+
+    // ORIGINAL METHODS OVERRIDES
+    // w.scroll and w.scrollTo
+    w.scroll = w.scrollTo = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.scroll.call(
+          w,
+          arguments[0].left !== undefined
+            ? arguments[0].left
+            : typeof arguments[0] !== 'object'
+              ? arguments[0]
+              : w.scrollX || w.pageXOffset,
+          // use top prop, second argument if present or fallback to scrollY
+          arguments[0].top !== undefined
+            ? arguments[0].top
+            : arguments[1] !== undefined
+              ? arguments[1]
+              : w.scrollY || w.pageYOffset
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        arguments[0].left !== undefined
+          ? ~~arguments[0].left
+          : w.scrollX || w.pageXOffset,
+        arguments[0].top !== undefined
+          ? ~~arguments[0].top
+          : w.scrollY || w.pageYOffset
+      );
+    };
+
+    // w.scrollBy
+    w.scrollBy = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.scrollBy.call(
+          w,
+          arguments[0].left !== undefined
+            ? arguments[0].left
+            : typeof arguments[0] !== 'object' ? arguments[0] : 0,
+          arguments[0].top !== undefined
+            ? arguments[0].top
+            : arguments[1] !== undefined ? arguments[1] : 0
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        ~~arguments[0].left + (w.scrollX || w.pageXOffset),
+        ~~arguments[0].top + (w.scrollY || w.pageYOffset)
+      );
+    };
+
+    // Element.prototype.scroll and Element.prototype.scrollTo
+    Element.prototype.scroll = Element.prototype.scrollTo = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        // if one number is passed, throw error to match Firefox implementation
+        if (typeof arguments[0] === 'number' && arguments[1] === undefined) {
+          throw new SyntaxError('Value could not be converted');
+        }
+
+        original.elementScroll.call(
+          this,
+          // use left prop, first number argument or fallback to scrollLeft
+          arguments[0].left !== undefined
+            ? ~~arguments[0].left
+            : typeof arguments[0] !== 'object' ? ~~arguments[0] : this.scrollLeft,
+          // use top prop, second argument or fallback to scrollTop
+          arguments[0].top !== undefined
+            ? ~~arguments[0].top
+            : arguments[1] !== undefined ? ~~arguments[1] : this.scrollTop
+        );
+
+        return;
+      }
+
+      var left = arguments[0].left;
+      var top = arguments[0].top;
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        this,
+        this,
+        typeof left === 'undefined' ? this.scrollLeft : ~~left,
+        typeof top === 'undefined' ? this.scrollTop : ~~top
+      );
+    };
+
+    // Element.prototype.scrollBy
+    Element.prototype.scrollBy = function() {
+      // avoid action when no arguments are passed
+      if (arguments[0] === undefined) {
+        return;
+      }
+
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.elementScroll.call(
+          this,
+          arguments[0].left !== undefined
+            ? ~~arguments[0].left + this.scrollLeft
+            : ~~arguments[0] + this.scrollLeft,
+          arguments[0].top !== undefined
+            ? ~~arguments[0].top + this.scrollTop
+            : ~~arguments[1] + this.scrollTop
+        );
+
+        return;
+      }
+
+      this.scroll({
+        left: ~~arguments[0].left + this.scrollLeft,
+        top: ~~arguments[0].top + this.scrollTop,
+        behavior: arguments[0].behavior
+      });
+    };
+
+    // Element.prototype.scrollIntoView
+    Element.prototype.scrollIntoView = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0]) === true) {
+        original.scrollIntoView.call(
+          this,
+          arguments[0] === undefined ? true : arguments[0]
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      var scrollableParent = findScrollableParent(this);
+      var parentRects = scrollableParent.getBoundingClientRect();
+      var clientRects = this.getBoundingClientRect();
+
+      if (scrollableParent !== d.body) {
+        // reveal element inside parent
+        smoothScroll.call(
+          this,
+          scrollableParent,
+          scrollableParent.scrollLeft + clientRects.left - parentRects.left,
+          scrollableParent.scrollTop + clientRects.top - parentRects.top
+        );
+
+        // reveal parent in viewport unless is fixed
+        if (w.getComputedStyle(scrollableParent).position !== 'fixed') {
+          w.scrollBy({
+            left: parentRects.left,
+            top: parentRects.top,
+            behavior: 'smooth'
+          });
+        }
+      } else {
+        // reveal element in viewport
+        w.scrollBy({
+          left: clientRects.left,
+          top: clientRects.top,
+          behavior: 'smooth'
+        });
+      }
+    };
+  }
+
+  {
+    // commonjs
+    module.exports = { polyfill: polyfill };
+  }
+
+}());
+});
+var smoothscroll_1 = smoothscroll.polyfill;
+
 // kick off the polyfill!
 
 /*

package/dist/esm/YoutubeGroup.js

@@ -4,5 +4,4 @@ import 'prop-types';
 import 'next/link';
 import 'react-dom';
 import './index-5f9f807a.js';
-export { Y as default } from './YoutubeGroup-a87b8967.js';
-import 'smoothscroll-polyfill';
+export { Y as default } from './YoutubeGroup-562ed456.js';

package/dist/esm/index.js

@@ -21,13 +21,13 @@ import { i as imageUrlBuilder } from './index-3849e3fe.js';
 import './index-5f9f807a.js';
 import { h as html_decode_1, c as clean_html_1 } from './entities-7cc3bf45.js';
 import { _ as _slicedToArray } from './slicedToArray-d0a9593a.js';
-import { _ as _JSON$stringify, a as _asyncToGenerator, r as regenerator, D as DFPAdSlot, B as Beam } from './AdSlot-cc6a4f74.js';
-export { D as AdSlot, B as Beam } from './AdSlot-cc6a4f74.js';
+import { _ as _JSON$stringify, a as _asyncToGenerator, r as regenerator, D as DFPAdSlot, B as Beam } from './AdSlot-03043ffb.js';
+export { D as AdSlot, B as Beam } from './AdSlot-03043ffb.js';
 import './promise-e3480f1c.js';
-import './ADInfeed-fd816c1f.js';
+import './ADInfeed-ac3ac372.js';
 export { default as DeckContent } from './DeckContent.js';
 import { i as isFunction_1, a as isArray_1, _ as _arrayMap } from './get-9c285a85.js';
-export { A as AD, G as GridContent } from './GridContent-2e9e7528.js';
+export { A as AD, G as GridContent } from './GridContent-96716e42.js';
 export { default as DeckQueue } from './DeckQueue.js';
 import 'react-bootstrap/Media';
 export { default as ThumbnailCard } from './ThumbnailCard.js';
@@ -35,9 +35,8 @@ import { B as BlockContent } from './TaxonomyCard-ee1a22ae.js';
 export { T as TaxonomyCard } from './TaxonomyCard-ee1a22ae.js';
 import GroupDeck from './GroupDeck.js';
 export { default as GroupDeck } from './GroupDeck.js';
-import { g as getYoutubeId } from './YoutubeGroup-a87b8967.js';
-export { Y as YoutubeGroup } from './YoutubeGroup-a87b8967.js';
-import 'smoothscroll-polyfill';
+import { g as getYoutubeId } from './YoutubeGroup-562ed456.js';
+export { Y as YoutubeGroup } from './YoutubeGroup-562ed456.js';
 import { Spinner as Spinner$1, Container as Container$1, Row as Row$1, Col as Col$1, Carousel, Table, Figure as Figure$1, Button as Button$1, ProgressBar, Card } from 'react-bootstrap';
 export { default as QueueDeckExpanded } from './QueueDeckExpanded.js';
 import { I as IoMdArrowDropdown } from './index.esm-536609db.js';
@@ -49,8 +48,8 @@ export { default as IssueDeck } from './IssueDeck.js';
 import 'react-bootstrap/Badge';
 export { default as IssueContentDeck } from './IssueContentDeck.js';
 import Spinner from 'react-bootstrap/Spinner';
-import { M as MdPictureAsPdf, T as TemplateNormal } from './Normal-319bc9fb.js';
-export { A as AD728x90, C as Column1, a as Column2, b as Column3, f as HamMagazine, H as Header, L as LeftNav, e as NavDvm, c as NavMagazine, N as NavNative, d as NavNormal, P as PageFilter, S as Search, g as SideFooter, T as TemplateNormal } from './Normal-319bc9fb.js';
+import { M as MdPictureAsPdf, T as TemplateNormal } from './Normal-d27184f4.js';
+export { A as AD728x90, C as Column1, a as Column2, b as Column3, f as HamMagazine, H as Header, L as LeftNav, e as NavDvm, c as NavMagazine, N as NavNative, d as NavNormal, P as PageFilter, S as Search, g as SideFooter, T as TemplateNormal } from './Normal-d27184f4.js';
 import 'react-bootstrap/ListGroup';
 import Head from 'next/head';
 import Accordion from 'react-bootstrap/Accordion';
@@ -61,7 +60,6 @@ import 'react-bootstrap/Navbar';
 import 'react-bootstrap/NavDropdown';
 import 'react-bootstrap/Form';
 import 'react-bootstrap/FormControl';
-import Modal from 'react-bootstrap/Modal';
 import Pagination from 'react-bootstrap/Pagination';
 import dynamic from 'next/dynamic';
 import Carousel$1 from 'react-bootstrap/Carousel';
@@ -3028,14 +3026,21 @@ var ADWelcome = function ADWelcome(_ref) {
       adTargeting = _useState2[0],
       setTargeting = _useState2[1];
 
+  var adRef = useRef(null);
+
+  var _useState3 = useState(),
+      _useState4 = _slicedToArray(_useState3, 2),
+      showAd = _useState4[0],
+      setShowAd = _useState4[1];
+
   var calculateTimeLeft = function calculateTimeLeft(timeLeft) {
     return --timeLeft;
   };
 
-  var _useState3 = useState(calculateTimeLeft(counter)),
-      _useState4 = _slicedToArray(_useState3, 2),
-      timeLeft = _useState4[0],
-      setTimeLeft = _useState4[1];
+  var _useState5 = useState(calculateTimeLeft(counter + 1)),
+      _useState6 = _slicedToArray(_useState5, 2),
+      timeLeft = _useState6[0],
+      setTimeLeft = _useState6[1];
 
   useEffect(function () {
     if (timeLeft > 0) {
@@ -3047,9 +3052,17 @@ var ADWelcome = function ADWelcome(_ref) {
     }
   });
 
+  useEffect(function () {
+    if (typeof showAd !== 'undefined' && showAd) {
+      adRef.current.style.opacity = '1';
+    } else if (typeof showAd !== 'undefined' && !showAd) {
+      setFlag(true);
+    }
+  }, [showAd]);
+
   return React__default.createElement(
-    Modal,
-    { show: true, 'aria-labelledby': 'contained-modal-title-vcenter', backdrop: 'static', style: { outline: 'none' }, dialogClassName: 'welcome-modal' },
+    'div',
+    { ref: adRef, style: { outline: 'none', opacity: 0 }, className: 'welcome-modal' },
     React__default.createElement(
       'div',
       { className: 'right-top', style: { position: 'absolute', top: 0, right: 0, textAlign: 'center', margin: '2rem' } },
@@ -3084,14 +3097,14 @@ var ADWelcome = function ADWelcome(_ref) {
       React__default.createElement('img', { style: { width: '100%' }, src: Website.logo, alt: Website.title })
     ),
     React__default.createElement(
-      Modal.Body,
+      'div',
       { className: title, style: { position: 'relative', width: '300px', height: '250px', margin: 'auto', top: '10rem' } },
-      React__default.createElement(DFPAdSlot, { className: className, slotId: slotId, networkID: networkID, sizes: sizes, adUnit: adUnit, targeting: adTargeting, refreshFlag: false })
+      React__default.createElement(DFPAdSlot, { className: className, slotId: slotId, networkID: networkID, sizes: sizes, adUnit: adUnit, targeting: adTargeting, refreshFlag: false, setShowAd: setShowAd })
     ),
     React__default.createElement(
       'style',
       { jsx: 'true' },
-      '\n        .modal.show {\n          padding: 0px;\n        }\n        .continue-site:hover {\n          cursor: pointer;\n        }\n\n        .welcome-modal {\n          max-width: 100% !important;\n          margin: 0px !important;\n        }\n        @media (min-width: 1200px) {\n          .modal-backdrop {\n            display: block;\n          }\n          .modal-content {\n            display: block;\n            height: 100vh;\n          }\n        }\n      '
+      '\n        .continue-site:hover {\n          cursor: pointer;\n        }\n\n        .welcome-modal {\n          max-width: 100% !important;\n          margin: 0px !important;\n        }\n      '
     )
   );
 };
@@ -14112,46 +14125,63 @@ var RelatedTopicsDropdown = function RelatedTopicsDropdown(_ref) {
 };
 
 /*
-This dropdown is used inside Article body to display related content placement pages
- sample usage: <ArticleDetailDropdown contentPlacement={content_placement} exclude={['News',]} />
+This dropdown is used inside Article body to display related content placement and document group pages
+sample usage: <ArticleDetailDropdown article={props.article} exclude={['News']} style={{ backgroundColor: 'var(--primary)', border: 0 }} />
+
+- accepts any normal html arrtibute (style, id, class)
 
- in article query, need to add '...' to content_placement to retreive additional info needed
+- in article query, need to add '...' to content_placement to retreive additional info needed, and document_group to retrieve group data if available
 
- 'content_placement': taxonomyMapping[]-> {
+'content_placement': taxonomyMapping[]-> {
     ...,
     'ancestor': parent->parent->identifier,
     'parent': parent->identifier,
     'path': identifier
-  }
-
+},
+'document_group': documentGroup-> {
+    name,
+    'parent': parent->identifier,
+    'path': identifier.current
+}
 */
 
 var ArticleDetailDropdown = function ArticleDetailDropdown(props) {
-  var _props$contentPlaceme = props.contentPlacement,
-      contentPlacement = _props$contentPlaceme === undefined ? false : _props$contentPlaceme,
+  var article = props.article,
       _props$exclude = props.exclude,
-      exclude = _props$exclude === undefined ? [''] : _props$exclude;
-
-  if (contentPlacement.length == 1 && exclude.includes(contentPlacement[0].name) || contentPlacement == false) {
-    return null;
-  }
+      exclude = _props$exclude === undefined ? [] : _props$exclude;
 
+  var _props = _extends$2({}, props);
+  delete _props.article;
+  delete _props.exclude;
   return React__default.createElement(
     Dropdown,
-    { style: { marginBottom: '1rem' } },
+    null,
     React__default.createElement(
       Dropdown.Toggle,
-      { variant: 'primary', id: 'partner-dropdown' },
+      _props,
       'Related Topics'
     ),
     React__default.createElement(
       Dropdown.Menu,
       null,
-      contentPlacement.map(function (cp, index) {
-        var href = cp.parent ? '/' + cp.parent + '/' + cp.path : '/' + cp.path;
-        return !exclude.includes(cp.name) && React__default.createElement(
+      article.document_group && React__default.createElement(
+        Dropdown.Item,
+        { href: '/' + article.document_group.parent.current + '/' + article.document_group.path },
+        article.document_group.name
+      ),
+      article.content_placement && article.content_placement.length > 0 && article.content_placement.map(function (cp, i) {
+        if (exclude.includes(cp.name)) return;
+        var href = '';
+        if (cp.ancestor) {
+          href = '/' + cp.ancestor + '/' + cp.identifier;
+        } else if (cp.parent) {
+          href = '/' + cp.parent + '/' + cp.identifier;
+        } else {
+          href = '/' + cp.identifier;
+        }
+        return React__default.createElement(
           Dropdown.Item,
-          { key: index, href: href },
+          { key: i, href: href },
           cp.name
         );
       })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mjhls/mjh-framework",
-  "version": "1.0.284",
+  "version": "1.0.286",
   "description": "Foundation Framework",
   "author": "mjh-framework",
   "license": "MIT",