@micromag/core 0.3.767 → 0.3.769

package/lib/contexts.js

@@ -0,0 +1,1802 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var isString = require('lodash/isString');
+var PropTypes = require('prop-types');
+var React = require('react');
+var core = require('@micromag/core');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var JSCookie = require('js-cookie');
+var reactIntl = require('react-intl');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var uniqBy = require('lodash/uniqBy');
+var fetch = require('@folklore/fetch');
+var isObject = require('lodash/isObject');
+var services = require('@folklore/services');
+var utils = require('@micromag/core/utils');
+var routes = require('@folklore/routes');
+var wouter = require('wouter');
+var tracking = require('@folklore/tracking');
+var EventEmitter = require('wolfy87-eventemitter');
+
+var MODALS_NAMESPACE = 'modals';
+var FIELDS_NAMESPACE = 'fields';
+var FORMS_NAMESPACE = 'forms';
+var SCREENS_NAMESPACE = 'screens';
+var ELEMENTS_NAMESPACE = 'elements';
+var ComponentsContext = /*#__PURE__*/React.createContext(null);
+
+/**
+ * Hooks
+ */
+var useComponentsManager = function useComponentsManager() {
+  var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  var manager = React.useContext(ComponentsContext);
+  var finalManager = React.useMemo(function () {
+    return namespace !== null ? new core.ComponentsManager(manager.getComponents(namespace)) : manager;
+  }, [manager, namespace]);
+  return finalManager;
+};
+var useComponents = function useComponents() {
+  var namespace = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+  var defaultComponents = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var manager = useComponentsManager();
+  return manager.getComponents(namespace) || defaultComponents;
+};
+var useComponent = function useComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var namespace = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+  var manager = useComponentsManager(namespace);
+  return React.useMemo(function () {
+    if (!isString(name)) {
+      return name || defaultComponent;
+    }
+    return manager.getComponent(name) || defaultComponent;
+  }, [manager, name, defaultComponent]);
+};
+
+/**
+ * Fields hooks
+ */
+var useFieldsComponentsManager = function useFieldsComponentsManager() {
+  return useComponentsManager(FIELDS_NAMESPACE);
+};
+var useFieldsComponents = function useFieldsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(FIELDS_NAMESPACE, defaultComponents);
+};
+var useFieldComponent = function useFieldComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, FIELDS_NAMESPACE);
+};
+
+/**
+ * Screens hooks
+ */
+var useScreensComponentsManager = function useScreensComponentsManager() {
+  return useComponentsManager(SCREENS_NAMESPACE);
+};
+var useScreensComponents = function useScreensComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(SCREENS_NAMESPACE, defaultComponents);
+};
+var useScreenComponent = function useScreenComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, SCREENS_NAMESPACE);
+};
+
+/**
+ * Forms hooks
+ */
+var useFormsComponentsManager = function useFormsComponentsManager() {
+  return useComponentsManager(FORMS_NAMESPACE);
+};
+var useFormsComponents = function useFormsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(FORMS_NAMESPACE, defaultComponents);
+};
+var useFormComponent = function useFormComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, FORMS_NAMESPACE);
+};
+
+/**
+ * Modals hooks
+ */
+var useModalsComponentsManager = function useModalsComponentsManager() {
+  return useComponentsManager(MODALS_NAMESPACE);
+};
+var useModalsComponents = function useModalsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(MODALS_NAMESPACE, defaultComponents);
+};
+var useModalComponent = function useModalComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, MODALS_NAMESPACE);
+};
+
+/**
+ * Elements hooks
+ */
+var useElementsComponentsManager = function useElementsComponentsManager() {
+  return useComponentsManager(ELEMENTS_NAMESPACE);
+};
+var useElementsComponents = function useElementsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(ELEMENTS_NAMESPACE, defaultComponents);
+};
+var useElementComponent = function useElementComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, ELEMENTS_NAMESPACE);
+};
+
+/**
+ * Provider
+ */
+var propTypes$j = {
+  children: PropTypes.node.isRequired,
+  namespace: PropTypes.string,
+  manager: PropTypes.instanceOf(core.ComponentsManager),
+  components: PropTypes.objectOf(PropTypes.oneOfType([PropTypes.object, PropTypes.func]))
+};
+var defaultProps$j = {
+  namespace: null,
+  components: {},
+  manager: null
+};
+var ComponentsProvider = function ComponentsProvider(_ref) {
+  var components = _ref.components,
+    manager = _ref.manager,
+    namespace = _ref.namespace,
+    children = _ref.children;
+  var previousManager = useComponentsManager() || null;
+  var finalManager = React.useMemo(function () {
+    return new core.ComponentsManager(_objectSpread(_objectSpread(_objectSpread({}, previousManager !== null ? previousManager.getComponents() : null), manager !== null ? manager.getComponents() : null), new core.ComponentsManager(components).addNamespace(namespace).getComponents()));
+  }, [previousManager, manager, components, namespace]);
+  return /*#__PURE__*/React.createElement(ComponentsContext.Provider, {
+    value: finalManager
+  }, children);
+};
+ComponentsProvider.propTypes = propTypes$j;
+ComponentsProvider.defaultProps = defaultProps$j;
+
+var messages = reactIntl.defineMessages({
+  functionality_title: {
+    id: "consent.functionality_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Functionnal"
+    }]
+  },
+  functionality_description: {
+    id: "consent.functionality_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies required for the site to function properly."
+    }]
+  },
+  analytics_title: {
+    id: "consent.analytics_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Analytics"
+    }]
+  },
+  analytics_description: {
+    id: "consent.analytics_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used to measure user behavior."
+    }]
+  },
+  ad_storage_title: {
+    id: "consent.ad_storage_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Ad Storage"
+    }]
+  },
+  ad_storage_description: {
+    id: "consent.ad_storage_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used for advertising purposes."
+    }]
+  },
+  ad_personalization_title: {
+    id: "consent.ad_personalization_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Ad Personalization"
+    }]
+  },
+  ad_personalization_description: {
+    id: "consent.ad_personalization_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used for ad targeting."
+    }]
+  },
+  ad_user_data_title: {
+    id: "consent.ad_user_data_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "User Ad Data"
+    }]
+  },
+  ad_user_data_description: {
+    id: "consent.ad_user_data_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used for user-specific ad data."
+    }]
+  },
+  personalization_storage_title: {
+    id: "consent.personalization_storage_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Personalization Storage"
+    }]
+  },
+  personalization_storage_description: {
+    id: "consent.personalization_storage_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used for personalizing user experience."
+    }]
+  },
+  security_storage_title: {
+    id: "consent.security_storage_title",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Security Storage"
+    }]
+  },
+  security_storage_description: {
+    id: "consent.security_storage_description",
+    defaultMessage: [{
+      "type": 0,
+      "value": "Cookies used for security purposes."
+    }]
+  }
+});
+var consentStates = [{
+  id: 'functionality_storage',
+  label: messages.functionality_title,
+  description: messages.functionality_description,
+  value: true,
+  disabled: true
+}, {
+  id: 'security_storage',
+  label: messages.security_storage_title,
+  description: messages.security_storage_description,
+  value: true
+}, {
+  id: 'personalization_storage',
+  label: messages.personalization_storage_title,
+  description: messages.personalization_storage_description,
+  value: false
+}, {
+  id: 'analytics_storage',
+  label: messages.analytics_title,
+  description: messages.analytics_description,
+  value: false
+}, {
+  id: 'ad_storage',
+  label: messages.ad_storage_title,
+  description: messages.ad_storage_description,
+  value: false
+}, {
+  id: 'ad_personalization',
+  label: messages.ad_personalization_title,
+  description: messages.ad_personalization_description,
+  value: false
+}, {
+  id: 'ad_user_data',
+  label: messages.ad_user_data_title,
+  description: messages.ad_user_data_description,
+  value: false
+}];
+var ConsentContext = /*#__PURE__*/React.createContext({
+  consent: null,
+  setConsent: function setConsent() {}
+});
+var useConsent = function useConsent() {
+  return React.useContext(ConsentContext);
+};
+var propTypes$i = {
+  children: PropTypes.node.isRequired,
+  consent: PropTypes.arrayOf(PropTypes.shape({})),
+  consented: PropTypes.bool,
+  expiration: PropTypes.number
+};
+var defaultProps$i = {
+  consent: ['functionality_storage', 'analytics_storage', 'ad_storage', 'ad_personalization', 'ad_user_data'],
+  consented: null,
+  expiration: 182 // Default expiration in days
+};
+var ConsentProvider = function ConsentProvider(_ref) {
+  var providedConsent = _ref.consent,
+    initialConsented = _ref.consented,
+    expiration = _ref.expiration,
+    children = _ref.children;
+  // Has consented or not to cookies
+  var initialCookieConsented = JSCookie.get('has_consented') === 'true';
+  var baseConsented = initialConsented || initialCookieConsented;
+  var _useState = React.useState(baseConsented),
+    _useState2 = _slicedToArray(_useState, 2),
+    consented = _useState2[0],
+    setConsentedState = _useState2[1];
+  var setConsented = React.useCallback(function () {
+    var accept = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var hasConsented = accept || false;
+    JSCookie.set('has_consented', hasConsented, {
+      secure: true,
+      expires: expiration
+    });
+    setConsentedState(hasConsented);
+  }, [expiration, setConsentedState]);
+  React.useEffect(function () {
+    if (initialConsented === true || initialConsented === false) {
+      setConsented(initialConsented);
+    }
+  }, [initialConsented, setConsented]);
+
+  // The consent state itself
+  var baseConsent = React.useMemo(function () {
+    return (providedConsent || consentStates || []).map(function (item) {
+      if (isString(item)) {
+        return (consentStates || []).find(function (it) {
+          return it.id === item;
+        }) || null;
+      }
+      return item || null;
+    }).filter(function (it) {
+      return it !== null;
+    }).map(function (it) {
+      return _objectSpread(_objectSpread({}, it), {}, {
+        value:
+        // eslint-disable-next-line no-nested-ternary
+        JSCookie.get(it.id) === 'granted' ? true : JSCookie.get(it.id) === 'denied' ? false : it.value
+      });
+    });
+  }, [providedConsent]);
+  var _useState3 = React.useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    consent = _useState4[0],
+    setConsentState = _useState4[1];
+  var setConsent = React.useCallback(function () {
+    var values = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var initial = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var tagManagerConsent = (values || []).reduce(function (acc, it) {
+      if (it.value === true) {
+        JSCookie.set(it.id, 'granted', {
+          secure: true,
+          expires: expiration
+        });
+        acc[it.id] = 'granted';
+      } else if (it.value === false) {
+        JSCookie.set(it.id, 'denied', {
+          secure: true,
+          expires: expiration
+        });
+        acc[it.id] = 'denied';
+      } else {
+        JSCookie.remove(it.id);
+        acc[it.id] = 'denied';
+      }
+      return acc;
+    }, {});
+    if (typeof window !== 'undefined' && typeof window.gtag === 'function') {
+      window.gtag('consent', initial === true ? 'default' : 'update', tagManagerConsent);
+      window.gtag('event', initial === true ? 'consent_default' : 'consent_update', tagManagerConsent);
+      console.log('consent', initial === true ? 'default' : 'update', tagManagerConsent);
+    }
+    setConsentState(values);
+  }, [setConsentState, expiration]);
+  React.useEffect(function () {
+    if (baseConsent !== null && baseConsent.length > 0) {
+      setConsent(baseConsent);
+    }
+  }, [baseConsent, setConsent]);
+  var value = React.useMemo(function () {
+    return {
+      consent: consent,
+      setConsent: setConsent,
+      consented: consented,
+      setConsented: setConsented
+    };
+  }, [consent, setConsent, consented, setConsented]);
+  return /*#__PURE__*/React.createElement(ConsentContext.Provider, {
+    value: value
+  }, children);
+};
+ConsentProvider.propTypes = propTypes$i;
+ConsentProvider.defaultProps = defaultProps$i;
+
+var FieldsContext = /*#__PURE__*/React.createContext(null);
+var useFieldsManager = function useFieldsManager() {
+  return React.useContext(FieldsContext);
+};
+var useFieldDefinition = function useFieldDefinition(id) {
+  var manager = useFieldsManager();
+  return manager.getDefinition(id);
+};
+var propTypes$h = {
+  fields: core.PropTypes.fieldDefinitions,
+  manager: PropTypes.instanceOf(core.FieldsManager),
+  children: PropTypes.node.isRequired
+};
+var defaultProps$h = {
+  fields: null,
+  manager: null
+};
+var FieldsProvider = function FieldsProvider(_ref) {
+  var fields = _ref.fields,
+    manager = _ref.manager,
+    children = _ref.children;
+  var previousManager = useFieldsManager() || null;
+  var finalManager = React.useMemo(function () {
+    var newFields = uniqBy([].concat(_toConsumableArray(fields || []), _toConsumableArray(manager !== null ? manager.getDefinitions() : []), _toConsumableArray(previousManager !== null ? previousManager.getDefinitions() : [])), function (_ref2) {
+      var id = _ref2.id;
+      return id;
+    }).reverse();
+    return new core.FieldsManager(newFields);
+  }, [previousManager, manager, fields]);
+  var components = React.useMemo(function () {
+    var newComponents = finalManager.getComponents();
+    return Object.keys(newComponents).reduce(function (map, id) {
+      var component = newComponents[id];
+      return isString(component) ? map : _objectSpread(_objectSpread({}, map), {}, _defineProperty({}, id, component));
+    }, {});
+  }, [finalManager]);
+  return /*#__PURE__*/React.createElement(FieldsContext.Provider, {
+    value: finalManager
+  }, /*#__PURE__*/React.createElement(ComponentsProvider, {
+    namespace: FIELDS_NAMESPACE,
+    components: components
+  }, children));
+};
+FieldsProvider.propTypes = propTypes$h;
+FieldsProvider.defaultProps = defaultProps$h;
+
+var ScreensContext = /*#__PURE__*/React.createContext(new core.ScreensManager());
+var useScreensManager = function useScreensManager() {
+  return React.useContext(ScreensContext);
+};
+var propTypes$g = {
+  screens: core.PropTypes.screenDefinitions,
+  namespaces: PropTypes.arrayOf(PropTypes.string),
+  filterNamespaces: PropTypes.bool,
+  manager: PropTypes.instanceOf(core.ScreensManager),
+  children: PropTypes.node.isRequired
+};
+var defaultProps$g = {
+  screens: null,
+  namespaces: null,
+  filterNamespaces: false,
+  manager: null
+};
+var ScreensProvider = function ScreensProvider(_ref) {
+  var screens = _ref.screens,
+    namespaces = _ref.namespaces,
+    filterNamespaces = _ref.filterNamespaces,
+    manager = _ref.manager,
+    children = _ref.children;
+  var previousManager = useScreensManager();
+  var finalManager = React.useMemo(function () {
+    var newManager = manager !== null ? manager : new core.ScreensManager(screens);
+    if ((previousManager || null) !== null) {
+      newManager = previousManager.merge(newManager);
+    }
+    if (filterNamespaces) {
+      newManager = previousManager.filter(function (_ref2) {
+        var _ref2$namespaces = _ref2.namespaces,
+          screenGroups = _ref2$namespaces === void 0 ? null : _ref2$namespaces;
+        return screenGroups === null || namespaces !== null && screenGroups.reduce(function (acc, id) {
+          return acc || namespaces.indexOf(id) !== -1;
+        }, false);
+      });
+    }
+    return newManager;
+  }, [manager, screens, namespaces, filterNamespaces, previousManager]);
+  var initialComponents = React.useMemo(function () {
+    return finalManager.getComponents();
+  }, [finalManager]);
+  var _useState = React.useState(initialComponents),
+    _useState2 = _slicedToArray(_useState, 2),
+    components = _useState2[0],
+    setComponents = _useState2[1];
+  React.useEffect(function () {
+    var onChange = function onChange() {
+      return setComponents(finalManager.getComponents());
+    };
+    finalManager.on('change', onChange);
+    return function () {
+      finalManager.off('change', onChange);
+    };
+  }, [finalManager, setComponents]);
+  return /*#__PURE__*/React.createElement(ScreensContext.Provider, {
+    value: finalManager
+  }, /*#__PURE__*/React.createElement(ComponentsProvider, {
+    namespace: SCREENS_NAMESPACE,
+    components: components
+  }, children));
+};
+ScreensProvider.propTypes = propTypes$g;
+ScreensProvider.defaultProps = defaultProps$g;
+
+var StoryContext = /*#__PURE__*/React.createContext(null);
+var useStoryContext = function useStoryContext() {
+  return React.useContext(StoryContext);
+};
+var useStory = function useStory() {
+  var story = useStoryContext();
+  return story;
+};
+var propTypes$f = {
+  story: PropTypes.oneOfType([core.PropTypes.story, core.PropTypes.theme]),
+  children: PropTypes.node.isRequired
+};
+var defaultProps$f = {
+  story: null
+};
+var StoryProvider = function StoryProvider(_ref) {
+  var story = _ref.story,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(StoryContext.Provider, {
+    value: story
+  }, children);
+};
+StoryProvider.propTypes = propTypes$f;
+StoryProvider.defaultProps = defaultProps$f;
+
+var EditorContext = /*#__PURE__*/React.createContext(null);
+var useEditor = function useEditor() {
+  return React.useContext(EditorContext);
+};
+var useGetColors = function useGetColors() {
+  var _ref = useEditor() || {},
+    _ref$getColors = _ref.getColors,
+    getColors = _ref$getColors === void 0 ? function () {
+      return [];
+    } : _ref$getColors;
+  return getColors;
+};
+var propTypes$e = {
+  children: PropTypes.node.isRequired
+};
+var defaultProps$e = {};
+var EditorProvider = function EditorProvider(_ref2) {
+  var children = _ref2.children;
+  var story = useStory();
+  var screensManager = useScreensManager();
+  var fieldsManager = useFieldsManager();
+  var parser = React.useMemo(function () {
+    return new core.ColorsParser({
+      screensManager: screensManager,
+      fieldsManager: fieldsManager
+    });
+  }, [screensManager, fieldsManager]);
+  var parse = React.useCallback(function (currentStory) {
+    return parser.parse(currentStory);
+  }, [parser]);
+  var getColors = React.useCallback(function () {
+    return parse(story);
+  }, [parse, story]);
+
+  // eslint-disable-next-line react/jsx-no-constructed-context-values
+  return /*#__PURE__*/React.createElement(EditorContext.Provider, {
+    value: {
+      getColors: getColors
+    }
+  }, children);
+};
+EditorProvider.propTypes = propTypes$e;
+EditorProvider.defaultProps = defaultProps$e;
+
+/* eslint-disable react/jsx-props-no-spreading */
+var FieldsValueContext = /*#__PURE__*/React.createContext(null);
+var useFieldsValue = function useFieldsValue() {
+  return React.useContext(FieldsValueContext);
+};
+var propTypes$d = {
+  value: PropTypes.any,
+  // eslint-disable-line react/forbid-prop-types
+  children: PropTypes.node.isRequired
+};
+var defaultProps$d = {
+  value: null
+};
+var FieldsValueContextProvider = function FieldsValueContextProvider(_ref) {
+  var value = _ref.value,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(FieldsValueContext.Provider, {
+    value: value
+  }, children);
+};
+FieldsValueContextProvider.propTypes = propTypes$d;
+FieldsValueContextProvider.defaultProps = defaultProps$d;
+
+/* eslint-disable react/jsx-props-no-spreading */
+var FieldContext = /*#__PURE__*/React.createContext(null);
+var useFieldContext = function useFieldContext() {
+  return React.useContext(FieldContext);
+};
+var propTypes$c = {
+  context: PropTypes.any,
+  // eslint-disable-line react/forbid-prop-types
+  children: PropTypes.node.isRequired
+};
+var defaultProps$c = {
+  context: null
+};
+var FieldContextProvider = function FieldContextProvider(_ref) {
+  var context = _ref.context,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(FieldContext.Provider, {
+    value: context
+  }, children);
+};
+FieldContextProvider.propTypes = propTypes$c;
+FieldContextProvider.defaultProps = defaultProps$c;
+
+/* eslint-disable react/jsx-props-no-spreading */
+var GoogleKeysContext = /*#__PURE__*/React.createContext({
+  apiKey: null
+});
+var useGoogleKeys = function useGoogleKeys() {
+  return React.useContext(GoogleKeysContext);
+};
+var propTypes$b = {
+  children: PropTypes.node.isRequired,
+  apiKey: PropTypes.string // .isRequired,
+};
+var defaultProps$b = {
+  apiKey: null
+};
+var GoogleKeysProvider = function GoogleKeysProvider(_ref) {
+  var children = _ref.children,
+    apiKey = _ref.apiKey;
+  var _useGoogleKeys = useGoogleKeys(),
+    previousApiKey = _useGoogleKeys.apiKey;
+  var value = React.useMemo(function () {
+    return {
+      apiKey: apiKey || previousApiKey
+    };
+  }, [apiKey, previousApiKey]);
+  return /*#__PURE__*/React.createElement(GoogleKeysContext.Provider, {
+    value: value
+  }, children);
+};
+GoogleKeysProvider.propTypes = propTypes$b;
+GoogleKeysProvider.defaultProps = defaultProps$b;
+
+var FontsContext = /*#__PURE__*/React.createContext({
+  systemFonts: null,
+  googleFonts: null,
+  customFonts: null
+});
+var useGoogleFonts = function useGoogleFonts() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$disabled = _ref.disabled,
+    disabled = _ref$disabled === void 0 ? false : _ref$disabled,
+    _ref$setFonts = _ref.setFonts,
+    setFonts = _ref$setFonts === void 0 ? null : _ref$setFonts;
+  var _useGoogleKeys = useGoogleKeys(),
+    apiKey = _useGoogleKeys.apiKey;
+  var _useState = React.useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    googleFonts = _useState2[0],
+    setGoogleFonts = _useState2[1];
+  React.useEffect(function () {
+    var canceled = false;
+    if (apiKey !== null && !disabled) {
+      fetch.getJSON("https://www.googleapis.com/webfonts/v1/webfonts?key=".concat(apiKey, "&sort=popularity")).then(function (_ref2) {
+        var _ref2$items = _ref2.items,
+          items = _ref2$items === void 0 ? [] : _ref2$items;
+        if (!canceled) {
+          var newFonts = items.map(function (it) {
+            return {
+              type: 'google',
+              name: it.family,
+              variants: it.variants
+            };
+          });
+          if (setFonts !== null) {
+            setFonts(newFonts);
+          } else {
+            setGoogleFonts(newFonts);
+          }
+        }
+      });
+    }
+    return function () {
+      canceled = true;
+    };
+  }, [apiKey, disabled, setFonts, setGoogleFonts]);
+  return googleFonts;
+};
+var useFonts = function useFonts() {
+  var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref3$withoutGoogleFo = _ref3.withoutGoogleFonts,
+    withoutGoogleFonts = _ref3$withoutGoogleFo === void 0 ? false : _ref3$withoutGoogleFo;
+  var _useContext = React.useContext(FontsContext),
+    _useContext$setGoogle = _useContext.setGoogleFonts,
+    setGoogleFonts = _useContext$setGoogle === void 0 ? null : _useContext$setGoogle,
+    _useContext$systemFon = _useContext.systemFonts,
+    systemFonts = _useContext$systemFon === void 0 ? null : _useContext$systemFon,
+    _useContext$googleFon = _useContext.googleFonts,
+    googleFonts = _useContext$googleFon === void 0 ? null : _useContext$googleFon,
+    _useContext$customFon = _useContext.customFonts,
+    customFonts = _useContext$customFon === void 0 ? null : _useContext$customFon;
+  useGoogleFonts({
+    disabled: withoutGoogleFonts || googleFonts !== null && googleFonts.length > 0,
+    setFonts: setGoogleFonts
+  });
+  var fonts = React.useMemo(function () {
+    return {
+      systemFonts: systemFonts,
+      googleFonts: googleFonts,
+      customFonts: customFonts
+    };
+  }, [systemFonts, googleFonts, customFonts]);
+  return fonts;
+};
+var propTypes$a = {
+  children: PropTypes.node.isRequired,
+  systemFonts: core.PropTypes.fonts,
+  customFonts: core.PropTypes.fonts
+};
+var defaultProps$a = {
+  systemFonts: ['Arial', 'Courier New', 'Georgia', 'Times New Roman', 'Verdana'],
+  customFonts: null
+};
+var FontsProvider = function FontsProvider(_ref4) {
+  var systemFonts = _ref4.systemFonts,
+    customFonts = _ref4.customFonts,
+    children = _ref4.children;
+  var _useFonts = useFonts(),
+    _useFonts$systemFonts = _useFonts.systemFonts,
+    previousSystemFonts = _useFonts$systemFonts === void 0 ? null : _useFonts$systemFonts,
+    _useFonts$googleFonts = _useFonts.googleFonts,
+    previousGoogleFonts = _useFonts$googleFonts === void 0 ? null : _useFonts$googleFonts,
+    previousCustomFonts = _useFonts.customFonts;
+  var _useState3 = React.useState(null),
+    _useState4 = _slicedToArray(_useState3, 2),
+    googleFonts = _useState4[0],
+    setGoogleFonts = _useState4[1];
+  var fonts = React.useMemo(function () {
+    return {
+      systemFonts: uniqBy([].concat(_toConsumableArray(previousSystemFonts || []), _toConsumableArray(systemFonts || [])), function (font) {
+        return isObject(font) ? font.name : font;
+      }),
+      googleFonts: uniqBy([].concat(_toConsumableArray(previousGoogleFonts || []), _toConsumableArray(googleFonts || [])), function (font) {
+        return isObject(font) ? font.name : font;
+      }),
+      customFonts: uniqBy([].concat(_toConsumableArray(previousCustomFonts || []), _toConsumableArray(customFonts || [])), function (font) {
+        return isObject(font) ? font.name : font;
+      }),
+      setGoogleFonts: setGoogleFonts
+    };
+  }, [previousSystemFonts, previousGoogleFonts, previousCustomFonts, customFonts, systemFonts, googleFonts, setGoogleFonts]);
+  return /*#__PURE__*/React.createElement(FontsContext.Provider, {
+    value: fonts
+  }, children);
+};
+FontsProvider.propTypes = propTypes$a;
+FontsProvider.defaultProps = defaultProps$a;
+
+var GoogleApiClientContext = /*#__PURE__*/React.createContext(null);
+var useGoogleApiClient = function useGoogleApiClient() {
+  return React.useContext(GoogleApiClientContext);
+};
+var withGoogleApiClient = function withGoogleApiClient(WrappedComponent) {
+  var getDisplayName = function getDisplayName(_ref) {
+    var _ref$displayName = _ref.displayName,
+      displayName = _ref$displayName === void 0 ? null : _ref$displayName,
+      _ref$name = _ref.name,
+      name = _ref$name === void 0 ? null : _ref$name;
+    return displayName || name || 'Component';
+  };
+  var WithGoogleApiClientComponent = function WithGoogleApiClientComponent(props) {
+    return /*#__PURE__*/React.createElement(GoogleApiClientContext.Consumer, null, function (client) {
+      return /*#__PURE__*/React.createElement(WrappedComponent, Object.assign({
+        googleApiClient: client
+      }, props));
+    });
+  };
+  WithGoogleApiClientComponent.displayName = "WithGoogleApiClient(".concat(getDisplayName(WrappedComponent), ")");
+  return WithGoogleApiClientComponent;
+};
+var propTypes$9 = {
+  children: PropTypes.node.isRequired
+};
+var defaultProps$9 = {};
+var GoogleApiClientProvider = function GoogleApiClientProvider(_ref2) {
+  var children = _ref2.children;
+  var _useGoogleKeys = useGoogleKeys(),
+    apiKey = _useGoogleKeys.apiKey;
+  var _useState = React.useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    client = _useState2[0],
+    setClient = _useState2[1];
+  React.useEffect(function () {
+    services.loadGoogleApi().then(function (gapi) {
+      return gapi.client.init({
+        apiKey: apiKey
+      }).then(function () {
+        return gapi;
+      });
+    }).then(function (gapi) {
+      return setClient(gapi);
+    });
+  }, [apiKey, setClient]);
+  return /*#__PURE__*/React.createElement(GoogleApiClientContext.Provider, {
+    value: client
+  }, children);
+};
+GoogleApiClientProvider.propTypes = propTypes$9;
+GoogleApiClientProvider.defaultProps = defaultProps$9;
+
+var GoogleMapsClientContext = /*#__PURE__*/React.createContext(null);
+var useGoogleMapsClient = function useGoogleMapsClient() {
+  return React.useContext(GoogleMapsClientContext);
+};
+var withGoogleMapsClient = function withGoogleMapsClient(WrappedComponent) {
+  var getDisplayName = function getDisplayName(_ref) {
+    var _ref$displayName = _ref.displayName,
+      displayName = _ref$displayName === void 0 ? null : _ref$displayName,
+      _ref$name = _ref.name,
+      name = _ref$name === void 0 ? null : _ref$name;
+    return displayName || name || 'Component';
+  };
+  var WithGoogleMapsClientComponent = function WithGoogleMapsClientComponent(props) {
+    return /*#__PURE__*/React.createElement(GoogleMapsClientContext.Consumer, null, function (client) {
+      return /*#__PURE__*/React.createElement(WrappedComponent, Object.assign({
+        googleApiClient: client
+      }, props));
+    });
+  };
+  WithGoogleMapsClientComponent.displayName = "WithGoogleMapsClient(".concat(getDisplayName(WrappedComponent), ")");
+  return WithGoogleMapsClientComponent;
+};
+var propTypes$8 = {
+  children: PropTypes.node.isRequired,
+  locale: PropTypes.string,
+  libraries: PropTypes.arrayOf(PropTypes.string)
+};
+var defaultProps$8 = {
+  locale: 'fr',
+  libraries: null
+};
+var GoogleMapsClientProvider = function GoogleMapsClientProvider(_ref2) {
+  var children = _ref2.children,
+    locale = _ref2.locale,
+    libraries = _ref2.libraries;
+  var _useGoogleKeys = useGoogleKeys(),
+    apiKey = _useGoogleKeys.apiKey;
+  var exisitingClient = useGoogleMapsClient();
+  var _useState = React.useState(exisitingClient),
+    _useState2 = _slicedToArray(_useState, 2),
+    client = _useState2[0],
+    setClient = _useState2[1];
+  React.useEffect(function () {
+    if (exisitingClient === null) {
+      services.loadGoogleMaps({
+        apiKey: apiKey,
+        locale: locale,
+        libraries: libraries
+      }).then(function (newClient) {
+        setClient(newClient);
+      });
+    }
+  }, [apiKey, locale, libraries, setClient, exisitingClient]);
+  return /*#__PURE__*/React.createElement(GoogleMapsClientContext.Provider, {
+    value: client
+  }, children);
+};
+GoogleMapsClientProvider.propTypes = propTypes$8;
+GoogleMapsClientProvider.defaultProps = defaultProps$8;
+
+var ModalsContext = /*#__PURE__*/React.createContext({
+  container: null
+});
+var useModals = function useModals() {
+  return React.useContext(ModalsContext) || {};
+};
+var withModals = function withModals(WrappedComponent) {
+  var WithModalsComponent = function WithModalsComponent(props) {
+    return /*#__PURE__*/React.createElement(ModalsContext.Consumer, null, function (_ref) {
+      var modals = _ref.modals,
+        container = _ref.container,
+        setContainer = _ref.setContainer,
+        register = _ref.register,
+        unregister = _ref.unregister;
+      return /*#__PURE__*/React.createElement(WrappedComponent, Object.assign({
+        modalsContainer: container,
+        setModalsContainer: setContainer,
+        modals: modals,
+        registerModal: register,
+        unregisterModal: unregister
+      }, props));
+    });
+  };
+  WithModalsComponent.displayName = "WithModals(".concat(utils.getDisplayName(WrappedComponent), ")");
+  return WithModalsComponent;
+};
+var propTypes$7 = {
+  children: PropTypes.node.isRequired,
+  container: PropTypes.object // eslint-disable-line
+};
+var defaultProps$7 = {
+  container: null
+};
+var ModalsProvider = function ModalsProvider(_ref2) {
+  var children = _ref2.children,
+    initialContainer = _ref2.container;
+  var _useState = React.useState(initialContainer),
+    _useState2 = _slicedToArray(_useState, 2),
+    container = _useState2[0],
+    setContainer = _useState2[1];
+  var _useState3 = React.useState([]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    modals = _useState4[0],
+    setModals = _useState4[1];
+  var modalsRef = React.useRef(modals);
+  var register = React.useCallback(function (id) {
+    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var currentModals = modalsRef.current;
+    var newModals = [].concat(_toConsumableArray(currentModals), [_objectSpread({
+      id: id
+    }, data)]);
+    setModals(newModals);
+    modalsRef.current = newModals;
+  }, [modals, setModals]);
+  var unregister = React.useCallback(function (id) {
+    var currentModals = modalsRef.current;
+    var foundIndex = currentModals.findIndex(function (_ref3) {
+      var modalId = _ref3.id;
+      return modalId === id;
+    });
+    if (foundIndex !== -1) {
+      var newModals = currentModals.filter(function (_ref4) {
+        var modalId = _ref4.id;
+        return modalId !== id;
+      });
+      setModals(newModals);
+      modalsRef.current = newModals;
+    }
+  }, [modals, setModals]);
+  var value = React.useMemo(function () {
+    return {
+      modals: modals,
+      container: container,
+      setContainer: setContainer,
+      register: register,
+      unregister: unregister
+    };
+  }, [modals, container, setContainer, register, unregister]);
+  return /*#__PURE__*/React.createElement(ModalsContext.Provider, {
+    value: value
+  }, children);
+};
+ModalsProvider.propTypes = propTypes$7;
+ModalsProvider.defaultProps = defaultProps$7;
+
+var PanelsContext = /*#__PURE__*/React.createContext({
+  container: null
+});
+var usePanels = function usePanels() {
+  return React.useContext(PanelsContext) || {};
+};
+var withPanels = function withPanels(WrappedComponent) {
+  var WithPanelsComponent = function WithPanelsComponent(props) {
+    return /*#__PURE__*/React.createElement(PanelsContext.Consumer, null, function (_ref) {
+      var panels = _ref.panels,
+        setContainer = _ref.setContainer,
+        container = _ref.container,
+        register = _ref.register,
+        unregister = _ref.unregister;
+      return /*#__PURE__*/React.createElement(WrappedComponent, Object.assign({
+        panelsContainer: container,
+        setPanelsContainer: setContainer,
+        panels: panels,
+        registerPanel: register,
+        unregisterPanel: unregister
+      }, props));
+    });
+  };
+  WithPanelsComponent.displayName = "WithPanels(".concat(utils.getDisplayName(WrappedComponent), ")");
+  return WithPanelsComponent;
+};
+var propTypes$6 = {
+  children: PropTypes.node.isRequired,
+  container: PropTypes.object // eslint-disable-line
+};
+var defaultProps$6 = {
+  container: null
+};
+var PanelsProvider = function PanelsProvider(_ref2) {
+  var children = _ref2.children,
+    initialContainer = _ref2.container;
+  var _useState = React.useState(initialContainer),
+    _useState2 = _slicedToArray(_useState, 2),
+    container = _useState2[0],
+    setContainer = _useState2[1];
+  var _useState3 = React.useState([]),
+    _useState4 = _slicedToArray(_useState3, 2),
+    panels = _useState4[0],
+    setPanels = _useState4[1];
+  var panelsRef = React.useRef(panels);
+  var register = React.useCallback(function (id) {
+    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var currentPanels = panelsRef.current;
+    var newPanels = [].concat(_toConsumableArray(currentPanels), [_objectSpread({
+      id: id
+    }, data)]);
+    setPanels(newPanels);
+    panelsRef.current = newPanels;
+  }, [panels, setPanels]);
+  var unregister = React.useCallback(function (id) {
+    var currentPanels = panelsRef.current;
+    var foundIndex = currentPanels.findIndex(function (_ref3) {
+      var modalId = _ref3.id;
+      return modalId === id;
+    });
+    if (foundIndex !== -1) {
+      var newPanels = currentPanels.filter(function (_ref4) {
+        var modalId = _ref4.id;
+        return modalId !== id;
+      });
+      setPanels(newPanels);
+      panelsRef.current = newPanels;
+    }
+  }, [panels, setPanels]);
+  var value = React.useMemo(function () {
+    return {
+      panels: panels,
+      setContainer: setContainer,
+      container: container,
+      register: register,
+      unregister: unregister
+    };
+  }, [panels, setContainer, container, register, unregister]);
+  return /*#__PURE__*/React.createElement(PanelsContext.Provider, {
+    value: value
+  }, children);
+};
+PanelsProvider.propTypes = propTypes$6;
+PanelsProvider.defaultProps = defaultProps$6;
+
+var defaultControlsThemeValue = {
+  seekBarOnly: false,
+  color: null,
+  progressColor: null
+};
+var defaultValue$1 = {
+  playing: false,
+  paused: false,
+  muted: true,
+  controls: false,
+  controlsSuggestPlay: false,
+  controlsVisible: false,
+  media: null,
+  controlsTheme: defaultControlsThemeValue,
+  currentQualityLevel: null
+};
+var PlaybackContext = /*#__PURE__*/React.createContext(_objectSpread(_objectSpread({}, defaultValue$1), {}, {
+  setMuted: function setMuted() {},
+  setPlaying: function setPlaying() {},
+  setControls: function setControls() {},
+  setControlsVisible: function setControlsVisible() {},
+  setControlsTheme: function setControlsTheme() {},
+  showControls: function showControls() {},
+  hideControls: function hideControls() {},
+  setMedia: function setMedia() {},
+  setCurrentQualityLevel: function setCurrentQualityLevel() {}
+}));
+var usePlaybackContext = function usePlaybackContext() {
+  return React.useContext(PlaybackContext);
+};
+var usePlaybackMediaRef = function usePlaybackMediaRef(active) {
+  var _usePlaybackContext = usePlaybackContext(),
+    setMedia = _usePlaybackContext.setMedia;
+  var mediaRef = React.useRef(null);
+  React.useEffect(function () {
+    if (!active) {
+      return function () {};
+    }
+    if (mediaRef.current !== null) {
+      setMedia(mediaRef.current);
+    }
+    return function () {
+      setMedia(null);
+    };
+  }, [setMedia, active]);
+  return mediaRef;
+};
+var propTypes$5 = {
+  children: PropTypes.node.isRequired,
+  controls: PropTypes.bool,
+  controlsSuggestPlay: PropTypes.bool,
+  controlsVisible: PropTypes.bool,
+  controlsTheme: PropTypes.shape({
+    seekBarOnly: PropTypes.bool,
+    color: PropTypes.any,
+    progressColor: PropTypes.any
+  }),
+  muted: PropTypes.bool,
+  playing: PropTypes.bool,
+  paused: PropTypes.bool,
+  currentQualityLevel: PropTypes.number
+};
+var defaultProps$5 = _objectSpread({}, defaultValue$1);
+var PlaybackProvider = function PlaybackProvider(_ref) {
+  var initialMuted = _ref.muted,
+    initialPlaying = _ref.playing,
+    paused = _ref.paused,
+    initialControls = _ref.controls,
+    initialControlsSuggestPlay = _ref.controlsSuggestPlay,
+    initialControlsVisible = _ref.controlsVisible,
+    initialControlsTheme = _ref.controlsTheme,
+    initialCurrentQualityLevel = _ref.currentQualityLevel,
+    children = _ref.children;
+  var _useState = React.useState(initialMuted),
+    _useState2 = _slicedToArray(_useState, 2),
+    muted = _useState2[0],
+    setMuted = _useState2[1];
+  var _useState3 = React.useState(initialPlaying),
+    _useState4 = _slicedToArray(_useState3, 2),
+    playing = _useState4[0],
+    setPlaying = _useState4[1];
+  var _useState5 = React.useState(null),
+    _useState6 = _slicedToArray(_useState5, 2),
+    media = _useState6[0],
+    setMedia = _useState6[1];
+  var _useState7 = React.useState(initialControls),
+    _useState8 = _slicedToArray(_useState7, 2),
+    controls = _useState8[0],
+    setControls = _useState8[1];
+  var _useState9 = React.useState(initialControlsSuggestPlay),
+    _useState0 = _slicedToArray(_useState9, 2),
+    controlsSuggestPlay = _useState0[0],
+    setControlsSuggestPlay = _useState0[1];
+  var _useState1 = React.useState(initialControlsVisible),
+    _useState10 = _slicedToArray(_useState1, 2),
+    controlsVisible = _useState10[0],
+    setControlsVisible = _useState10[1];
+  var _useState11 = React.useState(initialControlsTheme),
+    _useState12 = _slicedToArray(_useState11, 2),
+    controlsTheme = _useState12[0],
+    setControlsTheme = _useState12[1];
+  var _useState13 = React.useState(initialCurrentQualityLevel),
+    _useState14 = _slicedToArray(_useState13, 2),
+    currentQualityLevel = _useState14[0],
+    setCurrentQualityLevel = _useState14[1];
+  var finalSetControls = React.useCallback(function (newControls) {
+    if (newControls) {
+      setControls(true);
+      setControlsVisible(true);
+      setControlsSuggestPlay(false);
+    } else {
+      setControls(false);
+      setControlsVisible(false);
+      setControlsSuggestPlay(false);
+    }
+  }, [setControls, setControlsVisible, setControlsSuggestPlay]);
+  var finalSetControlsTheme = React.useCallback(function (newTheme) {
+    setControlsTheme(_objectSpread(_objectSpread({}, defaultControlsThemeValue), newTheme));
+  }, [setControlsTheme]);
+  var finalSetPlaying = React.useCallback(function (value) {
+    if (value) {
+      setControlsSuggestPlay(false);
+    }
+    setPlaying(value);
+  }, [setPlaying, setControlsSuggestPlay]);
+
+  // Reset on media change
+  React.useEffect(function () {
+    setControlsSuggestPlay(false);
+  }, [media, setControlsSuggestPlay]);
+  var showControls = React.useCallback(function () {
+    return setControlsVisible(true);
+  }, [setControlsVisible]);
+  var hideControls = React.useCallback(function () {
+    setControlsVisible(false);
+  }, [setControlsVisible]);
+  var hasAudio = React.useMemo(function () {
+    if (media === null || media.tagName.toLowerCase() !== 'video') {
+      return false;
+    }
+    if (media.tagName.toLowerCase() === 'audio') {
+      return true;
+    }
+    if (typeof media.dataset.hasAudio === 'undefined') {
+      return null;
+    }
+    return media.dataset.hasAudio === 'true' || media.dataset.hasAudio === true;
+  }, [media]);
+  var finalSetCurrentQualityLevel = React.useCallback(function (level) {
+    var fromRef = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    if (fromRef === null || media === null || fromRef === media) {
+      setCurrentQualityLevel(level);
+    }
+  }, [setCurrentQualityLevel]);
+  var value = React.useMemo(function () {
+    return {
+      muted: muted,
+      playing: playing && !paused,
+      controls: controls,
+      controlsSuggestPlay: controlsSuggestPlay,
+      controlsVisible: controlsVisible,
+      media: media,
+      hasAudio: hasAudio,
+      controlsTheme: controlsTheme,
+      currentQualityLevel: currentQualityLevel,
+      setMuted: setMuted,
+      setPlaying: finalSetPlaying,
+      setControls: finalSetControls,
+      setControlsSuggestPlay: setControlsSuggestPlay,
+      setControlsVisible: setControlsVisible,
+      setControlsTheme: finalSetControlsTheme,
+      showControls: showControls,
+      hideControls: hideControls,
+      setMedia: setMedia,
+      setCurrentQualityLevel: finalSetCurrentQualityLevel
+    };
+  }, [muted, playing, paused, controls, controlsSuggestPlay, controlsVisible, controlsTheme, media, hasAudio, currentQualityLevel, setMuted, finalSetPlaying, finalSetControls, finalSetControlsTheme, setControlsSuggestPlay, setControlsVisible, setControlsTheme, showControls, hideControls, setMedia, setCurrentQualityLevel]);
+  return /*#__PURE__*/React.createElement(PlaybackContext.Provider, {
+    value: value
+  }, children);
+};
+PlaybackProvider.propTypes = propTypes$5;
+PlaybackProvider.defaultProps = defaultProps$5;
+
+var useRoutePush = function useRoutePush() {
+  var url = routes.useUrlGenerator();
+  var _useLocation = wouter.useLocation(),
+    _useLocation2 = _slicedToArray(_useLocation, 2),
+    navigate = _useLocation2[1];
+  var push = React.useCallback(function (route, data) {
+    for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+      args[_key - 2] = arguments[_key];
+    }
+    if (isString(route)) {
+      navigate.apply(void 0, [url(route, data)].concat(args));
+    } else {
+      var _ref = route || {},
+        _ref$pathname = _ref.pathname,
+        pathname = _ref$pathname === void 0 ? null : _ref$pathname,
+        _ref$search = _ref.search,
+        search = _ref$search === void 0 ? null : _ref$search;
+      navigate.apply(void 0, ["".concat(url(pathname, data)).concat(search !== null ? "?".concat(search) : '')].concat(args));
+    }
+  }, [navigate, url]);
+  return push;
+};
+var useRouteBack = function useRouteBack() {
+  var url = routes.useUrlGenerator();
+  var _useLocation3 = wouter.useLocation(),
+    _useLocation4 = _slicedToArray(_useLocation3, 2),
+    navigate = _useLocation4[1];
+  var back = React.useCallback(function () {
+    return navigate(-1);
+  }, [navigate, url]);
+  return back;
+};
+
+var ScreenContext = /*#__PURE__*/React.createContext({
+  data: null,
+  definition: null,
+  renderContext: null
+});
+var useScreen = function useScreen() {
+  return React.useContext(ScreenContext);
+};
+var useScreenDefinition = function useScreenDefinition() {
+  var intl = reactIntl.useIntl();
+  var _ref = useScreen() || {},
+    _ref$definition = _ref.definition,
+    definition = _ref$definition === void 0 ? null : _ref$definition;
+  var _ref2 = definition || {},
+    _ref2$fields = _ref2.fields,
+    fields = _ref2$fields === void 0 ? null : _ref2$fields;
+  var finalFields = React.useMemo(function () {
+    return fields !== null ? [].concat(_toConsumableArray(fields), [utils.getScreenExtraField(intl)]) : null;
+  }, [fields]);
+  return _objectSpread(_objectSpread({}, definition), {}, {
+    fields: finalFields
+  });
+};
+var useScreenData = function useScreenData() {
+  var _ref3 = useScreen() || {},
+    data = _ref3.data;
+  return data;
+};
+var useScreenRenderContext = function useScreenRenderContext() {
+  var _ref4 = useScreen() || {},
+    _ref4$renderContext = _ref4.renderContext,
+    renderContext = _ref4$renderContext === void 0 ? 'view' : _ref4$renderContext;
+  var isPlaceholder = renderContext === 'placeholder';
+  var isPreview = renderContext === 'preview';
+  var isEdit = renderContext === 'edit';
+  var isView = renderContext === 'view';
+  var isStatic = renderContext === 'static';
+  var isCapture = renderContext === 'capture';
+  return {
+    renderContext: renderContext,
+    isPlaceholder: isPlaceholder,
+    isPreview: isPreview,
+    isEdit: isEdit,
+    isView: isView || isStatic || isCapture,
+    isStatic: isStatic,
+    isCapture: isCapture
+  };
+};
+var useScreenState = function useScreenState() {
+  var _ref5 = useScreen() || {},
+    screenState = _ref5.screenState;
+  return screenState;
+};
+var propTypes$4 = {
+  children: PropTypes.node.isRequired,
+  data: core.PropTypes.screen,
+  definition: core.PropTypes.screenDefinition,
+  renderContext: core.PropTypes.renderContext,
+  screenState: PropTypes.string
+};
+var defaultProps$4 = {
+  data: null,
+  definition: null,
+  renderContext: null,
+  screenState: null
+};
+var ScreenProvider = function ScreenProvider(_ref6) {
+  var data = _ref6.data,
+    definition = _ref6.definition,
+    renderContext = _ref6.renderContext,
+    screenState = _ref6.screenState,
+    children = _ref6.children;
+  var _ref7 = useScreen() || {},
+    _ref7$data = _ref7.data,
+    previousData = _ref7$data === void 0 ? null : _ref7$data,
+    _ref7$definition = _ref7.definition,
+    previousDefinition = _ref7$definition === void 0 ? null : _ref7$definition,
+    _ref7$renderContext = _ref7.renderContext,
+    previousContext = _ref7$renderContext === void 0 ? null : _ref7$renderContext,
+    _ref7$screenState = _ref7.screenState,
+    previousScreenState = _ref7$screenState === void 0 ? null : _ref7$screenState;
+  var finalData = data || previousData || null;
+  var _ref8 = finalData || {},
+    _ref8$type = _ref8.type,
+    type = _ref8$type === void 0 ? null : _ref8$type;
+  var screensManager = useScreensManager();
+  var contextDefinition = screensManager !== null ? screensManager.getDefinition(type) : null;
+  var finalDefinition = definition || contextDefinition || previousDefinition;
+  var finalRenderContext = renderContext || previousContext || 'view';
+  var finalScreenState = screenState || previousScreenState || null;
+  var value = React.useMemo(function () {
+    return {
+      data: finalData,
+      definition: finalDefinition,
+      renderContext: finalRenderContext,
+      screenState: finalScreenState
+    };
+  }, [finalData, finalDefinition, finalRenderContext, finalScreenState]);
+  return /*#__PURE__*/React.createElement(ScreenContext.Provider, {
+    value: value
+  }, children);
+};
+ScreenProvider.propTypes = propTypes$4;
+ScreenProvider.defaultProps = defaultProps$4;
+
+/* eslint-disable react/jsx-props-no-spreading */
+var ScreenSizeContext = /*#__PURE__*/React.createContext({
+  screen: null,
+  screens: [],
+  width: 0,
+  height: 0,
+  resolution: 1,
+  landscape: false
+});
+var useScreenSize = function useScreenSize() {
+  return React.useContext(ScreenSizeContext);
+};
+var propTypes$3 = {
+  children: PropTypes.node.isRequired,
+  size: core.PropTypes.screenSize
+};
+var defaultProps$3 = {
+  size: {}
+};
+
+// Note: this is done to avoid excessive renders on the screens that use the context
+
+var ScreenSizeProvider = function ScreenSizeProvider(_ref) {
+  var size = _ref.size,
+    children = _ref.children;
+  var nextScreen = size.screen,
+    nextWidth = size.width,
+    nextHeight = size.height,
+    nextResolution = size.resolution;
+  var currentSize = React.useMemo(function () {
+    return size;
+  }, [nextScreen, nextWidth, nextHeight, nextResolution]);
+  return /*#__PURE__*/React.createElement(ScreenSizeContext.Provider, {
+    value: currentSize
+  }, children);
+};
+ScreenSizeProvider.propTypes = propTypes$3;
+ScreenSizeProvider.defaultProps = defaultProps$3;
+
+var useTracking = function useTracking() {
+  return React.useContext(tracking.TrackingContext);
+};
+var propTypes$2 = {
+  children: PropTypes.node.isRequired,
+  variables: core.PropTypes.trackingVariables,
+  disabled: PropTypes.bool,
+  paused: PropTypes.bool
+};
+var defaultProps$2 = {
+  variables: null,
+  disabled: false,
+  paused: false
+};
+var TrackingProvider = function TrackingProvider(_ref) {
+  var variables = _ref.variables,
+    disabled = _ref.disabled,
+    paused = _ref.paused,
+    children = _ref.children;
+  var contextTracking = useTracking() || null;
+  var refTracking = React.useRef(null);
+  var tracking$1 = React.useMemo(function () {
+    if (refTracking.current === null) {
+      refTracking.current = new core.Tracking({
+        variables: _objectSpread(_objectSpread({}, contextTracking !== null ? contextTracking.getVariables() : null), variables),
+        disabled: disabled,
+        paused: paused
+      });
+    } else {
+      refTracking.current.setVariables(_objectSpread(_objectSpread({}, refTracking.current.getVariables()), variables));
+      refTracking.current.setDisabled(disabled);
+      refTracking.current.setPaused(paused);
+    }
+    return refTracking.current;
+  }, [contextTracking, variables, disabled, paused]);
+  return /*#__PURE__*/React.createElement(tracking.TrackingContainer, {
+    tracking: tracking$1
+  }, children);
+};
+TrackingProvider.propTypes = propTypes$2;
+TrackingProvider.defaultProps = defaultProps$2;
+
+var defaultValue = {
+  events: new EventEmitter(),
+  menuVisible: false,
+  menuOverScreen: false,
+  topHeight: 0,
+  bottomHeight: 0,
+  bottomSidesWidth: 0,
+  gotoNextScreen: function gotoNextScreen() {},
+  gotoPreviousScreen: function gotoPreviousScreen() {},
+  disableInteraction: function disableInteraction() {},
+  enableInteraction: function enableInteraction() {}
+};
+var ViewerContext = /*#__PURE__*/React.createContext(_objectSpread(_objectSpread({}, defaultValue), {}, {
+  webView: null,
+  setWebView: function setWebView() {}
+}));
+var useViewerContext = function useViewerContext() {
+  return React.useContext(ViewerContext);
+};
+var useViewerSize = function useViewerSize() {
+  var _useViewerContext = useViewerContext(),
+    width = _useViewerContext.width,
+    height = _useViewerContext.height;
+  return {
+    width: width,
+    height: height
+  };
+};
+var useViewerNavigation = function useViewerNavigation() {
+  var _useViewerContext2 = useViewerContext(),
+    gotoNextScreen = _useViewerContext2.gotoNextScreen,
+    gotoPreviousScreen = _useViewerContext2.gotoPreviousScreen;
+  return {
+    gotoNextScreen: gotoNextScreen,
+    gotoPreviousScreen: gotoPreviousScreen
+  };
+};
+var useViewerEvents = function useViewerEvents() {
+  var _useViewerContext3 = useViewerContext(),
+    events = _useViewerContext3.events;
+  return events;
+};
+var useViewerContainer = function useViewerContainer() {
+  var _useViewerContext4 = useViewerContext(),
+    _useViewerContext4$co = _useViewerContext4.containerRef,
+    containerRef = _useViewerContext4$co === void 0 ? null : _useViewerContext4$co;
+  return containerRef !== null ? containerRef.current : null;
+};
+var useViewerInteraction = function useViewerInteraction() {
+  var _useViewerContext5 = useViewerContext(),
+    disableInteraction = _useViewerContext5.disableInteraction,
+    enableInteraction = _useViewerContext5.enableInteraction;
+  return {
+    disableInteraction: disableInteraction,
+    enableInteraction: enableInteraction
+  };
+};
+var useViewerWebView = function useViewerWebView() {
+  var _useViewerContext6 = useViewerContext(),
+    webView = _useViewerContext6.webView,
+    setWebView = _useViewerContext6.setWebView;
+  var value = React.useMemo(function () {
+    return _objectSpread(_objectSpread({}, webView), {}, {
+      opened: webView !== null,
+      open: function open(newWebView) {
+        return setWebView(isString(newWebView) ? {
+          url: newWebView
+        } : newWebView);
+      },
+      close: function close() {
+        return setWebView(null);
+      },
+      update: function update(newWebView) {
+        return setWebView(_objectSpread(_objectSpread({}, webView), newWebView));
+      }
+    });
+  }, [webView, setWebView]);
+  return value;
+};
+var propTypes$1 = {
+  children: PropTypes.node.isRequired,
+  events: PropTypes.instanceOf(EventEmitter),
+  containerRef: PropTypes.oneOfType([PropTypes.func, PropTypes.shape({
+    // eslint-disable-next-line react/forbid-prop-types
+    current: PropTypes.any
+  })]),
+  menuVisible: PropTypes.bool,
+  menuOverScreen: PropTypes.bool,
+  width: PropTypes.number,
+  height: PropTypes.number,
+  topHeight: PropTypes.number,
+  bottomHeight: PropTypes.number,
+  bottomSidesWidth: PropTypes.number,
+  gotoNextScreen: PropTypes.func,
+  gotoPreviousScreen: PropTypes.func,
+  disableInteraction: PropTypes.func,
+  enableInteraction: PropTypes.func
+};
+var defaultProps$1 = _objectSpread({}, defaultValue);
+var ViewerProvider = function ViewerProvider(_ref) {
+  var children = _ref.children,
+    containerRef = _ref.containerRef,
+    events = _ref.events,
+    menuVisible = _ref.menuVisible,
+    menuOverScreen = _ref.menuOverScreen,
+    width = _ref.width,
+    height = _ref.height,
+    topHeight = _ref.topHeight,
+    bottomHeight = _ref.bottomHeight,
+    bottomSidesWidth = _ref.bottomSidesWidth,
+    gotoNextScreen = _ref.gotoNextScreen,
+    gotoPreviousScreen = _ref.gotoPreviousScreen,
+    disableInteraction = _ref.disableInteraction,
+    enableInteraction = _ref.enableInteraction;
+  var _useState = React.useState(null),
+    _useState2 = _slicedToArray(_useState, 2),
+    webView = _useState2[0],
+    setWebView = _useState2[1];
+  var value = React.useMemo(function () {
+    return {
+      containerRef: containerRef,
+      events: events,
+      menuVisible: menuVisible,
+      menuOverScreen: menuOverScreen,
+      width: width,
+      height: height,
+      topHeight: topHeight,
+      bottomHeight: bottomHeight,
+      bottomSidesWidth: bottomSidesWidth,
+      gotoNextScreen: gotoNextScreen,
+      gotoPreviousScreen: gotoPreviousScreen,
+      disableInteraction: disableInteraction,
+      enableInteraction: enableInteraction,
+      webView: webView,
+      setWebView: setWebView
+    };
+  }, [containerRef, events, menuVisible, menuOverScreen, width, height, topHeight, bottomHeight, bottomSidesWidth, gotoNextScreen, gotoPreviousScreen, disableInteraction, enableInteraction, webView, setWebView]);
+  return /*#__PURE__*/React.createElement(ViewerContext.Provider, {
+    value: value
+  }, children);
+};
+ViewerProvider.propTypes = propTypes$1;
+ViewerProvider.defaultProps = defaultProps$1;
+
+var VisitorContext = /*#__PURE__*/React.createContext({
+  visitor: null,
+  setVisitor: function setVisitor() {}
+});
+var useVisitorContext = function useVisitorContext() {
+  var _useContext = React.useContext(VisitorContext),
+    visitor = _useContext.visitor,
+    setVisitor = _useContext.setVisitor;
+  return {
+    visitor: visitor,
+    setVisitor: setVisitor
+  };
+};
+var useVisitor = function useVisitor() {
+  var _useContext2 = React.useContext(VisitorContext),
+    visitor = _useContext2.visitor;
+  return visitor;
+};
+var useSetVisitor = function useSetVisitor() {
+  var _useContext3 = React.useContext(VisitorContext),
+    setVisitor = _useContext3.setVisitor;
+  return setVisitor;
+};
+var propTypes = {
+  children: PropTypes.node.isRequired,
+  visitor: core.PropTypes.visitor
+};
+var defaultProps = {
+  visitor: null
+};
+var VisitorProvider = function VisitorProvider(_ref) {
+  var providedVisitor = _ref.visitor,
+    children = _ref.children;
+  var _useState = React.useState(providedVisitor),
+    _useState2 = _slicedToArray(_useState, 2),
+    visitor = _useState2[0],
+    setVisitor = _useState2[1];
+  React.useEffect(function () {
+    if (providedVisitor !== visitor) {
+      setVisitor(providedVisitor);
+    }
+  }, [providedVisitor, setVisitor]);
+  var value = React.useMemo(function () {
+    return {
+      visitor: visitor,
+      setVisitor: function setVisitor(newVisitor) {
+        return isString(newVisitor) ? {
+          id: newVisitor
+        } : newVisitor;
+      }
+    };
+  }, [visitor, setVisitor]);
+  return /*#__PURE__*/React.createElement(VisitorContext.Provider, {
+    value: value
+  }, children);
+};
+VisitorProvider.propTypes = propTypes;
+VisitorProvider.defaultProps = defaultProps;
+
+Object.defineProperty(exports, "RoutesContext", {
+    enumerable: true,
+    get: function () { return routes.RoutesContext; }
+});
+Object.defineProperty(exports, "RoutesProvider", {
+    enumerable: true,
+    get: function () { return routes.RoutesProvider; }
+});
+Object.defineProperty(exports, "useRoutes", {
+    enumerable: true,
+    get: function () { return routes.useRoutes; }
+});
+Object.defineProperty(exports, "useUrlGenerator", {
+    enumerable: true,
+    get: function () { return routes.useUrlGenerator; }
+});
+Object.defineProperty(exports, "TrackingContext", {
+    enumerable: true,
+    get: function () { return tracking.TrackingContext; }
+});
+exports.ComponentsContext = ComponentsContext;
+exports.ComponentsProvider = ComponentsProvider;
+exports.ConsentContext = ConsentContext;
+exports.ConsentProvider = ConsentProvider;
+exports.ELEMENTS_NAMESPACE = ELEMENTS_NAMESPACE;
+exports.EditorContext = EditorContext;
+exports.EditorProvider = EditorProvider;
+exports.FIELDS_NAMESPACE = FIELDS_NAMESPACE;
+exports.FORMS_NAMESPACE = FORMS_NAMESPACE;
+exports.FieldContext = FieldContext;
+exports.FieldContextProvider = FieldContextProvider;
+exports.FieldsContext = FieldsContext;
+exports.FieldsProvider = FieldsProvider;
+exports.FieldsValueContext = FieldsValueContext;
+exports.FieldsValueContextProvider = FieldsValueContextProvider;
+exports.FontsContext = FontsContext;
+exports.FontsProvider = FontsProvider;
+exports.GoogleApiClientContext = GoogleApiClientContext;
+exports.GoogleApiClientProvider = GoogleApiClientProvider;
+exports.GoogleKeysContext = GoogleKeysContext;
+exports.GoogleKeysProvider = GoogleKeysProvider;
+exports.GoogleMapsClientContext = GoogleMapsClientContext;
+exports.GoogleMapsClientProvider = GoogleMapsClientProvider;
+exports.MODALS_NAMESPACE = MODALS_NAMESPACE;
+exports.ModalsContext = ModalsContext;
+exports.ModalsProvider = ModalsProvider;
+exports.PanelsContext = PanelsContext;
+exports.PanelsProvider = PanelsProvider;
+exports.PlaybackContext = PlaybackContext;
+exports.PlaybackProvider = PlaybackProvider;
+exports.SCREENS_NAMESPACE = SCREENS_NAMESPACE;
+exports.ScreenContext = ScreenContext;
+exports.ScreenProvider = ScreenProvider;
+exports.ScreenSizeContext = ScreenSizeContext;
+exports.ScreenSizeProvider = ScreenSizeProvider;
+exports.ScreensContext = ScreensContext;
+exports.ScreensProvider = ScreensProvider;
+exports.StoryContext = StoryContext;
+exports.StoryProvider = StoryProvider;
+exports.TrackingProvider = TrackingProvider;
+exports.ViewerContext = ViewerContext;
+exports.ViewerProvider = ViewerProvider;
+exports.VisitorContext = VisitorContext;
+exports.VisitorProvider = VisitorProvider;
+exports.useComponent = useComponent;
+exports.useComponents = useComponents;
+exports.useComponentsManager = useComponentsManager;
+exports.useConsent = useConsent;
+exports.useEditor = useEditor;
+exports.useElementComponent = useElementComponent;
+exports.useElementsComponents = useElementsComponents;
+exports.useElementsComponentsManager = useElementsComponentsManager;
+exports.useFieldComponent = useFieldComponent;
+exports.useFieldContext = useFieldContext;
+exports.useFieldDefinition = useFieldDefinition;
+exports.useFieldsComponents = useFieldsComponents;
+exports.useFieldsComponentsManager = useFieldsComponentsManager;
+exports.useFieldsManager = useFieldsManager;
+exports.useFieldsValue = useFieldsValue;
+exports.useFonts = useFonts;
+exports.useFormComponent = useFormComponent;
+exports.useFormsComponents = useFormsComponents;
+exports.useFormsComponentsManager = useFormsComponentsManager;
+exports.useGetColors = useGetColors;
+exports.useGoogleApiClient = useGoogleApiClient;
+exports.useGoogleFonts = useGoogleFonts;
+exports.useGoogleKeys = useGoogleKeys;
+exports.useGoogleMapsClient = useGoogleMapsClient;
+exports.useModalComponent = useModalComponent;
+exports.useModals = useModals;
+exports.useModalsComponents = useModalsComponents;
+exports.useModalsComponentsManager = useModalsComponentsManager;
+exports.usePanels = usePanels;
+exports.usePlaybackContext = usePlaybackContext;
+exports.usePlaybackMediaRef = usePlaybackMediaRef;
+exports.useRouteBack = useRouteBack;
+exports.useRoutePush = useRoutePush;
+exports.useScreen = useScreen;
+exports.useScreenComponent = useScreenComponent;
+exports.useScreenData = useScreenData;
+exports.useScreenDefinition = useScreenDefinition;
+exports.useScreenRenderContext = useScreenRenderContext;
+exports.useScreenSize = useScreenSize;
+exports.useScreenState = useScreenState;
+exports.useScreensComponents = useScreensComponents;
+exports.useScreensComponentsManager = useScreensComponentsManager;
+exports.useScreensManager = useScreensManager;
+exports.useSetVisitor = useSetVisitor;
+exports.useStory = useStory;
+exports.useStoryContext = useStoryContext;
+exports.useTracking = useTracking;
+exports.useViewerContainer = useViewerContainer;
+exports.useViewerContext = useViewerContext;
+exports.useViewerEvents = useViewerEvents;
+exports.useViewerInteraction = useViewerInteraction;
+exports.useViewerNavigation = useViewerNavigation;
+exports.useViewerSize = useViewerSize;
+exports.useViewerWebView = useViewerWebView;
+exports.useVisitor = useVisitor;
+exports.useVisitorContext = useVisitorContext;
+exports.withGoogleApiClient = withGoogleApiClient;
+exports.withGoogleMapsClient = withGoogleMapsClient;
+exports.withModals = withModals;
+exports.withPanels = withPanels;