chayns-api 1.0.12 → 1.1.0-0

package/dist/esm/components/TestProvider.js

@@ -0,0 +1,308 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useEffect, useState } from "react";
+var api;
+
+var ChaynsProvider = function ChaynsProvider(_ref) {
+  var children = _ref.children;
+
+  var _useState = useState(false),
+      _useState2 = _slicedToArray(_useState, 2),
+      loaded = _useState2[0],
+      setLoaded = _useState2[1];
+
+  useEffect(function () {
+    void _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              _context.next = 2;
+              return import("app2/index2");
+
+            case 2:
+              api = _context.sent;
+              setLoaded(true);
+
+            case 4:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }))();
+  }, []);
+  if (!loaded) return false;
+  return /*#__PURE__*/React.createElement(api.RealChaynsProvider, null, children);
+};
+
+export var useGeoLocation = function useGeoLocation() {
+  var _api;
+
+  return (_api = api).useGeoLocation.apply(_api, arguments);
+};
+export var addGeoLocationListener = function addGeoLocationListener() {
+  var _api2;
+
+  return (_api2 = api).addGeoLocationListener.apply(_api2, arguments);
+};
+export var addScrollListener = function addScrollListener() {
+  var _api3;
+
+  return (_api3 = api).addScrollListener.apply(_api3, arguments);
+};
+export var addVisibilityChangeListener = function addVisibilityChangeListener() {
+  var _api4;
+
+  return (_api4 = api).addVisibilityChangeListener.apply(_api4, arguments);
+};
+export var addWindowMetricsListener = function addWindowMetricsListener() {
+  var _api5;
+
+  return (_api5 = api).addWindowMetricsListener.apply(_api5, arguments);
+};
+export var getAccessToken = function getAccessToken() {
+  var _api6;
+
+  return (_api6 = api).getAccessToken.apply(_api6, arguments);
+};
+export var getAvailableSharingServices = function getAvailableSharingServices() {
+  var _api7;
+
+  return (_api7 = api).getAvailableSharingServices.apply(_api7, arguments);
+};
+export var getGeoLocation = function getGeoLocation() {
+  var _api8;
+
+  return (_api8 = api).getGeoLocation.apply(_api8, arguments);
+};
+export var getUserInfo = function getUserInfo() {
+  var _api9;
+
+  return (_api9 = api).getUserInfo.apply(_api9, arguments);
+};
+export var getScrollPosition = function getScrollPosition() {
+  var _api10;
+
+  return (_api10 = api).getScrollPosition.apply(_api10, arguments);
+};
+export var getWindowMetrics = function getWindowMetrics() {
+  var _api11;
+
+  return (_api11 = api).getWindowMetrics.apply(_api11, arguments);
+};
+export var invokeCall = function invokeCall() {
+  var _api12;
+
+  return (_api12 = api).invokeCall.apply(_api12, arguments);
+};
+export var login = function login() {
+  var _api13;
+
+  return (_api13 = api).login.apply(_api13, arguments);
+};
+export var logout = function logout() {
+  var _api14;
+
+  return (_api14 = api).logout.apply(_api14, arguments);
+};
+export var navigateBack = function navigateBack() {
+  var _api15;
+
+  return (_api15 = api).navigateBack.apply(_api15, arguments);
+};
+export var openImage = function openImage() {
+  var _api16;
+
+  return (_api16 = api).openImage.apply(_api16, arguments);
+};
+export var openUrl = function openUrl() {
+  var _api17;
+
+  return (_api17 = api).openUrl.apply(_api17, arguments);
+};
+export var openVideo = function openVideo() {
+  var _api18;
+
+  return (_api18 = api).openVideo.apply(_api18, arguments);
+};
+export var refreshAccessToken = function refreshAccessToken() {
+  var _api19;
+
+  return (_api19 = api).refreshAccessToken.apply(_api19, arguments);
+};
+export var refreshData = function refreshData() {
+  var _api20;
+
+  return (_api20 = api).refreshData.apply(_api20, arguments);
+};
+export var removeGeoLocationListener = function removeGeoLocationListener() {
+  var _api21;
+
+  return (_api21 = api).removeGeoLocationListener.apply(_api21, arguments);
+};
+export var removeScrollListener = function removeScrollListener() {
+  var _api22;
+
+  return (_api22 = api).removeScrollListener.apply(_api22, arguments);
+};
+export var removeVisibilityChangeListener = function removeVisibilityChangeListener() {
+  var _api23;
+
+  return (_api23 = api).removeVisibilityChangeListener.apply(_api23, arguments);
+};
+export var removeWindowMetricsListener = function removeWindowMetricsListener() {
+  var _api24;
+
+  return (_api24 = api).removeWindowMetricsListener.apply(_api24, arguments);
+};
+export var scrollToY = function scrollToY() {
+  var _api25;
+
+  return (_api25 = api).scrollToY.apply(_api25, arguments);
+};
+export var sendMessageToGroup = function sendMessageToGroup() {
+  var _api26;
+
+  return (_api26 = api).sendMessageToGroup.apply(_api26, arguments);
+};
+export var sendMessageToPage = function sendMessageToPage() {
+  var _api27;
+
+  return (_api27 = api).sendMessageToPage.apply(_api27, arguments);
+};
+export var sendMessageToUser = function sendMessageToUser() {
+  var _api28;
+
+  return (_api28 = api).sendMessageToUser.apply(_api28, arguments);
+};
+export var setAdminMode = function setAdminMode() {
+  var _api29;
+
+  return (_api29 = api).setAdminMode.apply(_api29, arguments);
+};
+export var setDisplayTimeout = function setDisplayTimeout() {
+  var _api30;
+
+  return (_api30 = api).setDisplayTimeout.apply(_api30, arguments);
+};
+export var setFloatingButton = function setFloatingButton() {
+  var _api31;
+
+  return (_api31 = api).setFloatingButton.apply(_api31, arguments);
+};
+export var setHeight = function setHeight() {
+  var _api32;
+
+  return (_api32 = api).setHeight.apply(_api32, arguments);
+};
+export var setOverlay = function setOverlay() {
+  var _api33;
+
+  return (_api33 = api).setOverlay.apply(_api33, arguments);
+};
+export var setRefreshScrollEnabled = function setRefreshScrollEnabled() {
+  var _api34;
+
+  return (_api34 = api).setRefreshScrollEnabled.apply(_api34, arguments);
+};
+export var setScanQrCode = function setScanQrCode() {
+  var _api35;
+
+  return (_api35 = api).setScanQrCode.apply(_api35, arguments);
+};
+export var setTempDesignSettings = function setTempDesignSettings() {
+  var _api36;
+
+  return (_api36 = api).setTempDesignSettings.apply(_api36, arguments);
+};
+export var setWaitCursor = function setWaitCursor() {
+  var _api37;
+
+  return (_api37 = api).setWaitCursor.apply(_api37, arguments);
+};
+export var storageGetItem = function storageGetItem() {
+  var _api38;
+
+  return (_api38 = api).storageGetItem.apply(_api38, arguments);
+};
+export var storageRemoveItem = function storageRemoveItem() {
+  var _api39;
+
+  return (_api39 = api).storageRemoveItem.apply(_api39, arguments);
+};
+export var storageSetItem = function storageSetItem() {
+  var _api40;
+
+  return (_api40 = api).storageSetItem.apply(_api40, arguments);
+};
+export var vibrate = function vibrate() {
+  var _api41;
+
+  return (_api41 = api).vibrate.apply(_api41, arguments);
+};
+export var useAccessToken = function useAccessToken() {
+  var _api42;
+
+  return (_api42 = api).useAccessToken.apply(_api42, arguments);
+};
+export var useWindowMetrics = function useWindowMetrics() {
+  var _api43;
+
+  return (_api43 = api).useWindowMetrics.apply(_api43, arguments);
+};
+export var useScrollPosition = function useScrollPosition() {
+  var _api44;
+
+  return (_api44 = api).useScrollPosition.apply(_api44, arguments);
+};
+export var useUser = function useUser() {
+  var _api45;
+
+  return (_api45 = api).useUser.apply(_api45, arguments);
+};
+export var useIsAdminMode = function useIsAdminMode() {
+  var _api46;
+
+  return (_api46 = api).useIsAdminMode.apply(_api46, arguments);
+};
+export var useScrollOffsetTop = function useScrollOffsetTop() {
+  var _api47;
+
+  return (_api47 = api).useScrollOffsetTop.apply(_api47, arguments);
+};
+export var useScrollOffsetBottom = function useScrollOffsetBottom() {
+  var _api48;
+
+  return (_api48 = api).useScrollOffsetBottom.apply(_api48, arguments);
+};
+export var useScrollListener = function useScrollListener() {
+  var _api49;
+
+  return (_api49 = api).useScrollListener.apply(_api49, arguments);
+};
+export var useWindowMetricsListener = function useWindowMetricsListener() {
+  var _api50;
+
+  return (_api50 = api).useWindowMetricsListener.apply(_api50, arguments);
+};
+export var useGeoLocationListener = function useGeoLocationListener() {
+  var _api51;
+
+  return (_api51 = api).useGeoLocationListener.apply(_api51, arguments);
+};
+export default ChaynsProvider;

package/dist/esm/components/Title.js

@@ -0,0 +1,210 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+import React, { useEffect, useRef, useState } from 'react';
+import { useContextSelector } from 'use-context-selector';
+import { useUser } from '../hooks/useUser';
+import { useIsAdminMode } from '../hooks/useIsAdminMode';
+import { useScrollOffsetBottom, useScrollOffsetTop, useScrollPosition } from '../hooks/scrollListener';
+import { useWindowMetrics } from '../hooks/windowMetricsListener';
+import { ChaynsContext, ChaynsFunctionsContext } from './ChaynsContext';
+import ChaynsHost from '../host/ChaynsHost';
+// import './title.scss';
+import { addScrollListener, removeScrollListener } from '../index';
+var FirstName = /*#__PURE__*/React.memo(function () {
+  var user = useUser();
+  console.debug('render first name', user);
+  return /*#__PURE__*/React.createElement("div", {
+    className: "firstname"
+  }, "FirstName: ", user === null || user === void 0 ? void 0 : user.firstName);
+});
+
+var Title = function Title() {
+  var _URLSearchParams$get;
+
+  var isAdminModeActive = useIsAdminMode();
+  var ref = useRef(null); // const addScrollListener = useScrollListener();
+  //const { value } = useGeoLocation({ timeout: 1000, enabled: true, silent: true });
+
+  var _useScrollPosition = useScrollPosition({
+    enabled: true,
+    throttle: 100
+  }),
+      scrollY = _useScrollPosition.scrollY; // const addGeoLocationListener = useGeoLocationListener();
+  // const addWindowMetricsListener = useWindowMetricsListener();
+
+
+  var offsetTop = useScrollOffsetTop();
+  var offsetBottom = useScrollOffsetBottom();
+  var values = useContextSelector(ChaynsContext, function (s) {
+    return s;
+  });
+  var functions = useContextSelector(ChaynsFunctionsContext, function (s) {
+    return s;
+  });
+  var login = useContextSelector(ChaynsFunctionsContext, function (s) {
+    return s.login;
+  });
+  var logout = useContextSelector(ChaynsFunctionsContext, function (s) {
+    return s.logout;
+  }); // const [windowMetrics, setWindowMetrics] = useState(null);
+
+  var windowMetrics = useWindowMetrics();
+  console.log('offsetTop', offsetTop, offsetBottom, windowMetrics);
+
+  var _useState = useState(10),
+      _useState2 = _slicedToArray(_useState, 2),
+      testHeight = _useState2[0],
+      setTestHeight = _useState2[1];
+
+  useEffect(function () {
+    var promise = addScrollListener({}, function (r) {
+      return console.log('add scroll', r);
+    });
+    return function () {
+      void (promise === null || promise === void 0 ? void 0 : promise.then(function (id) {
+        console.log('remove scroll', id);
+        return removeScrollListener(id);
+      }));
+    };
+  }, []); // useEffect(() => addScrollListener({ throttle: 200 }, (ev) => {
+  //         console.log('scroll', ev)
+  //         setWindowMetrics(ev.windowMetrics);
+  //     }), [addScrollListener]);
+  //
+  // useEffect(() => addGeoLocationListener({ silent: true }, (ev) => {
+  //         console.log('geo location', ev);
+  //     }), [addGeoLocationListener])
+  //
+  // useEffect(() => addWindowMetricsListener((ev) => {
+  //         console.log('window metrics', ev);
+  //         setWindowMetrics(ev);
+  //     }), [addWindowMetricsListener]);
+  // console.debug('render title', scrollPosition);
+
+  var src = useRef();
+  var depth = global.location ? Number.parseInt((_URLSearchParams$get = new URLSearchParams(window.location.search).get('depth')) !== null && _URLSearchParams$get !== void 0 ? _URLSearchParams$get : '1', 10) : 1;
+
+  if (!src.current) {
+    src.current = "https://w-hn-laptop.tobit.ag:8082?depth=".concat(depth + 1); // src.current = 'https://tapp01.tobit.com/Tapps/Chaynsnet/landingpage_2020/v4/index.html?isWidget=true';
+  }
+
+  var maxDepth = 2;
+  return /*#__PURE__*/React.createElement("div", {
+    className: "chayns-api"
+  }, /*#__PURE__*/React.createElement(FirstName, null), /*#__PURE__*/React.createElement("button", {
+    id: "login-button",
+    type: "button",
+    onClick: function onClick() {
+      return login({
+        ignoreAuthenticated: false
+      }, function () {}, function () {});
+    }
+  }, "Login"), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: logout
+  }, "Logout"), /*#__PURE__*/React.createElement("div", null, "AdminMode active: ", isAdminModeActive ? 'true' : 'false'), depth < maxDepth && /*#__PURE__*/React.createElement(ChaynsHost, _extends({}, values, {
+    iFrameRef: ref,
+    src: src.current,
+    iFrameProps: {
+      name: "CustomPluginIframe".concat(depth),
+      style: {
+        border: 0,
+        width: '100%'
+      },
+      height: 1
+    },
+    functions: _objectSpread(_objectSpread({}, functions), {}, {
+      getWindowMetrics: function () {
+        var _getWindowMetrics = _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+          var v;
+          return regeneratorRuntime.wrap(function _callee$(_context) {
+            while (1) {
+              switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return functions.getWindowMetrics();
+
+                case 2:
+                  v = _context.sent;
+                  return _context.abrupt("return", _objectSpread(_objectSpread({}, v), {}, {
+                    offsetTop: v.offsetTop + (ref.current ? ref.current.getBoundingClientRect().top : 0)
+                  }));
+
+                case 4:
+                case "end":
+                  return _context.stop();
+              }
+            }
+          }, _callee);
+        }));
+
+        function getWindowMetrics() {
+          return _getWindowMetrics.apply(this, arguments);
+        }
+
+        return getWindowMetrics;
+      }(),
+      addWindowMetricsListener: function addWindowMetricsListener(cb) {
+        return functions.addWindowMetricsListener(function (result) {
+          return cb(_objectSpread(_objectSpread({}, result), {}, {
+            offsetTop: result.offsetTop + (ref.current ? ref.current.getBoundingClientRect().top : 0)
+          }));
+        });
+      }
+    }),
+    type: "client-iframe"
+  })), /*#__PURE__*/React.createElement("div", {
+    style: {
+      position: 'absolute',
+      top: offsetTop,
+      color: 'green',
+      backgroundColor: 'white'
+    }
+  }, "456"), /*#__PURE__*/React.createElement("div", {
+    style: {
+      position: 'absolute',
+      top: Math.min(offsetBottom, window.innerHeight) - 25,
+      right: 20,
+      color: 'red',
+      backgroundColor: 'white'
+    }
+  }, "123"), /*#__PURE__*/React.createElement("button", {
+    type: "button",
+    onClick: function onClick() {
+      return setTestHeight(testHeight + 100);
+    }
+  }, "Increase height"), /*#__PURE__*/React.createElement("div", {
+    className: "nice",
+    style: {
+      height: testHeight
+    }
+  }), /*#__PURE__*/React.createElement("button", {
+    onClick: function onClick() {
+      return setTestHeight(Math.max(0, testHeight - 100));
+    }
+  }, "Reduce height"));
+};
+
+export default /*#__PURE__*/React.memo(Title);

package/dist/esm/handler/DialogHandler.js

@@ -0,0 +1,36 @@
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return typeof key === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (typeof input !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (typeof res !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+export default class DialogHandler {
+  constructor(config, open, close) {
+    _defineProperty(this, "isOpen", false);
+    _defineProperty(this, "result", undefined);
+    this._open = open;
+    this._close = close;
+    this._config = config;
+  }
+  async open() {
+    if (this.isOpen) {
+      throw new Error('cannot open a dialog which is already open');
+    }
+    const res = await new Promise(async resolve => {
+      const callback = data => {
+        this.isOpen = false;
+        resolve(data);
+      };
+      this.isOpen = true;
+      this.dialogId = await this._open(this._config, callback);
+    });
+    return this.result = res;
+  }
+  close(buttonType, data) {
+    if (!this.isOpen) {
+      return;
+    }
+    this.isOpen = false;
+    this._close(this.dialogId, data);
+  }
+  getResult() {
+    return this.result;
+  }
+}

package/dist/esm/helper/cssLoader.js

@@ -0,0 +1,21 @@
+export function loadCss() {
+  var apiUrl = 'https://api.chayns.net/css/';
+  var parameters = new URLSearchParams(window.location.search.toLowerCase());
+  document.documentElement.style.visibility = 'hidden';
+  document.documentElement.style.overflow = 'hidden';
+  var head = document.getElementsByTagName('HEAD')[0];
+  var link = document.createElement('link');
+  link.rel = 'stylesheet';
+  link.type = 'text/css';
+  link.href = apiUrl + (parameters.get('siteid') || "");
+
+  link.onload = function () {
+    document.documentElement.style.visibility = 'visible';
+  };
+
+  link.onerror = function () {
+    document.documentElement.style.visibility = 'visible';
+  };
+
+  head.appendChild(link);
+}

package/dist/esm/hooks/geoLocationListener.js

@@ -1,8 +1,8 @@
 import { useContextSelector } from 'use-context-selector';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { ChaynsFunctionsContext } from '../components/ChaynsContext';
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useGeoLocationListener = () => {
   const addListener = useContextSelector(ChaynsFunctionsContext, v => v.addGeoLocationListener);
@@ -17,8 +17,8 @@ export const useGeoLocationListener = () => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 };
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useGeoLocation = function () {
   let {

package/dist/esm/hooks/index.js

@@ -13,4 +13,5 @@ export { useLanguage } from './useLanguage';
 export { useValues } from './useValues';
 export { useFunctions } from './useFunctions';
 export { useCurrentPage } from './useCurrentPage';
-export { useCustomData } from './useCustomData';
+export { useCustomData } from './useCustomData';
+export { useDialogState, useDialogData } from './useDialogState';

package/dist/esm/hooks/scrollListener.js

@@ -2,8 +2,8 @@ import { useContextSelector } from 'use-context-selector';
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { ChaynsFunctionsContext } from '../components/ChaynsContext';
 import { useWindowMetrics } from './windowMetricsListener';
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useScrollListener = () => {
   const addListener = useContextSelector(ChaynsFunctionsContext, v => v.addScrollListener);
@@ -18,8 +18,8 @@ export const useScrollListener = () => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 };
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useScrollPosition = function () {
   let {
@@ -46,8 +46,8 @@ export const useScrollPosition = function () {
   }, [getScrollPosition]);
   return value;
 };
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useScrollOffsetTop = function () {
   let {
@@ -69,8 +69,8 @@ export const useScrollOffsetTop = function () {
   }
   return 0;
 };
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useScrollOffsetBottom = function () {
   let {

package/dist/esm/hooks/useAccessToken.js

@@ -2,8 +2,8 @@ import { useEffect, useState } from "react";
 import { useContextSelector } from "use-context-selector";
 import { ChaynsFunctionsContext } from "../components/ChaynsContext";
 
-/**
- * @category Hooks
+/**
+ * @category Hooks
  */
 export const useAccessToken = accessToken => {
   const [token, setToken] = useState(null);

package/dist/esm/hooks/useAddGeoLocationListener.js

@@ -0,0 +1,18 @@
+import { useContextSelector } from 'use-context-selector';
+import { ChaynsFunctionsContext } from '../components/ChaynsContext';
+import { useCallback } from 'react';
+export var useAddGeoLocationListener = function useAddGeoLocationListener() {
+  var addGeoLocationListener = useContextSelector(ChaynsFunctionsContext, function (v) {
+    return v === null || v === void 0 ? void 0 : v.addGeoLocationListener;
+  });
+  var removeGeoLocationListener = useContextSelector(ChaynsFunctionsContext, function (v) {
+    return v === null || v === void 0 ? void 0 : v.removeGeoLocationListener;
+  });
+  var promise;
+  return useCallback(function (value, callback) {
+    promise = addGeoLocationListener(value, callback);
+    return function () {
+      promise.then(removeGeoLocationListener);
+    };
+  }, []);
+};