@folklore/ads 0.0.109 → 0.0.110

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,33 +51,43 @@ 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 {
-    name,
-    size: viewPortSize
-  } = _ref;
-  return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
-}, []) : sizeMapping;
-const buildSizeMappingFromSizes = (sizes, viewports) => getSortedViewports(viewports).map(_ref2 => {
-  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: viewPortSize
-  } = _ref2;
-  return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
-});
-const getSizeMappingFromSlot = (_ref3, viewports) => {
+    size: viewports[name]
+  })), [viewport => viewport.size[0]]).reverse();
+}
+function buildSizeMappingFromViewports(sizeMapping, viewports) {
+  return isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, _ref) => {
+    let {
+      name,
+      size: viewPortSize
+    } = _ref;
+    return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
+  }, []) : sizeMapping;
+}
+function buildSizeMappingFromSizes(sizes, viewports) {
+  return getSortedViewports(viewports).map(_ref2 => {
+    let {
+      name,
+      size: viewPortSize
+    } = _ref2;
+    return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
+  });
+}
+function getSizeMappingFromSlot(_ref3, viewports) {
   let {
     size: allSizes = [],
     sizeMapping = null
@@ -87,7 +96,7 @@ const getSizeMappingFromSlot = (_ref3, viewports) => {
     return buildSizeMappingFromSizes(allSizes, viewports);
   }
   return sizeMapping !== null ? buildSizeMappingFromViewports(sizeMapping, viewports) : null;
-};
+}
 function getSizeFromSizeMapping(sizeMapping) {
   if (sizeMapping === null) {
     return null;
@@ -683,65 +692,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
+    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
   } = _ref;
   const [ready, setReady] = React.useState(false);
   const adsRef = React.useRef(null);
@@ -793,12 +763,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,50 +777,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 defaultProps$1 = {
-  targeting: {
-    domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
-  },
-  replace: false
+const defaultTargeting = {
+  domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
 };
+const AdsTargetingContext = /*#__PURE__*/React.createContext(defaultTargeting);
+const useAdsTargeting = () => React.useContext(AdsTargetingContext);
 function AdsTargetingProvider(_ref) {
   let {
     children,
-    targeting,
-    replace
+    targeting = defaultTargeting,
+    replace = false
   } = _ref;
   const previousTargeting = useAdsTargeting();
   const mergedTargeting = React.useMemo(() => replace ? targeting : {
@@ -862,16 +826,8 @@ 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,
@@ -890,12 +846,12 @@ 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(function (action) {
+    let slot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let renderEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     if (tracking$1 !== null && typeof tracking$1.trackAd !== 'undefined') {
       tracking$1.trackAd(action, slot, renderEvent);
     }
@@ -925,9 +881,11 @@ function useAd(path, size) {
     trackingDisabled: globalTrackingDisabled = false
   } = useAdsContext();
   const trackAd = useAdsTracking();
-  const track = React.useCallback(function () {
+  const track = React.useCallback(function (action) {
+    let slot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let renderEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     if (!disableTracking && !globalTrackingDisabled) {
-      trackAd(...arguments);
+      trackAd(action, slot, renderEvent);
     }
   }, [disableTracking, globalTrackingDisabled, trackAd]);
 
@@ -1115,7 +1073,8 @@ function parseRichAd(data) {
   } catch (e) {}
   return richAd;
 }
-function useRichAd(containerRef, id, opts) {
+function useRichAd(containerRef, id) {
+  let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const [richAd, setRichAd] = React.useState(null);
   const {
     onRichAd = null
@@ -1153,34 +1112,9 @@ 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,
+    slot: slotName,
     path: providedPath = null,
     size: providedSize = null,
     sizeMapping: providedSizeMapping = null,
@@ -1213,7 +1147,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 +1246,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 +1310,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;

package/dist/es.js

@@ -1,9 +1,8 @@
 import PropTypes from 'prop-types';
 import classNames from 'classnames';
-import isFunction from 'lodash/isFunction';
-import isObject from 'lodash/isObject';
-import React, { useContext, useState, useRef, useMemo, useEffect, useCallback, useId } from 'react';
+import React, { useContext, useState, useRef, useMemo, useEffect, createContext, useCallback, useId } from 'react';
 import isArray from 'lodash/isArray';
+import isObject from 'lodash/isObject';
 import sortBy from 'lodash/sortBy';
 import uniqBy from 'lodash/uniqBy';
 import debounce from 'lodash/debounce';
@@ -27,7 +26,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,
@@ -50,33 +49,43 @@ 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 {
-    name,
-    size: viewPortSize
-  } = _ref;
-  return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
-}, []) : sizeMapping;
-const buildSizeMappingFromSizes = (sizes, viewports) => getSortedViewports(viewports).map(_ref2 => {
-  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: viewPortSize
-  } = _ref2;
-  return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
-});
-const getSizeMappingFromSlot = (_ref3, viewports) => {
+    size: viewports[name]
+  })), [viewport => viewport.size[0]]).reverse();
+}
+function buildSizeMappingFromViewports(sizeMapping, viewports) {
+  return isObject(sizeMapping) && !isArray(sizeMapping) ? getSortedViewports(viewports).reduce((newSizeMapping, _ref) => {
+    let {
+      name,
+      size: viewPortSize
+    } = _ref;
+    return typeof sizeMapping[name] !== 'undefined' ? [...newSizeMapping, [viewPortSize, sizeMapping[name]]] : newSizeMapping;
+  }, []) : sizeMapping;
+}
+function buildSizeMappingFromSizes(sizes, viewports) {
+  return getSortedViewports(viewports).map(_ref2 => {
+    let {
+      name,
+      size: viewPortSize
+    } = _ref2;
+    return [viewPortSize, sizes.filter(size => sizeFitsInViewport(size, name === 'default' ? [300, 300] : viewPortSize))];
+  });
+}
+function getSizeMappingFromSlot(_ref3, viewports) {
   let {
     size: allSizes = [],
     sizeMapping = null
@@ -85,7 +94,7 @@ const getSizeMappingFromSlot = (_ref3, viewports) => {
     return buildSizeMappingFromSizes(allSizes, viewports);
   }
   return sizeMapping !== null ? buildSizeMappingFromViewports(sizeMapping, viewports) : null;
-};
+}
 function getSizeFromSizeMapping(sizeMapping) {
   if (sizeMapping === null) {
     return null;
@@ -681,65 +690,26 @@ const AdsContext = /*#__PURE__*/React.createContext({
   ready: false
 });
 const useAdsContext = () => 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
+    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
   } = _ref;
   const [ready, setReady] = useState(false);
   const adsRef = useRef(null);
@@ -791,12 +761,12 @@ function AdsProvider(_ref) {
       onResize.cancel();
     };
   }, [ads, resizeDebounceDelay, refreshOnResize]);
-  const slotsWithSizeMapping = useMemo(() => Object.keys(slots || {}).reduce((map, key) => {
-    const slot = slots[key];
+  const slotsWithSizeMapping = 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]: {
@@ -805,50 +775,44 @@ function AdsProvider(_ref) {
         sizeMapping
       }
     };
-  }, {}), []);
-  const finalSlotsPath = useMemo(() => defaultSlotPath !== null ? {
-    default: defaultSlotPath,
-    ...slotsPath
-  } : {
-    ...slotsPath
+  }, {}), [slots$1, viewports$1]);
+  const finalSlotsPath = useMemo(() => {
+    if (defaultSlotPath !== null && slotsPath) {
+      return {
+        default: defaultSlotPath,
+        ...slotsPath
+      };
+    }
+    return slotsPath ? {
+      ...slotsPath
+    } : {};
   }, [defaultSlotPath, slotsPath]);
   const value = 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__*/jsx(AdsContext.Provider, {
     value: value,
     children: children
   });
 }
-AdsProvider.propTypes = propTypes$3;
-AdsProvider.defaultProps = defaultProps$2;
 
-const AdsTargetingContext = /*#__PURE__*/React.createContext(null);
-const useAdsTargeting = () => useContext(AdsTargetingContext);
-const propTypes$2 = {
-  children: PropTypes.node.isRequired,
-  // eslint-disable-next-line react/forbid-prop-types
-  targeting: PropTypes.object,
-  replace: PropTypes.bool
-};
-const defaultProps$1 = {
-  targeting: {
-    domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
-  },
-  replace: false
+const defaultTargeting = {
+  domain: typeof window !== 'undefined' ? `${window.location.protocol}//${window.location.host}` : null
 };
+const AdsTargetingContext = /*#__PURE__*/createContext(defaultTargeting);
+const useAdsTargeting = () => useContext(AdsTargetingContext);
 function AdsTargetingProvider(_ref) {
   let {
     children,
-    targeting,
-    replace
+    targeting = defaultTargeting,
+    replace = false
   } = _ref;
   const previousTargeting = useAdsTargeting();
   const mergedTargeting = useMemo(() => replace ? targeting : {
@@ -860,16 +824,8 @@ 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,
@@ -888,12 +844,12 @@ function RichAd(_ref) {
     ...richAdProps
   }) : null;
 }
-RichAd.propTypes = propTypes$1;
-RichAd.defaultProps = defaultProps;
 
 function useAdsTracking() {
   const tracking = useTracking() || null;
-  const trackEvent = useCallback((action, slot, renderEvent) => {
+  const trackEvent = useCallback(function (action) {
+    let slot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let renderEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     if (tracking !== null && typeof tracking.trackAd !== 'undefined') {
       tracking.trackAd(action, slot, renderEvent);
     }
@@ -923,9 +879,11 @@ function useAd(path, size) {
     trackingDisabled: globalTrackingDisabled = false
   } = useAdsContext();
   const trackAd = useAdsTracking();
-  const track = useCallback(function () {
+  const track = useCallback(function (action) {
+    let slot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    let renderEvent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
     if (!disableTracking && !globalTrackingDisabled) {
-      trackAd(...arguments);
+      trackAd(action, slot, renderEvent);
     }
   }, [disableTracking, globalTrackingDisabled, trackAd]);
 
@@ -1113,7 +1071,8 @@ function parseRichAd(data) {
   } catch (e) {}
   return richAd;
 }
-function useRichAd(containerRef, id, opts) {
+function useRichAd(containerRef, id) {
+  let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   const [richAd, setRichAd] = useState(null);
   const {
     onRichAd = null
@@ -1151,34 +1110,9 @@ 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,
+    slot: slotName,
     path: providedPath = null,
     size: providedSize = null,
     sizeMapping: providedSizeMapping = null,
@@ -1211,7 +1145,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,
@@ -1310,9 +1244,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;
   }
@@ -1374,6 +1308,5 @@ function Ad(_ref) {
     })
   });
 }
-Ad.propTypes = propTypes;
 
-export { Ad, AdSlot, AdsManager, AdsProvider, AdsTargetingProvider, propTypes$4 as PropTypes, RichAd, buildSizeMappingFromSizes, buildSizeMappingFromViewports, getAdSizes, getMinimumAdSize, getSizeFromSizeMapping, getSizeMappingFromSlot, getSortedViewports, normalizeAdSizes, sizeFitsInViewport, slots, useAd, useAdsContext, useAdsTargeting, useAdsTracking, useRichAd, viewports };
+export { Ad, AdSlot, AdsManager, AdsProvider, AdsTargetingProvider, propTypes as PropTypes, RichAd, buildSizeMappingFromSizes, buildSizeMappingFromViewports, getAdSizes, getMinimumAdSize, getSizeFromSizeMapping, getSizeMappingFromSlot, getSortedViewports, normalizeAdSizes, sizeFitsInViewport, slots, useAd, useAdsContext, useAdsTargeting, useAdsTracking, useRichAd, viewports };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@folklore/ads",
-    "version": "0.0.109",
+    "version": "0.0.110",
     "description": "Ads library",
     "keywords": [
         "javascript",
@@ -29,12 +29,15 @@
     ],
     "main": "dist/cjs.js",
     "module": "dist/es.js",
+    "types": "types/index.d.ts",
     "files": [
-        "dist"
+        "dist",
+        "types"
     ],
     "scripts": {
-        "clean": "rm -rf dist",
-        "build": "rollup --bundleConfigAsCjs --config ../../rollup.config.js",
+        "clean": "rm -rf dist && rm -rf types",
+        "build:types": "tsc --p tsconfig.json",
+        "build": "npm run build:types && rollup --bundleConfigAsCjs --config ../../rollup.config.js",
         "prepare": "npm run clean && npm run build"
     },
     "devDependencies": {
@@ -50,7 +53,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "6879f02e1991265ab2248de470fbf8e1240483a9",
+    "gitHead": "94ad547d193769ed8f6a056adee68f1b2b5c8120",
     "dependencies": {
         "@folklore/hooks": "^0.0.73",
         "@folklore/tracking": "^0.0.29",

package/types/Ad.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'react';
+import { AdSize, AdSizeMapping, AdsTargeting } from './types';
+import AdSlot from './AdSlot';
+export interface AdProps {
+    slot: string;
+    path?: string | null;
+    size?: AdSize[] | null;
+    sizeMapping?: AdSizeMapping[] | null;
+    viewport?: string | null;
+    targeting?: AdsTargeting | null;
+    refreshInterval?: number | null;
+    alwaysRender?: boolean;
+    disabled?: boolean;
+    disableTracking?: boolean;
+    shouldKeepSize?: boolean;
+    withoutStyle?: boolean;
+    withoutMinimumSize?: boolean;
+    withReactId?: boolean;
+    className?: string | null;
+    emptyClassName?: string | null;
+    adClassName?: string | null;
+    richAdClassName?: string | null;
+    richAdIframeClassName?: string | null;
+    onRender?: ((event: any) => void) | null;
+    onDestroy?: (() => void) | null;
+    onRichAd?: ((richAd: any) => void) | null;
+    slotRef?: Ref<AdSlot> | null;
+}
+declare function Ad({ slot: slotName, path: providedPath, size: providedSize, sizeMapping: providedSizeMapping, viewport: providedViewport, targeting: providedTargeting, refreshInterval: providedRefreshInterval, alwaysRender, disabled: providedDisabled, disableTracking, shouldKeepSize, withoutStyle, withoutMinimumSize, withReactId, className, emptyClassName, adClassName, richAdClassName, richAdIframeClassName, onRender, onDestroy, onRichAd, slotRef, }: AdProps): import("react/jsx-runtime").JSX.Element;
+export default Ad;

package/types/AdSlot.d.ts

@@ -0,0 +1,57 @@
+import EventEmitter from 'wolfy87-eventemitter';
+import { AdSizeMapping } from './types';
+export interface AdSlotOptions {
+    sizeMapping?: null | AdSizeMapping[];
+    targeting?: {
+        [key: string]: string | Array<string>;
+    };
+    categoryExclusions?: Array<string>;
+    visible?: boolean;
+}
+declare class AdSlot extends EventEmitter {
+    options: AdSlotOptions;
+    elementId: string;
+    adPath: string;
+    adSize: string | Array<string>;
+    visible: boolean;
+    wasVisible: boolean;
+    adSlot: any;
+    rendered: boolean;
+    displayed: boolean;
+    viewable: boolean;
+    renderEvent: any;
+    refreshDisabled: boolean;
+    destroyed: boolean;
+    constructor(id: any, path: any, size: any, opts?: {});
+    updateAdSlot(): void;
+    setAdSlot(slot: any): this;
+    setRenderEvent(event: any): this;
+    setViewable(viewable: any): void;
+    setDisplayed(displayed: any): this;
+    setVisible(visible: any): this;
+    setRefreshDisabled(): void;
+    setTargeting(targeting: any): void;
+    destroy(): void;
+    getElementId(): string;
+    getAdSlot(): any;
+    getAdPath(): string;
+    getAdSize(): string | string[];
+    getTargeting(): {
+        [key: string]: string | string[];
+    };
+    isVisible(): boolean;
+    isDefined(): boolean;
+    isDisplayed(): boolean;
+    isViewable(): boolean;
+    isRendered(): boolean;
+    isRefreshDisabled(): boolean;
+    isDestroyed(): boolean;
+    isEmpty(): any;
+    canBeDisplayed(): boolean;
+    getRenderedSize(): {
+        width: any;
+        height: any;
+        isFluid: boolean;
+    };
+}
+export default AdSlot;

package/types/AdsContext.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import AdsManager from './AdsManager';
+import { Slots, SlotsDefinition, Viewports } from './types';
+interface AdsContextType {
+    ready: boolean;
+    ads?: AdsManager;
+    viewports?: Viewports;
+    viewport?: string | null;
+    slots?: Slots;
+    slotsPath?: Record<string, string>;
+    trackingDisabled?: boolean;
+    richAdComponents?: Record<string, React.ElementType>;
+}
+declare const AdsContext: React.Context<AdsContextType>;
+export declare const useAdsContext: () => AdsContextType;
+interface AdsProviderProps {
+    children: React.ReactNode;
+    defaultSlotPath?: string | null;
+    slotsPath?: Record<string, string> | null;
+    disableSingleRequest?: boolean;
+    disableVideoAds?: boolean;
+    disableLazyLoad?: boolean;
+    autoInit?: boolean;
+    resizeDebounceDelay?: number;
+    refreshOnResize?: boolean;
+    mobileScaling?: number;
+    renderMarginPercent?: number;
+    fetchMarginPercent?: number;
+    viewport?: string | null;
+    viewports?: Viewports;
+    slots?: SlotsDefinition;
+    richAdComponents?: Record<string, React.ElementType> | null;
+    disabled?: boolean;
+    disableTracking?: boolean;
+}
+export declare function AdsProvider({ children, defaultSlotPath, slotsPath, disableSingleRequest, disableVideoAds, disableLazyLoad, autoInit, resizeDebounceDelay, refreshOnResize, mobileScaling, renderMarginPercent, fetchMarginPercent, viewport, viewports, slots, richAdComponents, disabled, disableTracking, }: AdsProviderProps): import("react/jsx-runtime").JSX.Element;
+export default AdsContext;

package/types/AdsManager.d.ts

@@ -0,0 +1,72 @@
+import EventEmitter from 'wolfy87-eventemitter';
+import AdSlot, { AdSlotOptions as BaseAdSlotOptions } from './AdSlot';
+import { AdSize } from './types';
+declare global {
+    interface Window {
+        googletag?: any;
+        refreshDisabledLineItems?: string[];
+    }
+}
+interface AdSlotOptions extends BaseAdSlotOptions {
+    id?: string;
+}
+declare class AdsManager extends EventEmitter {
+    static ID_PREFIX: string;
+    disabled: boolean;
+    personnalizedAdsDisabled: boolean;
+    ready: boolean;
+    enabled: boolean;
+    googletag: any;
+    slots: AdSlot[];
+    index: number;
+    options: {
+        disabled: boolean;
+        disablePersonnalizedAds: boolean;
+        disableSingleRequest: boolean;
+        disableLazyLoad: boolean;
+        disableVideoAds: boolean;
+        autoInit: boolean;
+        mobileScaling?: number;
+        renderMarginPercent?: number;
+        fetchMarginPercent?: number;
+    };
+    static getArticleTargeting(article: any): {
+        title: any;
+        slug: any;
+        postID: any;
+        categories: any;
+        authors: any;
+        sponsors: any;
+        GoogleSafeTargeting: any;
+    };
+    static getSectionTargeting(section: any): {
+        section: any;
+    };
+    static getIndexTargeting(index: any): {
+        index: any;
+    };
+    static getIndexItemTargeting(index: any, item: any): {
+        [index.id]: any[];
+    };
+    constructor(opts?: {});
+    createAdId(): string;
+    init(): void;
+    initGpt(): void;
+    onSlotRenderEnded(event: any): void;
+    onSlotImpressionViewable(event: any): void;
+    onSlotVisibleChange(visible: any, slot: any): void;
+    isReady(): boolean;
+    isDisabled(): boolean;
+    setDisabled(disabled: any): void;
+    disablePersonnalizedAds(disablePersonnalizedAds: any): void;
+    createSlot(path: string, size: AdSize, opts?: AdSlotOptions): AdSlot;
+    defineSlot(slot: any): void;
+    displaySlots(): boolean;
+    displaySlot(slot: any): void;
+    callDisplaySlot(slot: any): void;
+    destroySlot(id: any): void;
+    refreshSlot(id: any): void;
+    refreshSlots(ids: any): void;
+    refreshAllSlots(): void;
+}
+export default AdsManager;

package/types/AdsTargetingContext.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from 'react';
+import { AdsTargeting } from './types';
+interface AdsTargetingProviderProps {
+    children: ReactNode;
+    targeting?: AdsTargeting;
+    replace?: boolean;
+}
+declare const AdsTargetingContext: import("react").Context<AdsTargeting>;
+export declare const useAdsTargeting: () => AdsTargeting | null;
+export declare function AdsTargetingProvider({ children, targeting, replace, }: AdsTargetingProviderProps): import("react/jsx-runtime").JSX.Element;
+export default AdsTargetingContext;

package/types/RichAd.d.ts

@@ -0,0 +1,7 @@
+import { RichAd as RichAdType } from './types';
+export interface RichAdProps {
+    richAd: RichAdType;
+    [key: string]: any;
+}
+declare function RichAd({ richAd, ...props }: RichAdProps): import("react/jsx-runtime").JSX.Element;
+export default RichAd;

package/types/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/types/defaults.d.ts

@@ -0,0 +1,3 @@
+import { SlotsDefinition, Viewports } from './types';
+export declare const viewports: Viewports;
+export declare const slots: SlotsDefinition;

package/types/index.d.ts

@@ -0,0 +1,13 @@
+export * as PropTypes from "./propTypes";
+export { default as Ad } from "./Ad";
+export { default as RichAd } from "./RichAd";
+export * from "./AdsContext";
+export * from "./AdsTargetingContext";
+export * from "./defaults";
+export * from "./utils";
+export * from "./types";
+export { default as AdSlot } from "./AdSlot";
+export { default as AdsManager } from "./AdsManager";
+export { default as useAd } from "./useAd";
+export { default as useAdsTracking } from "./useAdsTracking";
+export { default as useRichAd } from "./useRichAd";

package/types/propTypes.d.ts

@@ -0,0 +1,7 @@
+export const adPath: any;
+export const adSize: any;
+export const adSizeMapping: any;
+export const adViewports: any;
+export const adSlot: any;
+export const adSlots: any;
+export const adTargeting: any;

package/types/types.d.ts

@@ -0,0 +1,34 @@
+export type AdSize = [number, number] | 'fluid';
+export type Viewport = [number, number];
+export type AdSizeMapping = [Viewport, AdSize[]];
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface Viewports {
+    [name: string]: Viewport;
+}
+export interface SlotDefinition {
+    sizeMapping?: Record<string, AdSize[]> | boolean | null | AdSizeMapping[] | null;
+    size?: AdSize[];
+    path?: string | null;
+}
+export interface Slot extends SlotDefinition {
+    sizeMapping?: AdSizeMapping[] | null;
+}
+export interface Slots {
+    [name: string]: Slot;
+}
+export interface SlotsDefinition {
+    [name: string]: SlotDefinition;
+}
+export interface AdsTargeting {
+    refreshAds?: 'inactive' | false | null | number;
+    disabled?: boolean;
+    viewport?: string | null;
+    [key: string]: any;
+}
+export interface RichAd {
+    type: string;
+    [key: string]: any;
+}

package/types/useAd.d.ts

@@ -0,0 +1,30 @@
+import AdSlot from './AdSlot';
+import { AdSizeMapping, AdsTargeting } from './types';
+interface UseAdOptions {
+    id?: string;
+    sizeMapping?: AdSizeMapping[] | null;
+    viewport?: string | null;
+    targeting?: AdsTargeting | null;
+    categoryExclusions?: string[] | null;
+    refreshInterval?: number | null;
+    alwaysRender?: boolean;
+    onRender?: (event: any) => void | null;
+    onDestroy?: (event: any) => void | null;
+    disabled?: boolean;
+    disableTracking?: boolean;
+    rootMargin?: string;
+}
+declare function useAd(path: string, size: any, { id, sizeMapping, viewport, targeting, categoryExclusions, refreshInterval, alwaysRender, onRender, onDestroy, disabled, disableTracking, rootMargin, }?: UseAdOptions): {
+    width: any;
+    height: any;
+    isFluid: boolean;
+    refObserver: import("react").RefObject<any>;
+    slot: AdSlot;
+    disabled: boolean;
+    id: string;
+    isRendered: boolean;
+    isEmpty: any;
+    isVisible: boolean;
+    renderEvent: any;
+};
+export default useAd;

package/types/useAdsTracking.d.ts

@@ -0,0 +1,2 @@
+import AdSlot from './AdSlot';
+export default function useAdsTracking(): (action: string, slot?: AdSlot, renderEvent?: any) => void;

package/types/useRichAd.d.ts

@@ -0,0 +1,6 @@
+import { RichAd } from './types';
+interface UseRichAdOptions {
+    onRichAd?: (richAd: RichAd) => void | null;
+}
+declare function useRichAd(containerRef: any, id: string, opts?: UseRichAdOptions): any;
+export default useRichAd;

package/types/utils.d.ts

@@ -0,0 +1,10 @@
+import { AdSize, AdSizeMapping, Size, Slot, SlotDefinition, Viewport, Viewports } from './types';
+export declare function normalizeAdSizes(size: any): AdSize[];
+export declare function getAdSizes(sizes: any): AdSize[];
+export declare function getMinimumAdSize(sizes: any): Size;
+export declare function sizeFitsInViewport(size: AdSize, viewport: Viewport): boolean;
+export declare function getSortedViewports(viewports: Viewports): any;
+export declare function buildSizeMappingFromViewports(sizeMapping: any, viewports: any): AdSizeMapping[];
+export declare function buildSizeMappingFromSizes(sizes: any, viewports: any): AdSizeMapping[];
+export declare function getSizeMappingFromSlot({ size: allSizes, sizeMapping }: Slot | SlotDefinition, viewports: Viewports): AdSizeMapping[] | null;
+export declare function getSizeFromSizeMapping(sizeMapping: any): AdSize[] | null;