@mjhls/mjh-framework 1.0.444 → 1.0.446

package/dist/esm/{ADlgInfeed-7b29db85.js → ADlgInfeed-94d7f5dd.js}

@@ -1,6 +1,6 @@
 import React from 'react';
 import 'react-bootstrap/Card';
-import { D as DFPAdSlot } from './AdSlot-362a1c30.js';
+import DFPAdSlot from './AdSlot.js';
 
 var ADlgInfeed = function ADlgInfeed(props) {
   var className = props.className,

package/dist/esm/AccordionPanel.js

@@ -0,0 +1,88 @@
+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 './iconBase-6ee2f2fb.js';
+import { a as IoMdArrowDropdown } from './index.esm-b97cf389.js';
+import Accordion from 'react-bootstrap/Accordion';
+import { useAccordionToggle } from 'react-bootstrap/AccordionToggle';
+
+var AccordionPanel = function AccordionPanel(props) {
+  var accordionClassName = props.accordionClassName,
+      data = props.data;
+
+  var _useState = useState('0'),
+      _useState2 = _slicedToArray(_useState, 2),
+      activeAccordionKey = _useState2[0],
+      setaAtiveAccordionKey = _useState2[1];
+
+  var handleAccordion = function handleAccordion(id) {
+    setaAtiveAccordionKey(id);
+  };
+
+  var CustomToggle = function CustomToggle(_ref) {
+    var children = _ref.children,
+        eventKey = _ref.eventKey;
+
+    var decoratedOnClick = useAccordionToggle(eventKey, function () {
+      return handleAccordion(eventKey);
+    });
+    return React.createElement(
+      'div',
+      { onMouseEnter: decoratedOnClick, className: 'accordion-head' },
+      children
+    );
+  };
+
+  return React.createElement(
+    React.Fragment,
+    null,
+    data && data.length && React.createElement(
+      Accordion,
+      { defaultActiveKey: '0', activeKey: activeAccordionKey, className: accordionClassName },
+      data.map(function (item) {
+        return React.createElement(
+          React.Fragment,
+          null,
+          React.createElement(
+            CustomToggle,
+            { key: item.id, eventKey: item.id },
+            React.createElement(
+              'a',
+              { href: item.url },
+              React.createElement(
+                React.Fragment,
+                null,
+                item.title,
+                item.subItems && React.createElement(IoMdArrowDropdown, null)
+              )
+            )
+          ),
+          React.createElement(
+            Accordion.Collapse,
+            { eventKey: item.id },
+            React.createElement(
+              'div',
+              null,
+              item.subItems && item.subItems.map(function (subItem) {
+                return React.createElement(
+                  'a',
+                  { href: subItem.url },
+                  React.createElement(
+                    'div',
+                    { key: subItem.id, className: 'accordion-sub-item' },
+                    subItem.title
+                  )
+                );
+              })
+            )
+          )
+        );
+      })
+    )
+  );
+};
+
+export default AccordionPanel;

package/dist/esm/AdSlot.js

@@ -0,0 +1,159 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import './_to-object-16fd8b46.js';
+import './core.get-iterator-method-f5c0d66a.js';
+import './_library-528f1934.js';
+import './_iter-detect-6e099a34.js';
+import './web.dom.iterable-46c95e52.js';
+import React, { useState } from 'react';
+import { a as lib_2 } from './index-fb49124c.js';
+import PropTypes from 'prop-types';
+import './isSymbol-c1b9be80.js';
+import { d as debounce_1 } from './debounce-8cd9e09c.js';
+import { b as main_16 } from './main-8c8784b8.js';
+import { _ as _slicedToArray } from './slicedToArray-f1e40361.js';
+import './stringify-e30bc114.js';
+import './asyncToGenerator-204b5a5c.js';
+import './_set-species-6f64f1c1.js';
+import './promise-53143c9a.js';
+import Beam from './Beam.js';
+import Segment from './Segment.js';
+
+var DFPAdSlot = function DFPAdSlot(_ref) {
+  var adUnit = _ref.adUnit,
+      sizeMapping = _ref.sizeMapping,
+      className = _ref.className,
+      slotId = _ref.slotId,
+      sizes = _ref.sizes,
+      _ref$targeting = _ref.targeting,
+      targeting = _ref$targeting === undefined ? {} : _ref$targeting,
+      _ref$refreshFlag = _ref.refreshFlag,
+      refreshFlag = _ref$refreshFlag === undefined ? true : _ref$refreshFlag,
+      checkIsAdFound = _ref.checkIsAdFound;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      adRendered = _useState2[0],
+      setAdRendered = _useState2[1];
+
+  var _useState3 = useState(false),
+      _useState4 = _slicedToArray(_useState3, 2),
+      adRefreshable = _useState4[0],
+      setAdRefreshable = _useState4[1];
+
+  var _useState5 = useState(false),
+      _useState6 = _slicedToArray(_useState5, 2),
+      adHasFocus = _useState6[0],
+      setAdHasFocus = _useState6[1];
+
+  var handleVisibilityChange = debounce_1(function (_ref2) {
+    var event = _ref2.event;
+
+    if (event.inViewPercentage <= 0) {
+      setAdRefreshable(false);
+    } else {
+      setAdRefreshable(true);
+    }
+  }, 500);
+
+  var _useState7 = useState(null),
+      _useState8 = _slicedToArray(_useState7, 2),
+      eventData = _useState8[0],
+      setEventData = _useState8[1];
+
+  return React.createElement(
+    'div',
+    { className: className, style: { textAlign: 'center' } },
+    React.createElement(lib_2, {
+      slotId: slotId,
+      sizes: sizes,
+      adUnit: adUnit,
+      sizeMapping: sizeMapping,
+      targetingArguments: targeting,
+      onSlotIsViewable: function onSlotIsViewable(e) {
+        Beam.report_beam_ad('Impression', main_16, eventData.cID, eventData.lID, eventData.campID, eventData.adSize, eventData.slot_id);
+        Segment.adViewed(eventData.domain, eventData.advertiserId, eventData.campID, eventData.cID, eventData.lID, eventData.adSize, eventData.isEmpty, eventData.sourceAgnosticCreativeId, eventData.sourceAgnosticLineItemId);
+      },
+      onSlotRender: function onSlotRender(eventData) {
+        if (eventData && eventData.slotId && eventData.slotId === slotId && checkIsAdFound) {
+          if (eventData.event && eventData.event.creativeId == null) {
+            checkIsAdFound(false, eventData);
+          } else {
+            checkIsAdFound(true, eventData);
+          }
+        }
+
+        setAdRendered(true);
+        if (eventData && eventData.event) {
+          var cID = eventData.event.creativeId;
+          var lID = eventData.event.lineItemId;
+          var campID = eventData.event.campaignId;
+          var adSize = eventData.event.size && eventData.event.size.length > 1 ? eventData.event.size[0] + 'x' + eventData.event.size[1] : '';
+          var slot_id = eventData.slotId ? eventData.slotId : '';
+          var isEmpty = eventData.event.isEmpty;
+          var sourceAgnosticCreativeId = eventData.event.sourceAgnosticCreativeId;
+          var sourceAgnosticLineItemId = eventData.event.sourceAgnosticLineItemId;
+          var advertiserId = eventData.event.advertiserId;
+          var domain = typeof window !== 'undefined' && window.location ? window.location.hostname : '';
+
+          setEventData({
+            cID: cID,
+            lID: lID,
+            campID: campID,
+            adSize: adSize,
+            slot_id: slot_id,
+            isEmpty: isEmpty,
+            sourceAgnosticCreativeId: sourceAgnosticCreativeId,
+            sourceAgnosticLineItemId: sourceAgnosticLineItemId,
+            advertiserId: advertiserId,
+            domain: domain
+          });
+
+          var slot_div = document.getElementById(eventData.slotId);
+          if (slot_div) {
+            slot_div.addEventListener('mouseenter', function () {
+              var timeoutId = slot_div.getAttribute('timeoutId');
+              clearTimeout(timeoutId);
+              slot_div.setAttribute('hasFocus', 'yes');
+            });
+
+            slot_div.addEventListener('mouseleave', function () {
+              var timeoutId = setTimeout(function () {
+                slot_div.setAttribute('hasFocus', 'no');
+              }, 60);
+              slot_div.setAttribute('timeoutId', timeoutId);
+            });
+
+            document.addEventListener('visibilitychange', function () {
+              if (!document.hidden) {
+                return;
+              }
+
+              var hasFocus = slot_div.getAttribute('hasFocus');
+              if (hasFocus == 'yes' && document.hidden) {
+                slot_div.setAttribute('hasFocus', 'no');
+                Beam.report_beam_ad('Click', main_16, cID, lID, campID, adSize, slotId);
+                Segment.adClicked(domain, advertiserId, campID, cID, lID, adSize, isEmpty, sourceAgnosticCreativeId, sourceAgnosticLineItemId);
+              }
+            });
+          } else {
+            console.error('slot div not found:', slotId);
+          }
+        }
+      },
+      onSlotVisibilityChanged: handleVisibilityChange,
+      shouldRefresh: function shouldRefresh() {
+        if (adRendered && adRefreshable && refreshFlag) return true;else return false;
+      }
+    })
+  );
+};
+
+DFPAdSlot.propTypes = {
+  adUnit: PropTypes.string.isRequired,
+  slotId: PropTypes.string,
+  className: PropTypes.string,
+  sizeMapping: PropTypes.array,
+  sizes: PropTypes.array
+};
+
+export default DFPAdSlot;

package/dist/esm/AdSlotsProvider.js

@@ -0,0 +1,25 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import React from 'react';
+import { b as lib_1 } from './index-fb49124c.js';
+import 'prop-types';
+
+var AdSlotsProvider = function AdSlotsProvider(_ref) {
+  var children = _ref.children,
+      networkID = _ref.networkID,
+      _ref$targeting = _ref.targeting,
+      targeting = _ref$targeting === undefined ? {} : _ref$targeting,
+      _ref$singleRequest = _ref.singleRequest,
+      singleRequest = _ref$singleRequest === undefined ? true : _ref$singleRequest;
+
+  return React.createElement(
+    lib_1,
+    {
+      dfpNetworkId: networkID,
+      targeting: targeting,
+      singleRequest: singleRequest,
+      lazyLoad: { fetchMarginPercent: 500, renderMarginPercent: 200, mobileScaling: 2.0 } },
+    children
+  );
+};
+
+export default AdSlotsProvider;

package/dist/esm/AlphabeticList.js

@@ -0,0 +1,131 @@
+import './_commonjsHelpers-0c4b6f40.js';
+import './_to-object-16fd8b46.js';
+import './core.get-iterator-method-f5c0d66a.js';
+import './_iter-detect-6e099a34.js';
+import './from-2c0a5f49.js';
+import { _ as _toConsumableArray } from './toConsumableArray-8712d678.js';
+import './_object-pie-33c40e79.js';
+import { _ as _extends } from './extends-6e00b262.js';
+import './_object-sap-56bb8073.js';
+import React, { useRef, useEffect } from 'react';
+import { _ as _Object$keys } from './keys-04cdec91.js';
+
+var sortByName = function sortByName(arr) {
+  var items = [].concat(_toConsumableArray(arr));
+  items.sort(function (a, b) {
+    var nameA = a.name.toUpperCase();
+    var nameB = b.name.toUpperCase();
+    if (nameA < nameB) {
+      return -1;
+    }
+    if (nameA > nameB) {
+      return 1;
+    }
+    return 0;
+  });
+  return items;
+};
+
+var AlphabeticList = function AlphabeticList(_ref) {
+  var _ref$dataRecord = _ref.dataRecord,
+      dataRecord = _ref$dataRecord === undefined ? [] : _ref$dataRecord;
+
+  var dataList = {};
+  if (dataRecord && dataRecord.length > 0) {
+    var sortedData = sortByName(dataRecord);
+    sortedData.forEach(function (item) {
+      var firstLetter = item.name.charAt(0).toUpperCase();
+      if (!dataList[firstLetter]) {
+        dataList[firstLetter] = [];
+      }
+      dataList[firstLetter].push(item);
+    });
+  }
+
+  var alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
+  var itemsRef = useRef([]);
+
+  var renderAlbhabetList = function renderAlbhabetList() {
+    var style = {
+      fontWeight: '600',
+      fontSize: '30px',
+      textDecoration: 'none',
+      padding: '0 10px',
+      color: 'grey'
+    };
+    return React.createElement(
+      'div',
+      { className: 'd-flex flex-wrap mb-3' },
+      alphabet.map(function (letter, i) {
+        if (dataList[letter]) {
+          return React.createElement(
+            'a',
+            {
+              key: i,
+              onClick: function onClick() {
+                var index = _Object$keys(dataList).findIndex(function (i) {
+                  return i === letter;
+                });
+                if (itemsRef.current && itemsRef.current[index]) {
+                  window.scrollTo(0, itemsRef.current[index].offsetTop);
+                }
+              } },
+            React.createElement(
+              'span',
+              {
+                style: _extends({}, style, {
+                  color: 'black'
+                }) },
+              letter
+            )
+          );
+        }
+        return React.createElement(
+          'span',
+          { key: i, style: style },
+          letter
+        );
+      })
+    );
+  };
+
+  useEffect(function () {
+    itemsRef.current = itemsRef.current.slice(0, _Object$keys(dataList).length);
+  }, [dataList]);
+
+  return React.createElement(
+    React.Fragment,
+    null,
+    renderAlbhabetList(),
+    _Object$keys(dataList).map(function (letter, index) {
+      return React.createElement(
+        React.Fragment,
+        { key: index },
+        React.createElement(
+          'h3',
+          { ref: function ref(el) {
+              return itemsRef.current[index] = el;
+            } },
+          letter
+        ),
+        React.createElement(
+          'ul',
+          null,
+          dataList[letter].map(function (item, i) {
+            return React.createElement(
+              'li',
+              { key: i },
+              React.createElement(
+                'a',
+                { href: item.url },
+                item.name
+              )
+            );
+          })
+        )
+      );
+    })
+  );
+};
+
+export default AlphabeticList;