@panneau/core 3.0.300 → 4.0.0

package/lib/contexts.js

@@ -0,0 +1,1406 @@
+'use strict';
+
+var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
+var isString = require('lodash-es/isString');
+var React = require('react');
+var core = require('@panneau/core');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
+var uniqBy = require('lodash-es/uniqBy');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var fetch = require('@folklore/fetch');
+var isObject = require('lodash-es/isObject');
+var services = require('@folklore/services');
+var reactIntl = require('react-intl');
+var utils = require('@panneau/core/utils');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var PropTypes = require('prop-types');
+var jsxRuntime = require('react/jsx-runtime');
+var pathToRegexp = require('path-to-regexp');
+var regexparam = require('regexparam');
+var index_js = require('use-sync-external-store/shim/index.js');
+var tracking = require('@folklore/tracking');
+
+function _interopNamespaceDefault(e) {
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
+        });
+    }
+    n.default = e;
+    return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
+var MODALS_NAMESPACE = 'modals';
+var FIELDS_NAMESPACE = 'fields';
+var FORMS_NAMESPACE = 'forms';
+var FILTERS_NAMESPACE = 'filters';
+var LISTS_NAMESPACE = 'lists';
+var DISPLAYS_NAMESPACE = 'displays';
+var ACTIONS_NAMESPACE = 'actions';
+var BUTTONS_NAMESPACE = 'buttons';
+var PAGES_NAMESPACE = 'pages';
+var PREVIEWS_NAMESPACE = 'previews';
+var APP_NAMESPACE = 'app';
+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);
+};
+
+/**
+ * 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);
+};
+
+/**
+ * Filters hooks
+ */
+var useFiltersComponentsManager = function useFiltersComponentsManager() {
+  return useComponentsManager(FILTERS_NAMESPACE);
+};
+var useFiltersComponents = function useFiltersComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(FILTERS_NAMESPACE, defaultComponents);
+};
+var useFilterComponent = function useFilterComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, FILTERS_NAMESPACE);
+};
+
+/**
+ * Lists hooks
+ */
+var useListsComponentsManager = function useListsComponentsManager() {
+  return useComponentsManager(LISTS_NAMESPACE);
+};
+var useListsComponents = function useListsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(LISTS_NAMESPACE, defaultComponents);
+};
+var useListComponent = function useListComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, LISTS_NAMESPACE);
+};
+
+/**
+ * Displays hooks
+ */
+var useDisplaysComponentsManager = function useDisplaysComponentsManager() {
+  return useComponentsManager(DISPLAYS_NAMESPACE);
+};
+var useDisplaysComponents = function useDisplaysComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(DISPLAYS_NAMESPACE, defaultComponents);
+};
+var useDisplayComponent = function useDisplayComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, DISPLAYS_NAMESPACE);
+};
+
+/**
+ * Actions hooks
+ */
+var useActionsComponentsManager = function useActionsComponentsManager() {
+  return useComponentsManager(ACTIONS_NAMESPACE);
+};
+var useActionsComponents = function useActionsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(ACTIONS_NAMESPACE, defaultComponents);
+};
+var useActionComponent = function useActionComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, ACTIONS_NAMESPACE);
+};
+
+/**
+ * Buttons hooks
+ */
+var useButtonsComponentsManager = function useButtonsComponentsManager() {
+  return useComponentsManager(BUTTONS_NAMESPACE);
+};
+var useButtonsComponents = function useButtonsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(BUTTONS_NAMESPACE, defaultComponents);
+};
+var useButtonComponent = function useButtonComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, BUTTONS_NAMESPACE);
+};
+
+/**
+ * Pages hooks
+ */
+var usePagesComponentsManager = function usePagesComponentsManager() {
+  return useComponentsManager(PAGES_NAMESPACE);
+};
+var usePagesComponents = function usePagesComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(PAGES_NAMESPACE, defaultComponents);
+};
+var usePageComponent = function usePageComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, PAGES_NAMESPACE);
+};
+
+/**
+ * Previews hooks
+ */
+var usePreviewsComponentsManager = function usePreviewsComponentsManager() {
+  return useComponentsManager(PREVIEWS_NAMESPACE);
+};
+var usePreviewsComponents = function usePreviewsComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(PREVIEWS_NAMESPACE, defaultComponents);
+};
+var usePreviewComponent = function usePreviewComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, PREVIEWS_NAMESPACE);
+};
+
+/**
+ * App hooks
+ */
+var useAppComponentsManager = function useAppComponentsManager() {
+  return useComponentsManager(APP_NAMESPACE);
+};
+var useAppComponents = function useAppComponents() {
+  var defaultComponents = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return useComponents(APP_NAMESPACE, defaultComponents);
+};
+var useAppComponent = function useAppComponent(name) {
+  var defaultComponent = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  return useComponent(name, defaultComponent, APP_NAMESPACE);
+};
+
+/**
+ * Provider
+ */
+
+var DEFAULT_COMPONENTS$1 = {};
+function ComponentsProvider(_ref) {
+  var _ref$components = _ref.components,
+    components = _ref$components === void 0 ? DEFAULT_COMPONENTS$1 : _ref$components,
+    _ref$manager = _ref.manager,
+    manager = _ref$manager === void 0 ? null : _ref$manager,
+    _ref$namespace = _ref.namespace,
+    namespace = _ref$namespace === void 0 ? null : _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);
+}
+
+/* eslint-disable react/jsx-props-no-spreading */
+var DefinitionContext = /*#__PURE__*/React.createContext(null);
+var useDefinitionContext = function useDefinitionContext() {
+  return React.useContext(DefinitionContext);
+};
+var useDefinition = function useDefinition() {
+  var definition = useDefinitionContext();
+  return definition || null;
+};
+function DefinitionProvider(_ref) {
+  var definition = _ref.definition,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(DefinitionContext.Provider, {
+    value: definition
+  }, children);
+}
+
+var FieldsContext = /*#__PURE__*/React.createContext(null);
+var useFieldsManager = function useFieldsManager() {
+  return React.useContext(FieldsContext);
+};
+var useField = function useField(id) {
+  var manager = useFieldsManager();
+  return manager.getDefinition(id);
+};
+var useFields = function useFields() {
+  var manager = useFieldsManager();
+  return manager.getDefinitions();
+};
+function FieldsProvider(_ref) {
+  var _ref$fields = _ref.fields,
+    fields = _ref$fields === void 0 ? null : _ref$fields,
+    _ref$manager = _ref.manager,
+    manager = _ref$manager === void 0 ? null : _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));
+}
+
+/* eslint-disable react/jsx-props-no-spreading */
+var GoogleKeysContext = /*#__PURE__*/React.createContext({
+  apiKey: null
+});
+var useGoogleKeys = function useGoogleKeys() {
+  return React.useContext(GoogleKeysContext);
+};
+function GoogleKeysProvider(_ref) {
+  var children = _ref.children,
+    _ref$apiKey = _ref.apiKey,
+    apiKey = _ref$apiKey === void 0 ? null : _ref$apiKey;
+  var _useGoogleKeys = useGoogleKeys(),
+    previousApiKey = _useGoogleKeys.apiKey;
+  var value = React.useMemo(function () {
+    return {
+      apiKey: apiKey || previousApiKey
+    };
+  }, [previousApiKey, apiKey]);
+  return /*#__PURE__*/React.createElement(GoogleKeysContext.Provider, {
+    value: value
+  }, children);
+}
+
+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 DEFAULT_SYSTEM_FONTS = ['Arial', 'Courier', 'Georgia', 'Times New Roman', 'Verdana'];
+function FontsProvider(_ref4) {
+  var _ref4$systemFonts = _ref4.systemFonts,
+    systemFonts = _ref4$systemFonts === void 0 ? DEFAULT_SYSTEM_FONTS : _ref4$systemFonts,
+    _ref4$customFonts = _ref4.customFonts,
+    customFonts = _ref4$customFonts === void 0 ? null : _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,
+    _useFonts$customFonts = _useFonts.customFonts,
+    previousCustomFonts = _useFonts$customFonts === void 0 ? null : _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);
+}
+
+/* eslint-disable react/jsx-props-no-spreading */
+var FormContext = /*#__PURE__*/React.createContext(null);
+var useForm = function useForm() {
+  return React.useContext(FormContext);
+};
+var useFormValue = function useFormValue() {
+  var _useForm = useForm(),
+    value = _useForm.value;
+  return value;
+};
+var useFormSetValue = function useFormSetValue() {
+  var _useForm2 = useForm(),
+    setValue = _useForm2.setValue;
+  return setValue;
+};
+function FormProvider(_ref) {
+  var value = _ref.value,
+    setValue = _ref.setValue,
+    children = _ref.children;
+  var values = React.useMemo(function () {
+    return {
+      value: value,
+      setValue: setValue
+    };
+  }, [value, setValue]);
+  return /*#__PURE__*/React.createElement(FormContext.Provider, {
+    value: values
+  }, children);
+}
+
+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;
+};
+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);
+}
+
+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;
+};
+function GoogleMapsClientProvider(_ref2) {
+  var children = _ref2.children,
+    _ref2$locale = _ref2.locale,
+    locale = _ref2$locale === void 0 ? 'fr' : _ref2$locale,
+    _ref2$libraries = _ref2.libraries,
+    libraries = _ref2$libraries === void 0 ? null : _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);
+}
+
+/* eslint-disable react/jsx-props-no-spreading */
+var defaultLocales = ['en', 'fr'];
+var LocalesContext = /*#__PURE__*/React.createContext({
+  locales: defaultLocales
+});
+var useLocalesContext = function useLocalesContext() {
+  var context = React.useContext(LocalesContext);
+  return context;
+};
+var useLocales = function useLocales() {
+  var _useLocalesContext = useLocalesContext(),
+    locales = _useLocalesContext.locales;
+  return locales;
+};
+var useOtherLocales = function useOtherLocales() {
+  var _useLocalesContext2 = useLocalesContext(),
+    locales = _useLocalesContext2.locales;
+  var _useIntl = reactIntl.useIntl(),
+    locale = _useIntl.locale;
+  var otherLocales = React.useMemo(function () {
+    return locales.filter(function (it) {
+      return it !== locale;
+    });
+  }, [locales, locale]);
+  return otherLocales;
+};
+var DEFAULT_LOCALES = [];
+function LocalesProvider(_ref) {
+  var _ref$locales = _ref.locales,
+    locales = _ref$locales === void 0 ? DEFAULT_LOCALES : _ref$locales,
+    children = _ref.children;
+  var value = React.useMemo(function () {
+    return {
+      locales: locales
+    };
+  }, [locales]);
+  return /*#__PURE__*/React.createElement(LocalesContext.Provider, {
+    value: value
+  }, children);
+}
+
+var ModalContext = /*#__PURE__*/React.createContext(null);
+var useModal = function useModal() {
+  return React.useContext(ModalContext) || {};
+};
+var DEFAULT_MODALS = [];
+function ModalProvider(_ref) {
+  var children = _ref.children,
+    _ref$container = _ref.container,
+    initialContainer = _ref$container === void 0 ? null : _ref$container;
+  var _useState = React.useState(initialContainer),
+    _useState2 = _slicedToArray(_useState, 2),
+    container = _useState2[0],
+    setContainer = _useState2[1];
+  var _useState3 = React.useState(DEFAULT_MODALS),
+    _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 _modalsRef$current = modalsRef.current,
+      currentModals = _modalsRef$current === void 0 ? [] : _modalsRef$current;
+    var newModals = [].concat(_toConsumableArray(currentModals), [_objectSpread({
+      id: id
+    }, data)]);
+    setModals(newModals);
+    modalsRef.current = newModals;
+  }, [setModals]);
+  var unregister = React.useCallback(function () {
+    var id = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var data = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    var _modalsRef$current2 = modalsRef.current,
+      currentModals = _modalsRef$current2 === void 0 ? [] : _modalsRef$current2;
+    var foundIndex = currentModals.findIndex(function (_ref2) {
+      var modalId = _ref2.id;
+      return modalId === id;
+    });
+    if (foundIndex !== -1) {
+      var _ref3 = data || {},
+        _ref3$onClose = _ref3.onClose,
+        onClose = _ref3$onClose === void 0 ? null : _ref3$onClose;
+      if (onClose !== null) {
+        onClose();
+      }
+      var newModals = currentModals.filter(function (_ref4) {
+        var modalId = _ref4.id;
+        return modalId !== id;
+      });
+      setModals(newModals);
+      modalsRef.current = newModals;
+    }
+  }, [setModals]);
+  var closeLastModal = React.useCallback(function () {
+    var lastModal = modals.pop() || null;
+    if (lastModal !== null) {
+      var _ref5 = lastModal || {},
+        _ref5$id = _ref5.id,
+        lastModalId = _ref5$id === void 0 ? null : _ref5$id,
+        _ref5$onClose = _ref5.onClose,
+        onClose = _ref5$onClose === void 0 ? null : _ref5$onClose;
+      if (onClose !== null) {
+        onClose();
+      }
+      var newModals = modals.filter(function (_ref6) {
+        var modalId = _ref6.id;
+        return modalId !== lastModalId;
+      });
+      setModals(newModals);
+      modalsRef.current = newModals;
+    }
+  }, [modals, setModals]);
+  var getModalById = React.useCallback(function (modalId) {
+    return (modals || []).find(function (modal) {
+      return (modal === null || modal === void 0 ? void 0 : modal.id) === modalId;
+    }) || null;
+  }, [modals]);
+  var value = React.useMemo(function () {
+    return {
+      modals: modals,
+      container: container,
+      setContainer: setContainer,
+      register: register,
+      unregister: unregister,
+      closeLastModal: closeLastModal,
+      getModalById: getModalById
+    };
+  }, [modals, container, setContainer, register, unregister, closeLastModal, getModalById]);
+  return /*#__PURE__*/React.createElement(ModalContext.Provider, {
+    value: value
+  }, children);
+}
+
+var PanelsContext = /*#__PURE__*/React.createContext({
+  panels: [],
+  container: null,
+  setContainer: function setContainer() {},
+  register: function register() {},
+  unregister: function unregister() {}
+});
+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;
+};
+function PanelsProvider(_ref2) {
+  var children = _ref2.children,
+    _ref2$container = _ref2.container,
+    initialContainer = _ref2$container === void 0 ? null : _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);
+}
+
+var _excluded = ["component"];
+var PanneauContext = /*#__PURE__*/React.createContext(null);
+var usePanneau = function usePanneau() {
+  return React.useContext(PanneauContext);
+};
+var DEFAULT_RESOURCES = [];
+var usePanneauResources = function usePanneauResources() {
+  var _ref = usePanneau() || {},
+    _ref$resources = _ref.resources,
+    resources = _ref$resources === void 0 ? DEFAULT_RESOURCES : _ref$resources;
+  return resources;
+};
+var usePanneauResource = function usePanneauResource(id) {
+  var resources = usePanneauResources();
+  return resources.find(function (it) {
+    return it.id === id;
+  }) || null;
+};
+var usePanneauColorScheme = function usePanneauColorScheme() {
+  var _ref2 = usePanneau() || {},
+    _ref2$theme = _ref2.theme,
+    theme = _ref2$theme === void 0 ? {} : _ref2$theme;
+  var _ref3 = theme || {},
+    _ref3$colorScheme = _ref3.colorScheme,
+    colorScheme = _ref3$colorScheme === void 0 ? 'light' : _ref3$colorScheme;
+  if (colorScheme === null || colorScheme === 'light' || colorScheme === 'dark') {
+    return colorScheme === 'dark' ? {
+      theme: 'dark',
+      background: 'dark',
+      text: 'light'
+    } : {
+      theme: 'light',
+      background: 'light',
+      text: 'dark'
+    };
+  }
+  return {
+    theme: colorScheme,
+    background: null,
+    text: null
+  };
+};
+var DEFAULT_COMPONENTS = {};
+var usePanneauComponents = function usePanneauComponents() {
+  var _ref4 = usePanneau() || {},
+    _ref4$components = _ref4.components,
+    components = _ref4$components === void 0 ? DEFAULT_COMPONENTS : _ref4$components;
+  return components;
+};
+var usePanneauComponent = function usePanneauComponent(namespace, name) {
+  var _ref5 = usePanneau() || {},
+    _ref5$components = _ref5.components,
+    components = _ref5$components === void 0 ? {} : _ref5$components;
+  var path = namespace !== null ? "".concat(namespace, ".").concat(name) : name || null;
+  var component = components[path] || null;
+  if (isString(component)) {
+    return component;
+  }
+  if (isObject(component) && isString(component === null || component === void 0 ? void 0 : component.componnent)) {
+    // eslint-disable-next-line no-unused-vars
+    component.component;
+      _objectWithoutProperties(component, _excluded);
+    return component.component;
+  }
+  return null;
+};
+var usePanneauAuth = function usePanneauAuth() {
+  var _ref6 = usePanneau() || {},
+    _ref6$auth = _ref6.auth,
+    auth = _ref6$auth === void 0 ? {} : _ref6$auth;
+  return auth;
+};
+var usePanneauSettings = function usePanneauSettings() {
+  var _ref7 = usePanneau() || {},
+    _ref7$settings = _ref7.settings,
+    settings = _ref7$settings === void 0 ? {} : _ref7$settings;
+  return settings;
+};
+function PanneauProvider(_ref8) {
+  var definition = _ref8.definition,
+    children = _ref8.children;
+  return /*#__PURE__*/React.createElement(PanneauContext.Provider, {
+    value: definition
+  }, children);
+}
+
+/* eslint-disable react/jsx-props-no-spreading */
+var ResourceContext = /*#__PURE__*/React.createContext(null);
+var useResource = function useResource() {
+  return React.useContext(ResourceContext);
+};
+function ResourceProvider(_ref) {
+  var resource = _ref.resource,
+    children = _ref.children;
+  return /*#__PURE__*/React.createElement(ResourceContext.Provider, {
+    value: resource
+  }, children);
+}
+
+// React.useInsertionEffect is not available in React <18
+// This hack fixes a transpilation issue on some apps
+var useBuiltinInsertionEffect = React__namespace["useInsertion" + "Effect"];
+
+// Copied from:
+// https://github.com/facebook/react/blob/main/packages/shared/ExecutionEnvironment.js
+var canUseDOM = !!(typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined");
+
+// Copied from:
+// https://github.com/reduxjs/react-redux/blob/master/src/utils/useIsomorphicLayoutEffect.ts
+// "React currently throws a warning when using useLayoutEffect on the server.
+// To get around it, we can conditionally useEffect on the server (no-op) and
+// useLayoutEffect in the browser."
+var useIsomorphicLayoutEffect = canUseDOM ? React__namespace.useLayoutEffect : React__namespace.useEffect;
+
+// useInsertionEffect is already a noop on the server.
+// See: https://github.com/facebook/react/blob/main/packages/react-server/src/ReactFizzHooks.js
+var useInsertionEffect = useBuiltinInsertionEffect || useIsomorphicLayoutEffect;
+
+// Userland polyfill while we wait for the forthcoming
+// https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md
+// Note: "A high-fidelity polyfill for useEvent is not possible because
+// there is no lifecycle or Hook in React that we can use to switch
+// .current at the right timing."
+// So we will have to make do with this "close enough" approach for now.
+var useEvent = function useEvent(fn) {
+  var ref = React__namespace.useRef([fn, function () {
+    return ref[0].apply(ref, arguments);
+  }]).current;
+  // Per Dan Abramov: useInsertionEffect executes marginally closer to the
+  // correct timing for ref synchronization than useLayoutEffect on React 18.
+  // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
+  useInsertionEffect(function () {
+    ref[0] = fn;
+  });
+  return ref[1];
+};
+
+/**
+ * History API docs @see https://developer.mozilla.org/en-US/docs/Web/API/History
+ */
+var eventPopstate = "popstate";
+var eventPushState = "pushState";
+var eventReplaceState = "replaceState";
+var eventHashchange = "hashchange";
+var events = [eventPopstate, eventPushState, eventReplaceState, eventHashchange];
+var subscribeToLocationUpdates = function subscribeToLocationUpdates(callback) {
+  for (var _i = 0, _events = events; _i < _events.length; _i++) {
+    var event = _events[_i];
+    addEventListener(event, callback);
+  }
+  return function () {
+    for (var _i2 = 0, _events2 = events; _i2 < _events2.length; _i2++) {
+      var _event = _events2[_i2];
+      removeEventListener(_event, callback);
+    }
+  };
+};
+var useLocationProperty = function useLocationProperty(fn, ssrFn) {
+  return index_js.useSyncExternalStore(subscribeToLocationUpdates, fn, ssrFn);
+};
+var currentSearch = function currentSearch() {
+  return location.search;
+};
+var useSearch = function useSearch() {
+  var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref$ssrSearch = _ref.ssrSearch,
+    ssrSearch = _ref$ssrSearch === void 0 ? "" : _ref$ssrSearch;
+  return useLocationProperty(currentSearch, function () {
+    return ssrSearch;
+  });
+};
+var currentPathname = function currentPathname() {
+  return location.pathname;
+};
+var usePathname = function usePathname() {
+  var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    ssrPath = _ref2.ssrPath;
+  return useLocationProperty(currentPathname, ssrPath ? function () {
+    return ssrPath;
+  } : currentPathname);
+};
+var navigate = function navigate(to) {
+  var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+    _ref3$replace = _ref3.replace,
+    replace = _ref3$replace === void 0 ? false : _ref3$replace,
+    _ref3$state = _ref3.state,
+    state = _ref3$state === void 0 ? null : _ref3$state;
+  return history[replace ? eventReplaceState : eventPushState](state, "", to);
+};
+
+// the 2nd argument of the `useBrowserLocation` return value is a function
+// that allows to perform a navigation.
+var useBrowserLocation = function useBrowserLocation() {
+  var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return [usePathname(opts), navigate];
+};
+var patchKey = Symbol["for"]("wouter_v3");
+
+// While History API does have `popstate` event, the only
+// proper way to listen to changes via `push/replaceState`
+// is to monkey-patch these methods.
+//
+// See https://stackoverflow.com/a/4585031
+if (typeof history !== "undefined" && typeof window[patchKey] === "undefined") {
+  var _loop = function _loop() {
+    var type = _arr[_i3];
+    var original = history[type];
+    // TODO: we should be using unstable_batchedUpdates to avoid multiple re-renders,
+    // however that will require an additional peer dependency on react-dom.
+    // See: https://github.com/reactwg/react-18/discussions/86#discussioncomment-1567149
+    history[type] = function () {
+      var result = original.apply(this, arguments);
+      var event = new Event(type);
+      event.arguments = arguments;
+      dispatchEvent(event);
+      return result;
+    };
+  };
+  for (var _i3 = 0, _arr = [eventPushState, eventReplaceState]; _i3 < _arr.length; _i3++) {
+    _loop();
+  }
+
+  // patch history object only once
+  // See: https://github.com/molefrog/wouter/issues/167
+  Object.defineProperty(window, patchKey, {
+    value: true
+  });
+}
+
+var _excluded3 = ["to", "href", "onClick", "asChild", "children", "className", "replace", "state"];
+
+/*
+ * Transforms `path` into its relative `base` version
+ * If base isn't part of the path provided returns absolute path e.g. `~/app`
+ */
+var _relativePath = function _relativePath(base, path) {
+  return !path.toLowerCase().indexOf(base.toLowerCase()) ? path.slice(base.length) || "/" : "~" + path;
+};
+
+/**
+ * When basepath is `undefined` or '/' it is ignored (we assume it's empty string)
+ */
+var baseDefaults = function baseDefaults() {
+  var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  return base === "/" ? "" : base;
+};
+var absolutePath = function absolutePath(to, base) {
+  return to[0] === "~" ? to.slice(1) : baseDefaults(base) + to;
+};
+var relativePath = function relativePath() {
+  var base = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+  var path = arguments.length > 1 ? arguments[1] : undefined;
+  return _relativePath(unescape(baseDefaults(base)), unescape(path));
+};
+
+/*
+ * decodes escape sequences such as %20
+ */
+var unescape = function unescape(str) {
+  try {
+    return decodeURI(str);
+  } catch (_e) {
+    // fail-safe mode: if string can't be decoded do nothing
+    return str;
+  }
+};
+
+/*
+ * Router and router context. Router is a lightweight object that represents the current
+ * routing options: how location is managed, base path etc.
+ *
+ * There is a default router present for most of the use cases, however it can be overridden
+ * via the <Router /> component.
+ */
+
+var defaultRouter = {
+  hook: useBrowserLocation,
+  searchHook: useSearch,
+  parser: regexparam.parse,
+  base: "",
+  // this option is used to override the current location during SSR
+  ssrPath: undefined,
+  ssrSearch: undefined,
+  // optional context to track render state during SSR
+  ssrContext: undefined,
+  // customizes how `href` props are transformed for <Link />
+  hrefs: function hrefs(x) {
+    return x;
+  }
+};
+var RouterCtx = React.createContext(defaultRouter);
+
+// gets the closest parent router from the context
+var useRouter = function useRouter() {
+  return React.useContext(RouterCtx);
+};
+
+/**
+ * Parameters context. Used by `useParams()` to get the
+ * matched params from the innermost `Route` component.
+ */
+
+var Params0 = {};
+  React.createContext(Params0);
+
+/*
+ * Part 1, Hooks API: useRoute and useLocation
+ */
+
+// Internal version of useLocation to avoid redundant useRouter calls
+
+var useLocationFromRouter = function useLocationFromRouter(router) {
+  var _router$hook = router.hook(router),
+    _router$hook2 = _slicedToArray(_router$hook, 2),
+    location = _router$hook2[0],
+    navigate = _router$hook2[1];
+
+  // the function reference should stay the same between re-renders, so that
+  // it can be passed down as an element prop without any performance concerns.
+  // (This is achieved via `useEvent`.)
+  return [relativePath(router.base, location), useEvent(function (to, navOpts) {
+    return navigate(absolutePath(to, router.base), navOpts);
+  })];
+};
+var useLocation = function useLocation() {
+  return useLocationFromRouter(useRouter());
+};
+React.forwardRef(function (props, ref) {
+  var router = useRouter();
+  var _useLocationFromRoute3 = useLocationFromRouter(router),
+    _useLocationFromRoute4 = _slicedToArray(_useLocationFromRoute3, 2),
+    currentPath = _useLocationFromRoute4[0],
+    navigate = _useLocationFromRoute4[1];
+  var _props$to = props.to,
+    to = _props$to === void 0 ? "" : _props$to,
+    _props$href = props.href,
+    targetPath = _props$href === void 0 ? to : _props$href,
+    _onClick = props.onClick,
+    asChild = props.asChild,
+    children = props.children,
+    cls = props.className;
+    props.replace;
+    props.state;
+    var restProps = _objectWithoutProperties(props, _excluded3);
+  var onClick = useEvent(function (event) {
+    // ignores the navigation when clicked using right mouse button or
+    // by holding a special modifier key: ctrl, command, win, alt, shift
+    if (event.ctrlKey || event.metaKey || event.altKey || event.shiftKey || event.button !== 0) return;
+    _onClick === null || _onClick === void 0 || _onClick(event);
+    if (!event.defaultPrevented) {
+      event.preventDefault();
+      navigate(targetPath, props);
+    }
+  });
+
+  // handle nested routers and absolute paths
+  var href = router.hrefs(targetPath[0] === "~" ? targetPath.slice(1) : router.base + targetPath, router // pass router as a second argument for convinience
+  );
+  return asChild && React.isValidElement(children) ? React.cloneElement(children, {
+    onClick: onClick,
+    href: href
+  }) : React.createElement("a", _objectSpread(_objectSpread({}, restProps), {}, {
+    onClick: onClick,
+    href: href,
+    // `className` can be a function to apply the class if this link is active
+    className: cls !== null && cls !== void 0 && cls.call ? cls(currentPath === targetPath) : cls,
+    children: children,
+    ref: ref
+  }));
+});
+
+/* eslint-disable react/jsx-props-no-spreading */
+var RoutesContext = /*#__PURE__*/React.createContext(null);
+var useRoutesContext = function useRoutesContext() {
+  return React.useContext(RoutesContext);
+};
+var propTypes$1 = {
+  children: PropTypes.node.isRequired,
+  routes: PropTypes.objectOf(PropTypes.string).isRequired,
+  basePath: PropTypes.string
+};
+var defaultProps = {
+  basePath: null
+};
+function RoutesProvider(_ref) {
+  var routes = _ref.routes,
+    basePath = _ref.basePath,
+    children = _ref.children;
+  var value = React.useMemo(function () {
+    return {
+      routes: routes,
+      basePath: basePath
+    };
+  }, [routes, basePath]);
+  return /*#__PURE__*/jsxRuntime.jsx(RoutesContext.Provider, {
+    value: value,
+    children: children
+  });
+}
+RoutesProvider.propTypes = propTypes$1;
+RoutesProvider.defaultProps = defaultProps;
+var compilers = {};
+function generatePath(fullPath, data) {
+  var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  var fullUrlMatches = fullPath.match(/^(https?:\/\/)/);
+  if (typeof compilers[fullPath] === 'undefined') {
+    compilers[fullPath] = pathToRegexp.compile(fullPath.replace(/^(https?:\/\/)/, ''), opts);
+  }
+  var compiler = compilers[fullPath];
+  return fullUrlMatches !== null ? "".concat(fullUrlMatches[1]).concat(compiler(data)) : compiler(data);
+}
+var useUrlGeneratorPathToRepexp = function useUrlGeneratorPathToRepexp() {
+  var _ref2 = useRoutesContext() || {},
+    _ref2$routes = _ref2.routes,
+    routes = _ref2$routes === void 0 ? null : _ref2$routes,
+    _ref2$basePath = _ref2.basePath,
+    basePath = _ref2$basePath === void 0 ? null : _ref2$basePath;
+  var urlGenerator = React.useCallback(function (key, data, opts) {
+    var path = routes !== null ? routes[key] || null : null;
+    if (path === null) {
+      return null;
+    }
+    var url = generatePath(path, data, opts);
+    return basePath !== null ? "".concat(basePath.replace(/\/$/, ''), "/").concat(url.replace(/^\//, '')) : url;
+  }, [routes, basePath]);
+  return urlGenerator;
+};
+var useRoutes = function useRoutes() {
+  var _useRoutesContext = useRoutesContext(),
+    routes = _useRoutesContext.routes;
+  return routes;
+};
+({
+  location: PropTypes.string.isRequired,
+  search: PropTypes.string,
+  children: PropTypes.node.isRequired
+});
+
+var useRoutePush = function useRoutePush() {
+  var url = useUrlGeneratorPathToRepexp();
+  var _useLocation = 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 = useUrlGeneratorPathToRepexp();
+  var _useLocation3 = useLocation(),
+    _useLocation4 = _slicedToArray(_useLocation3, 2),
+    navigate = _useLocation4[1];
+  var back = React.useCallback(function () {
+    return navigate(-1);
+  }, [navigate, url]);
+  return back;
+};
+
+/* eslint-disable react/jsx-props-no-spreading */
+var useTracking = function useTracking() {
+  return React.useContext(tracking.TrackingContext);
+};
+function TrackingProvider(_ref) {
+  var _ref$variables = _ref.variables,
+    variables = _ref$variables === void 0 ? null : _ref$variables,
+    children = _ref.children;
+  var contextTracking = useTracking() || null;
+  var tracking$1 = React.useMemo(function () {
+    if (contextTracking !== null) {
+      contextTracking.setVariables(variables);
+      return contextTracking;
+    }
+    return new core.Tracking({
+      variables: variables
+    });
+  }, [contextTracking, variables]);
+  return /*#__PURE__*/React.createElement(tracking.TrackingContainer, {
+    tracking: tracking$1
+  }, children);
+}
+
+Object.defineProperty(exports, "TrackingContext", {
+    enumerable: true,
+    get: function () { return tracking.TrackingContext; }
+});
+exports.ACTIONS_NAMESPACE = ACTIONS_NAMESPACE;
+exports.APP_NAMESPACE = APP_NAMESPACE;
+exports.BUTTONS_NAMESPACE = BUTTONS_NAMESPACE;
+exports.ComponentsContext = ComponentsContext;
+exports.ComponentsProvider = ComponentsProvider;
+exports.DISPLAYS_NAMESPACE = DISPLAYS_NAMESPACE;
+exports.DefinitionProvider = DefinitionProvider;
+exports.FIELDS_NAMESPACE = FIELDS_NAMESPACE;
+exports.FILTERS_NAMESPACE = FILTERS_NAMESPACE;
+exports.FORMS_NAMESPACE = FORMS_NAMESPACE;
+exports.FieldsContext = FieldsContext;
+exports.FieldsProvider = FieldsProvider;
+exports.FontsContext = FontsContext;
+exports.FontsProvider = FontsProvider;
+exports.FormProvider = FormProvider;
+exports.GoogleApiClientContext = GoogleApiClientContext;
+exports.GoogleApiClientProvider = GoogleApiClientProvider;
+exports.GoogleKeysContext = GoogleKeysContext;
+exports.GoogleKeysProvider = GoogleKeysProvider;
+exports.GoogleMapsClientContext = GoogleMapsClientContext;
+exports.GoogleMapsClientProvider = GoogleMapsClientProvider;
+exports.LISTS_NAMESPACE = LISTS_NAMESPACE;
+exports.LocalesContext = LocalesContext;
+exports.LocalesProvider = LocalesProvider;
+exports.MODALS_NAMESPACE = MODALS_NAMESPACE;
+exports.ModalContext = ModalContext;
+exports.ModalProvider = ModalProvider;
+exports.PAGES_NAMESPACE = PAGES_NAMESPACE;
+exports.PREVIEWS_NAMESPACE = PREVIEWS_NAMESPACE;
+exports.PanelsContext = PanelsContext;
+exports.PanelsProvider = PanelsProvider;
+exports.PanneauProvider = PanneauProvider;
+exports.ResourceProvider = ResourceProvider;
+exports.RoutesContext = RoutesContext;
+exports.RoutesProvider = RoutesProvider;
+exports.TrackingProvider = TrackingProvider;
+exports.useActionComponent = useActionComponent;
+exports.useActionsComponents = useActionsComponents;
+exports.useActionsComponentsManager = useActionsComponentsManager;
+exports.useAppComponent = useAppComponent;
+exports.useAppComponents = useAppComponents;
+exports.useAppComponentsManager = useAppComponentsManager;
+exports.useButtonComponent = useButtonComponent;
+exports.useButtonsComponents = useButtonsComponents;
+exports.useButtonsComponentsManager = useButtonsComponentsManager;
+exports.useComponent = useComponent;
+exports.useComponents = useComponents;
+exports.useComponentsManager = useComponentsManager;
+exports.useDefinition = useDefinition;
+exports.useDefinitionContext = useDefinitionContext;
+exports.useDisplayComponent = useDisplayComponent;
+exports.useDisplaysComponents = useDisplaysComponents;
+exports.useDisplaysComponentsManager = useDisplaysComponentsManager;
+exports.useField = useField;
+exports.useFieldComponent = useFieldComponent;
+exports.useFields = useFields;
+exports.useFieldsComponents = useFieldsComponents;
+exports.useFieldsComponentsManager = useFieldsComponentsManager;
+exports.useFieldsManager = useFieldsManager;
+exports.useFilterComponent = useFilterComponent;
+exports.useFiltersComponents = useFiltersComponents;
+exports.useFiltersComponentsManager = useFiltersComponentsManager;
+exports.useFonts = useFonts;
+exports.useForm = useForm;
+exports.useFormComponent = useFormComponent;
+exports.useFormSetValue = useFormSetValue;
+exports.useFormValue = useFormValue;
+exports.useFormsComponents = useFormsComponents;
+exports.useFormsComponentsManager = useFormsComponentsManager;
+exports.useGoogleApiClient = useGoogleApiClient;
+exports.useGoogleFonts = useGoogleFonts;
+exports.useGoogleKeys = useGoogleKeys;
+exports.useGoogleMapsClient = useGoogleMapsClient;
+exports.useListComponent = useListComponent;
+exports.useListsComponents = useListsComponents;
+exports.useListsComponentsManager = useListsComponentsManager;
+exports.useLocales = useLocales;
+exports.useLocalesContext = useLocalesContext;
+exports.useModal = useModal;
+exports.useModalComponent = useModalComponent;
+exports.useModalsComponents = useModalsComponents;
+exports.useModalsComponentsManager = useModalsComponentsManager;
+exports.useOtherLocales = useOtherLocales;
+exports.usePageComponent = usePageComponent;
+exports.usePagesComponents = usePagesComponents;
+exports.usePagesComponentsManager = usePagesComponentsManager;
+exports.usePanels = usePanels;
+exports.usePanneau = usePanneau;
+exports.usePanneauAuth = usePanneauAuth;
+exports.usePanneauColorScheme = usePanneauColorScheme;
+exports.usePanneauComponent = usePanneauComponent;
+exports.usePanneauComponents = usePanneauComponents;
+exports.usePanneauResource = usePanneauResource;
+exports.usePanneauResources = usePanneauResources;
+exports.usePanneauSettings = usePanneauSettings;
+exports.usePreviewComponent = usePreviewComponent;
+exports.usePreviewsComponents = usePreviewsComponents;
+exports.usePreviewsComponentsManager = usePreviewsComponentsManager;
+exports.useResource = useResource;
+exports.useRouteBack = useRouteBack;
+exports.useRoutePush = useRoutePush;
+exports.useRoutes = useRoutes;
+exports.useTracking = useTracking;
+exports.useUrlGenerator = useUrlGeneratorPathToRepexp;
+exports.withGoogleApiClient = withGoogleApiClient;
+exports.withGoogleMapsClient = withGoogleMapsClient;
+exports.withPanels = withPanels;