@folklore/ads 0.0.109 → 0.0.111

package/dist/cjs.js

@@ -2,10 +2,9 @@
 
 var PropTypes = require('prop-types');
 var classNames = require('classnames');
-var isFunction = require('lodash/isFunction');
-var isObject = require('lodash/isObject');
 var React = require('react');
 var isArray = require('lodash/isArray');
+var isObject = require('lodash/isObject');
 var sortBy = require('lodash/sortBy');
 var uniqBy = require('lodash/uniqBy');
 var debounce = require('lodash/debounce');
@@ -29,7 +28,7 @@ const adTargeting = PropTypes.shape({
   domain: PropTypes.string
 });
 
-var propTypes$4 = /*#__PURE__*/Object.freeze({
+var propTypes = /*#__PURE__*/Object.freeze({
     __proto__: null,
     adPath: adPath,
     adSize: adSize,
@@ -52,42 +51,45 @@ function normalizeAdSizes(size) {
 function getAdSizes(sizes) {
   return uniqBy(sizes, size => isArray(size) ? size.join('x') : size);
 }
-const getMinimumAdSize = sizes => getAdSizes(sizes).filter(size => size !== 'fluid').reduce((minimumSize, size) => ({
-  width: Math.min(minimumSize.width, size[0]),
-  height: Math.min(minimumSize.height, size[1])
-}), {
-  width: Infinity,
-  height: Infinity
-});
-const sizeFitsInViewport = (size, viewport) => size === 'fluid' && viewport[0] > 600 || size !== 'fluid' && (viewport[0] === 0 || size[0] <= viewport[0]) && (viewport[1] === 0 || size[1] <= viewport[1]);
-const getSortedViewports = viewports => sortBy(Object.keys(viewports).map(name => ({
-  name,
-  size: viewports[name]
-})), [viewport => viewport.size[0]]).reverse();
-const buildSizeMappingFromViewports = (sizeMapping, viewports) => isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, _ref) => {
-  let {
+function getMinimumAdSize(sizes) {
+  return getAdSizes(sizes).filter(size => size !== 'fluid').reduce((minimumSize, size) => ({
+    width: Math.min(minimumSize.width, size[0]),
+    height: Math.min(minimumSize.height, size[1])
+  }), {
+    width: Infinity,
+    height: Infinity
+  });
+}
+function sizeFitsInViewport(size, viewport) {
+  return size === 'fluid' && viewport[0] > 600 || size !== 'fluid' && (viewport[0] === 0 || size[0] <= viewport[0]) && (viewport[1] === 0 || size[1] <= viewport[1]);
+}
+function getSortedViewports(viewports) {
+  return sortBy(Object.keys(viewports).map(name => ({
+    name,
+    size: viewports[name]
+  })), [viewport => viewport.size[0]]).reverse();
+}
+function buildSizeMappingFromViewports(sizeMapping, viewports) {
+  return isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, {
     name,
     size: viewPortSize
-  } = _ref;
-  return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
-}, []) : sizeMapping;
-const buildSizeMappingFromSizes = (sizes, viewports) => getSortedViewports(viewports).map(_ref2 => {
-  let {
+  }) => typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping, []) : sizeMapping;
+}
+function buildSizeMappingFromSizes(sizes, viewports) {
+  return getSortedViewports(viewports).map(({
     name,
     size: viewPortSize
-  } = _ref2;
-  return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
-});
-const getSizeMappingFromSlot = (_ref3, viewports) => {
-  let {
-    size: allSizes = [],
-    sizeMapping = null
-  } = _ref3;
+  }) => [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))]);
+}
+function getSizeMappingFromSlot({
+  size: allSizes = [],
+  sizeMapping = null
+}, viewports) {
   if (sizeMapping === true) {
     return buildSizeMappingFromSizes(allSizes, viewports);
   }
   return sizeMapping !== null ? buildSizeMappingFromViewports(sizeMapping, viewports) : null;
-};
+}
 function getSizeFromSizeMapping(sizeMapping) {
   if (sizeMapping === null) {
     return null;
@@ -107,8 +109,7 @@ function getSizeFromSizeMapping(sizeMapping) {
 }
 
 class AdSlot extends EventEmitter {
-  constructor(id, path, size) {
-    let opts = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+  constructor(id, path, size, opts = {}) {
     super();
     this.options = {
       sizeMapping: null,
@@ -336,8 +337,7 @@ class AdsManager extends EventEmitter {
       [index.id]: [item.slug]
     } : null;
   }
-  constructor() {
-    let opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  constructor(opts = {}) {
     super();
     this.options = {
       disabled: false,
@@ -505,8 +505,7 @@ class AdsManager extends EventEmitter {
       googletag.pubads().setRequestNonPersonalizedAds(disablePersonnalizedAds ? 1 : 0);
     });
   }
-  createSlot(path, size) {
-    let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  createSlot(path, size, opts = {}) {
     const {
       id: providedId = null
     } = opts;
@@ -683,66 +682,26 @@ const AdsContext = /*#__PURE__*/React.createContext({
   ready: false
 });
 const useAdsContext = () => React.useContext(AdsContext);
-const propTypes$3 = {
-  children: PropTypes.node.isRequired,
-  defaultSlotPath: PropTypes.string,
-  slotsPath: PropTypes.objectOf(PropTypes.string),
-  disableSingleRequest: PropTypes.bool,
-  disableVideoAds: PropTypes.bool,
-  disableLazyLoad: PropTypes.bool,
-  autoInit: PropTypes.bool,
-  resizeDebounceDelay: PropTypes.number,
-  refreshOnResize: PropTypes.bool,
-  mobileScaling: PropTypes.number,
-  renderMarginPercent: PropTypes.number,
-  fetchMarginPercent: PropTypes.number,
-  viewport: PropTypes.string,
-  slots: adSlots,
-  viewports: adViewports,
-  richAdComponents: PropTypes.objectOf(PropTypes.elementType),
-  disabled: PropTypes.bool,
-  disableTracking: PropTypes.bool
-};
-const defaultProps$2 = {
-  defaultSlotPath: null,
-  slotsPath: null,
-  disableSingleRequest: false,
-  disableVideoAds: false,
-  disableLazyLoad: false,
-  autoInit: true,
-  resizeDebounceDelay: 500,
-  refreshOnResize: false,
-  mobileScaling: 1.0,
-  renderMarginPercent: 100,
-  fetchMarginPercent: 300,
-  viewport: null,
-  slots: slots,
-  viewports: viewports,
-  richAdComponents: null,
-  disabled: false,
-  disableTracking: false
-};
-function AdsProvider(_ref) {
-  let {
-    children,
-    defaultSlotPath,
-    slotsPath,
-    disableSingleRequest,
-    disableVideoAds,
-    disableLazyLoad,
-    autoInit,
-    resizeDebounceDelay,
-    refreshOnResize,
-    mobileScaling,
-    renderMarginPercent,
-    fetchMarginPercent,
-    viewport,
-    viewports,
-    slots,
-    richAdComponents,
-    disabled,
-    disableTracking
-  } = _ref;
+function AdsProvider({
+  children,
+  defaultSlotPath = null,
+  slotsPath = null,
+  disableSingleRequest = false,
+  disableVideoAds = false,
+  disableLazyLoad = false,
+  autoInit = true,
+  resizeDebounceDelay = 500,
+  refreshOnResize = false,
+  mobileScaling = 1.0,
+  renderMarginPercent = 100,
+  fetchMarginPercent = 300,
+  viewport = null,
+  viewports: viewports$1 = viewports,
+  slots: slots$1 = slots,
+  richAdComponents = null,
+  disabled = false,
+  disableTracking = false
+}) {
   const [ready, setReady] = React.useState(false);
   const adsRef = React.useRef(null);
   const ads = React.useMemo(() => {
@@ -793,12 +752,12 @@ function AdsProvider(_ref) {
       onResize.cancel();
     };
   }, [ads, resizeDebounceDelay, refreshOnResize]);
-  const slotsWithSizeMapping = React.useMemo(() => Object.keys(slots || {}).reduce((map, key) => {
-    const slot = slots[key];
+  const slotsWithSizeMapping = React.useMemo(() => Object.keys(slots$1 || {}).reduce((map, key) => {
+    const slot = slots$1[key];
     const {
       size
     } = slot;
-    const sizeMapping = getSizeMappingFromSlot(slot, viewports);
+    const sizeMapping = getSizeMappingFromSlot(slot, viewports$1);
     return {
       ...map,
       [key]: {
@@ -807,51 +766,44 @@ function AdsProvider(_ref) {
         sizeMapping
       }
     };
-  }, {}), []);
-  const finalSlotsPath = React.useMemo(() => defaultSlotPath !== null ? {
-    default: defaultSlotPath,
-    ...slotsPath
-  } : {
-    ...slotsPath
+  }, {}), [slots$1, viewports$1]);
+  const finalSlotsPath = React.useMemo(() => {
+    if (defaultSlotPath !== null && slotsPath) {
+      return {
+        default: defaultSlotPath,
+        ...slotsPath
+      };
+    }
+    return slotsPath ? {
+      ...slotsPath
+    } : {};
   }, [defaultSlotPath, slotsPath]);
   const value = React.useMemo(() => ({
     ready,
     ads,
-    viewports,
+    viewports: viewports$1,
     viewport,
     slots: slotsWithSizeMapping,
     slotsPath: finalSlotsPath,
     trackingDisabled: disableTracking,
     richAdComponents
-  }), [ready, ads, viewports, viewport, slotsWithSizeMapping, finalSlotsPath, disableTracking, richAdComponents]);
+  }), [ready, ads, viewports$1, viewport, slotsWithSizeMapping, finalSlotsPath, disableTracking, richAdComponents]);
   return /*#__PURE__*/jsxRuntime.jsx(AdsContext.Provider, {
     value: value,
     children: children
   });
 }
-AdsProvider.propTypes = propTypes$3;
-AdsProvider.defaultProps = defaultProps$2;
 
-const AdsTargetingContext = /*#__PURE__*/React.createContext(null);
-const useAdsTargeting = () => React.useContext(AdsTargetingContext);
-const propTypes$2 = {
-  children: PropTypes.node.isRequired,
-  // eslint-disable-next-line react/forbid-prop-types
-  targeting: PropTypes.object,
-  replace: PropTypes.bool
+const defaultTargeting = {
+  domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
 };
-const defaultProps$1 = {
-  targeting: {
-    domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
-  },
-  replace: false
-};
-function AdsTargetingProvider(_ref) {
-  let {
-    children,
-    targeting,
-    replace
-  } = _ref;
+const AdsTargetingContext = /*#__PURE__*/React.createContext(defaultTargeting);
+const useAdsTargeting = () => React.useContext(AdsTargetingContext);
+function AdsTargetingProvider({
+  children,
+  targeting = defaultTargeting,
+  replace = false
+}) {
   const previousTargeting = useAdsTargeting();
   const mergedTargeting = React.useMemo(() => replace ? targeting : {
     ...previousTargeting,
@@ -862,21 +814,12 @@ function AdsTargetingProvider(_ref) {
     children: children
   });
 }
-AdsTargetingProvider.propTypes = propTypes$2;
-AdsTargetingProvider.defaultProps = defaultProps$1;
 
 /* eslint-disable react/jsx-props-no-spreading */
-const propTypes$1 = {
-  richAd: PropTypes.shape({
-    type: PropTypes.string.isRequired
-  }).isRequired
-};
-const defaultProps = {};
-function RichAd(_ref) {
-  let {
-    richAd,
-    ...props
-  } = _ref;
+function RichAd({
+  richAd,
+  ...props
+}) {
   const {
     type = null,
     ...richAdProps
@@ -890,12 +833,10 @@ function RichAd(_ref) {
     ...richAdProps
   }) : null;
 }
-RichAd.propTypes = propTypes$1;
-RichAd.defaultProps = defaultProps;
 
 function useAdsTracking() {
   const tracking$1 = tracking.useTracking() || null;
-  const trackEvent = React.useCallback((action, slot, renderEvent) => {
+  const trackEvent = React.useCallback((action, slot = null, renderEvent = null) => {
     if (tracking$1 !== null && typeof tracking$1.trackAd !== 'undefined') {
       tracking$1.trackAd(action, slot, renderEvent);
     }
@@ -903,21 +844,20 @@ function useAdsTracking() {
   return trackEvent;
 }
 
-function useAd(path, size) {
-  let {
-    id,
-    sizeMapping = null,
-    viewport = null,
-    targeting = null,
-    categoryExclusions = null,
-    refreshInterval = null,
-    alwaysRender = false,
-    onRender = null,
-    onDestroy = null,
-    disabled = false,
-    disableTracking = false,
-    rootMargin = '300px'
-  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+function useAd(path, size, {
+  id,
+  sizeMapping = null,
+  viewport = null,
+  targeting = null,
+  categoryExclusions = null,
+  refreshInterval = null,
+  alwaysRender = false,
+  onRender = null,
+  onDestroy = null,
+  disabled = false,
+  disableTracking = false,
+  rootMargin = '300px'
+} = {}) {
   const {
     ads: adsManager,
     viewports,
@@ -925,9 +865,9 @@ function useAd(path, size) {
     trackingDisabled: globalTrackingDisabled = false
   } = useAdsContext();
   const trackAd = useAdsTracking();
-  const track = React.useCallback(function () {
+  const track = React.useCallback((action, slot = null, renderEvent = null) => {
     if (!disableTracking && !globalTrackingDisabled) {
-      trackAd(...arguments);
+      trackAd(action, slot, renderEvent);
     }
   }, [disableTracking, globalTrackingDisabled, trackAd]);
 
@@ -935,7 +875,7 @@ function useAd(path, size) {
   const {
     ref: refObserver,
     entry: {
-      isIntersecting
+      isIntersecting = false
     }
   } = hooks.useIntersectionObserver({
     rootMargin,
@@ -965,10 +905,7 @@ function useAd(path, size) {
       adsManager.destroySlot(currentSlot);
     }
     const viewportSize = viewport !== null ? viewports[viewport] || null : null;
-    const [, viewportFixedSize = null] = sizeMapping !== null && viewportSize !== null ? sizeMapping.find(_ref => {
-      let [itViewport] = _ref;
-      return itViewport.join('x') === viewportSize.join('x');
-    }) || [] : [];
+    const [, viewportFixedSize = null] = sizeMapping !== null && viewportSize !== null ? sizeMapping.find(([itViewport]) => itViewport.join('x') === viewportSize.join('x')) || [] : [];
     const newSlot = path !== null && !disabled ? adsManager.createSlot(path, viewportFixedSize || size, {
       id,
       visible: isVisible,
@@ -1115,7 +1052,7 @@ function parseRichAd(data) {
   } catch (e) {}
   return richAd;
 }
-function useRichAd(containerRef, id, opts) {
+function useRichAd(containerRef, id, opts = {}) {
   const [richAd, setRichAd] = React.useState(null);
   const {
     onRichAd = null
@@ -1153,57 +1090,31 @@ function useRichAd(containerRef, id, opts) {
 }
 
 /* eslint-disable react/require-default-props */
-const propTypes = {
-  slot: PropTypes.string.isRequired,
-  path: adPath,
-  size: adSize,
-  sizeMapping: adSizeMapping,
-  viewport: PropTypes.string,
-  targeting: adTargeting,
-  refreshInterval: PropTypes.number,
-  alwaysRender: PropTypes.bool,
-  disabled: PropTypes.bool,
-  disableTracking: PropTypes.bool,
-  shouldKeepSize: PropTypes.bool,
-  withoutStyle: PropTypes.bool,
-  withoutMinimumSize: PropTypes.bool,
-  withReactId: PropTypes.bool,
-  className: PropTypes.string,
-  emptyClassName: PropTypes.string,
-  adClassName: PropTypes.string,
-  richAdClassName: PropTypes.string,
-  richAdIframeClassName: PropTypes.string,
-  onRender: PropTypes.func,
-  onDestroy: PropTypes.func,
-  onRichAd: PropTypes.func,
-  slotRef: PropTypes.oneOfType([PropTypes.func, PropTypes.object])
-};
-function Ad(_ref) {
-  let {
-    slot: slotName = null,
-    path: providedPath = null,
-    size: providedSize = null,
-    sizeMapping: providedSizeMapping = null,
-    viewport: providedViewport = null,
-    targeting: providedTargeting = null,
-    refreshInterval: providedRefreshInterval = null,
-    alwaysRender = true,
-    disabled: providedDisabled = false,
-    disableTracking = false,
-    shouldKeepSize = false,
-    withoutStyle = false,
-    withoutMinimumSize = false,
-    withReactId = false,
-    className = null,
-    emptyClassName = null,
-    adClassName = null,
-    richAdClassName = null,
-    richAdIframeClassName = null,
-    onRender = null,
-    onDestroy = null,
-    onRichAd = null,
-    slotRef = null
-  } = _ref;
+function Ad({
+  slot: slotName,
+  path: providedPath = null,
+  size: providedSize = null,
+  sizeMapping: providedSizeMapping = null,
+  viewport: providedViewport = null,
+  targeting: providedTargeting = null,
+  refreshInterval: providedRefreshInterval = null,
+  alwaysRender = true,
+  disabled: providedDisabled = false,
+  disableTracking = false,
+  shouldKeepSize = false,
+  withoutStyle = false,
+  withoutMinimumSize = false,
+  withReactId = false,
+  className = null,
+  emptyClassName = null,
+  adClassName = null,
+  richAdClassName = null,
+  richAdIframeClassName = null,
+  onRender = null,
+  onDestroy = null,
+  onRichAd = null,
+  slotRef = null
+}) {
   const {
     slots = null,
     slotsPath = null,
@@ -1213,7 +1124,7 @@ function Ad(_ref) {
   const {
     default: defaultSlotPath = null
   } = slotsPath || {};
-  const slot = slotName !== null && slots !== null ? slots[slotName] || null : null;
+  const slot = slotName && slots !== null ? slots[slotName] || null : null;
   const {
     sizeMapping: slotSizeMapping = null,
     size: slotSize = null,
@@ -1312,9 +1223,9 @@ function Ad(_ref) {
   const richAd = useRichAd(adContainerRef, id, {
     onRichAd
   });
-  if (slotRef !== null && isFunction(slotRef)) {
+  if (slotRef !== null && typeof slotRef === 'function') {
     slotRef(slotObject);
-  } else if (slotRef !== null && isObject(slotRef)) {
+  } else if (slotRef !== null && typeof slotRef === 'object') {
     // eslint-disable-next-line no-param-reassign
     slotRef.current = slotObject;
   }
@@ -1376,14 +1287,13 @@ function Ad(_ref) {
     })
   });
 }
-Ad.propTypes = propTypes;
 
 exports.Ad = Ad;
 exports.AdSlot = AdSlot;
 exports.AdsManager = AdsManager;
 exports.AdsProvider = AdsProvider;
 exports.AdsTargetingProvider = AdsTargetingProvider;
-exports.PropTypes = propTypes$4;
+exports.PropTypes = propTypes;
 exports.RichAd = RichAd;
 exports.buildSizeMappingFromSizes = buildSizeMappingFromSizes;
 exports.buildSizeMappingFromViewports = buildSizeMappingFromViewports;