@opengeoweb/authentication 19.1.0 → 19.1.1

package/dist/index.esm.js

@@ -0,0 +1,1190 @@
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import axios from 'axios';
+import React, { useRef, useEffect, useState } from 'react';
+import { Navigate, Link } from 'react-router';
+import { sessionStorageProvider, useIsMounted, SHARED_NAMESPACE, AlertBanner, useDebounce } from '@opengeoweb/shared';
+import { useTranslation, Trans } from 'react-i18next';
+import { ThemeWrapper } from '@opengeoweb/theme';
+import 'i18next';
+import { FormControl, FormLabel, RadioGroup, FormControlLabel, Radio } from '@mui/material';
+
+var en$1 = {
+	"api-role-title-user": "User",
+	"api-role-title-preset-admin": "Preset-admin"
+};
+var fi$1 = {
+	"api-role-title-user": "Käyttäjä",
+	"api-role-title-preset-admin": "Preset-pääkäyttäjä"
+};
+var no$1 = {
+	"api-role-title-user": "Bruker",
+	"api-role-title-preset-admin": "Preset-admin"
+};
+var nl$1 = {
+	"api-role-title-user": "Gebruiker",
+	"api-role-title-preset-admin": "Preset-beheerder"
+};
+var apiTranslations = {
+	en: en$1,
+	fi: fi$1,
+	no: no$1,
+	nl: nl$1
+};
+
+var en = {
+	"auth-logout-go-back-to-home-page": "Go back to the <1>Home Page</1>",
+	"auth-logout-you-are-logged-out": "You are logged out.",
+	"auth-role-title": "Role"
+};
+var fi = {
+	"auth-logout-go-back-to-home-page": "Palaa takaisin <1>Kotisivulle</1>",
+	"auth-logout-you-are-logged-out": "Olet kirjautunut ulos.",
+	"auth-role-title": "Rooli"
+};
+var no = {
+	"auth-logout-go-back-to-home-page": "Gå tilbake til <1>Hjemmesiden</1>",
+	"auth-logout-you-are-logged-out": "Du er logget ut",
+	"auth-role-title": "Rolle"
+};
+var nl = {
+	"auth-logout-go-back-to-home-page": "Ga terug naar de <1>Startpagina</1>",
+	"auth-logout-you-are-logged-out": "Je bent uitgelogd.",
+	"auth-role-title": "Rol"
+};
+var authTranslations = {
+	en: en,
+	fi: fi,
+	no: no,
+	nl: nl
+};
+
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(void 0);
+    });
+  };
+}
+function _regenerator() {
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+  var e,
+    t,
+    r = "function" == typeof Symbol ? Symbol : {},
+    n = r.iterator || "@@iterator",
+    o = r.toStringTag || "@@toStringTag";
+  function i(r, n, o, i) {
+    var c = n && n.prototype instanceof Generator ? n : Generator,
+      u = Object.create(c.prototype);
+    return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+      var i,
+        c,
+        u,
+        f = 0,
+        p = o || [],
+        y = false,
+        G = {
+          p: 0,
+          n: 0,
+          v: e,
+          a: d,
+          f: d.bind(e, 4),
+          d: function (t, r) {
+            return i = t, c = 0, u = e, G.n = r, a;
+          }
+        };
+      function d(r, n) {
+        for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+          var o,
+            i = p[t],
+            d = G.p,
+            l = i[2];
+          r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
+        }
+        if (o || r > 1) return a;
+        throw y = true, n;
+      }
+      return function (o, p, l) {
+        if (f > 1) throw TypeError("Generator is already running");
+        for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+          i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+          try {
+            if (f = 2, i) {
+              if (c || (o = "next"), t = i[o]) {
+                if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                if (!t.done) return t;
+                u = t.value, c < 2 && (c = 0);
+              } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+              i = e;
+            } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+          } catch (t) {
+            i = e, c = 1, u = t;
+          } finally {
+            f = 1;
+          }
+        }
+        return {
+          value: t,
+          done: y
+        };
+      };
+    }(r, o, i), true), u;
+  }
+  var a = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  t = Object.getPrototypeOf;
+  var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+      return this;
+    }), t),
+    u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+  function f(e) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
+    return this;
+  }), _regeneratorDefine(u, "toString", function () {
+    return "[object Generator]";
+  }), (_regenerator = function () {
+    return {
+      w: i,
+      m: f
+    };
+  })();
+}
+function _regeneratorDefine(e, r, n, t) {
+  var i = Object.defineProperty;
+  try {
+    i({}, "", {});
+  } catch (e) {
+    i = 0;
+  }
+  _regeneratorDefine = function (e, r, n, t) {
+    function o(r, n) {
+      _regeneratorDefine(e, r, function (e) {
+        return this._invoke(r, n, e);
+      });
+    }
+    r ? i ? i(e, r, {
+      value: n,
+      enumerable: !t,
+      configurable: !t,
+      writable: !t
+    }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+  }, _regeneratorDefine(e, r, n, t);
+}
+
+var DEFAULT_TIMEOUT = 15000;
+var KEEP_ALIVE_POLLER_IN_SECONDS = 60; // Number of seconds between the checks if the token should be refreshed.
+var REFRESH_TOKEN_WHEN_PCT_EXPIRED = 75; // Refresh token when 75% expired. Set to (10 / 3600) * 100 = 0.2777778% to test with 10 second interval (assuming 1 hour token expiration).
+var DEFAULT_TOKEN_EXPIRES_IN = 3600; // Number of seconds a token expires by default
+var MILLISECOND_TO_SECOND = 1 / 1000;
+var GEOWEB_ROLE_PRESETS_ADMIN = {
+  name: 'ROLE_PRESET_ADMIN',
+  title: 'api-role-title-preset-admin'
+};
+var GEOWEB_ROLE_USER = {
+  name: 'ROLE_USER',
+  title: 'api-role-title-user'
+};
+/**
+ * Creates a Credentials object based on the axios response from the token service.
+ *
+ * It will calculate the expires_at attribute based on the expires_in property found in the JWT.
+ *
+ * @param tokenResponse Response of the tokenservice as axios response object.
+ * @returns Credentials object.
+ */
+var makeCredentialsFromTokenResponse = function makeCredentialsFromTokenResponse(tokenResponse, authConfig) {
+  var _tokenResponse$data$b;
+  var token = (_tokenResponse$data$b = tokenResponse.data.body) != null ? _tokenResponse$data$b : tokenResponse.data;
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  var access_token = token.access_token,
+    refresh_token = token.refresh_token,
+    id_token = token.id_token,
+    expires_in = token.expires_in;
+  if (!access_token || !id_token) {
+    // message is not user-facing
+    throw new Error('Login failed');
+  }
+  var userInfoString = atob(
+  // convert base64url specific characters before parsing as base64
+  id_token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/'));
+  var userInfo = JSON.parse(userInfoString);
+  var tokenExpirationInSeconds = expires_in && expires_in > 0 ? expires_in : DEFAULT_TOKEN_EXPIRES_IN; // If not set or zero in the token, assume valid for 1 hour.
+  var pctTokenExpirationInSeconds = tokenExpirationInSeconds * (REFRESH_TOKEN_WHEN_PCT_EXPIRED / 100);
+  var epochTimeTokenExpirationInSeconds = pctTokenExpirationInSeconds + getCurrentTimeInSeconds();
+  var isAuthCognito = userInfo.iss.includes('cognito');
+  var roleClaimName = authConfig == null ? void 0 : authConfig.GW_AUTH_ROLE_CLAIM_NAME;
+  var groups = userInfo[roleClaimName];
+  var newAuth = {
+    username: isAuthCognito ? userInfo['cognito:username'] : userInfo.email,
+    roles: groupsToRoles(groups, authConfig),
+    token: access_token,
+    refresh_token: refresh_token != null ? refresh_token : '',
+    expires_at: epochTimeTokenExpirationInSeconds,
+    has_connection_issue: false
+  };
+  return newAuth;
+};
+var refreshAccessToken = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+    var auth, _ref$config, _ref$config2, authTokenURL, authClientId, appURL, _ref$timeout, timeout, tokenAxiosInstance, refreshPayload, useDefaultContentType, data, axiosConfig;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          auth = _ref.auth, _ref$config = _ref.config, _ref$config2 = _ref$config === void 0 ? {} : _ref$config, authTokenURL = _ref$config2.authTokenURL, authClientId = _ref$config2.authClientId, appURL = _ref$config2.appURL, _ref$timeout = _ref.timeout, timeout = _ref$timeout === void 0 ? DEFAULT_TIMEOUT : _ref$timeout;
+          // Refresh token request with a new axios instance
+          // without request interceptor
+          tokenAxiosInstance = axios.create({
+            headers: {},
+            timeout: timeout
+          });
+          refreshPayload = {
+            refresh_token: auth.refresh_token,
+            redirect_uri: appURL + "/code",
+            grant_type: 'refresh_token',
+            client_id: authClientId
+          };
+          /* Send data in the "application/x-www-form-urlencoded" format.
+            If only JSON is supported, use Axios' default content type ("application/x-www-form-urlencoded"). */
+          useDefaultContentType = authTokenURL.includes('amazonaws.com');
+          data = useDefaultContentType ? refreshPayload : new URLSearchParams(refreshPayload);
+          axiosConfig = {
+            headers: {
+              'Content-Type': useDefaultContentType ? 'application/json' : 'application/x-www-form-urlencoded'
+            }
+          };
+          return _context.a(2, tokenAxiosInstance.post(authTokenURL, data, axiosConfig));
+      }
+    }, _callee);
+  }));
+  return function refreshAccessToken(_x) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+var refreshAccessTokenAndSetAuthContext = /*#__PURE__*/function () {
+  var _ref4 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(_ref3) {
+    var auth, onSetAuth, config, _ref3$timeout, timeout, configURLS, onLogin, refreshedToken, newAuth, _e$response, status, _t;
+    return _regenerator().w(function (_context2) {
+      while (1) switch (_context2.p = _context2.n) {
+        case 0:
+          auth = _ref3.auth, onSetAuth = _ref3.onSetAuth, config = _ref3.config, _ref3$timeout = _ref3.timeout, timeout = _ref3$timeout === void 0 ? DEFAULT_TIMEOUT : _ref3$timeout, configURLS = _ref3.configURLS, onLogin = _ref3.onLogin;
+          _context2.p = 1;
+          _context2.n = 2;
+          return refreshAccessToken({
+            auth: auth,
+            config: config,
+            timeout: timeout
+          });
+        case 2:
+          refreshedToken = _context2.v;
+          newAuth = makeCredentialsFromTokenResponse(refreshedToken, configURLS); // Cognito does not send a new refresh token, but gitlab does. Set it here into the auth context.
+          if (!newAuth.refresh_token || newAuth.refresh_token.length === 0) {
+            newAuth.refresh_token = auth.refresh_token;
+          }
+          // If the prop for the role config is not set, keep the roles of the current auth context.
+          if (!configURLS) {
+            newAuth.roles = auth.roles;
+          }
+          onSetAuth(newAuth);
+          _context2.n = 4;
+          break;
+        case 3:
+          _context2.p = 3;
+          _t = _context2.v;
+          status = (_e$response = _t.response) == null ? void 0 : _e$response.status;
+          if (status === 400) {
+            onLogin(false);
+          } else {
+            onSetAuth(Object.assign({}, auth, {
+              has_connection_issue: true
+            }));
+          }
+        case 4:
+          return _context2.a(2);
+      }
+    }, _callee2, null, [[1, 3]]);
+  }));
+  return function refreshAccessTokenAndSetAuthContext(_x2) {
+    return _ref4.apply(this, arguments);
+  };
+}();
+var createApiInstance = function createApiInstance(_ref5) {
+  var auth = _ref5.auth,
+    _ref5$config = _ref5.config,
+    _ref5$config2 = _ref5$config === void 0 ? {} : _ref5$config,
+    baseURL = _ref5$config2.baseURL,
+    _ref5$timeout = _ref5.timeout,
+    timeout = _ref5$timeout === void 0 ? DEFAULT_TIMEOUT : _ref5$timeout;
+  var axiosInstance = axios.create({
+    baseURL: baseURL,
+    headers: {},
+    timeout: timeout
+  });
+  // Request interceptor for API calls done BEFORE the request is made.
+  axiosInstance.interceptors.request.use(/*#__PURE__*/function () {
+    var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(axiosConfig) {
+      var newConfig;
+      return _regenerator().w(function (_context3) {
+        while (1) switch (_context3.n) {
+          case 0:
+            // Add the access token to the headers of the request.
+            newConfig = Object.assign({}, axiosConfig, {
+              headers: Object.assign({
+                'Content-Type': 'application/json',
+                Authorization: "Bearer " + auth.token,
+                Accept: 'application/json'
+              }, axiosConfig.headers || {})
+            });
+            return _context3.a(2, newConfig);
+        }
+      }, _callee3);
+    }));
+    return function (_x3) {
+      return _ref6.apply(this, arguments);
+    };
+  }(), /*#__PURE__*/function () {
+    var _ref7 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(error) {
+      return _regenerator().w(function (_context4) {
+        while (1) switch (_context4.n) {
+          case 0:
+            _context4.n = 1;
+            return Promise.reject(error);
+          case 1:
+            return _context4.a(2);
+        }
+      }, _callee4);
+    }));
+    return function (_x4) {
+      return _ref7.apply(this, arguments);
+    };
+  }());
+  // Response interceptor for API calls done AFTER the request is made.
+  axiosInstance.interceptors.response.use(function (response) {
+    return response;
+  }, /*#__PURE__*/function () {
+    var _ref8 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee5(error) {
+      var _error$response;
+      var originalRequest, _originalRequest$head;
+      return _regenerator().w(function (_context5) {
+        while (1) switch (_context5.n) {
+          case 0:
+            originalRequest = error.config; // If request fails with 401, retry the request once.
+            if (!((_error$response = error.response) != null && _error$response.status && error.response.status === 401 && !originalRequest.inRetry)) {
+              _context5.n = 1;
+              break;
+            }
+            originalRequest.inRetry = true;
+            // Update the headers of the original request with the token from the current auth context.
+            if ((_originalRequest$head = originalRequest.headers) != null && _originalRequest$head.Authorization) {
+              originalRequest.headers.Authorization = "Bearer " + (auth == null ? void 0 : auth.token);
+            }
+            return _context5.a(2, axiosInstance(originalRequest));
+          case 1:
+            return _context5.a(2, Promise.reject(error));
+        }
+      }, _callee5);
+    }));
+    return function (_x5) {
+      return _ref8.apply(this, arguments);
+    };
+  }());
+  return axiosInstance;
+};
+var createNonAuthApiInstance = function createNonAuthApiInstance(_ref9) {
+  var _ref9$config = _ref9.config,
+    _ref9$config2 = _ref9$config === void 0 ? {} : _ref9$config,
+    baseURL = _ref9$config2.baseURL,
+    _ref9$timeout = _ref9.timeout,
+    timeout = _ref9$timeout === void 0 ? DEFAULT_TIMEOUT : _ref9$timeout;
+  var axiosInstance = axios.create({
+    baseURL: baseURL,
+    headers: {},
+    timeout: timeout
+  });
+  // Request interceptor for API calls
+  axiosInstance.interceptors.request.use(/*#__PURE__*/function () {
+    var _ref0 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee6(config) {
+      var newConfig;
+      return _regenerator().w(function (_context6) {
+        while (1) switch (_context6.n) {
+          case 0:
+            newConfig = Object.assign({}, config, {
+              headers: Object.assign({
+                'Content-Type': 'application/json',
+                Accept: 'application/json'
+              }, config.headers || {})
+            });
+            return _context6.a(2, newConfig);
+        }
+      }, _callee6);
+    }));
+    return function (_x6) {
+      return _ref0.apply(this, arguments);
+    };
+  }(), /*#__PURE__*/function () {
+    var _ref1 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee7(error) {
+      return _regenerator().w(function (_context7) {
+        while (1) switch (_context7.n) {
+          case 0:
+            _context7.n = 1;
+            return Promise.reject(error);
+          case 1:
+            return _context7.a(2);
+        }
+      }, _callee7);
+    }));
+    return function (_x7) {
+      return _ref1.apply(this, arguments);
+    };
+  }());
+  return axiosInstance;
+};
+var fakeApiRequest = /*#__PURE__*/function () {
+  var _ref10 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee8(signal) {
+    return _regenerator().w(function (_context8) {
+      while (1) switch (_context8.n) {
+        case 0:
+          return _context8.a(2, new Promise(function (resolve, reject) {
+            var timer = setTimeout(function () {
+              resolve();
+            }, 300);
+            signal == null || signal.signal.addEventListener('abort', function () {
+              clearTimeout(timer);
+              reject(new Error('canceled'));
+            });
+          }));
+      }
+    }, _callee8);
+  }));
+  return function fakeApiRequest(_x8) {
+    return _ref10.apply(this, arguments);
+  };
+}();
+var createFakeApiInstance = function createFakeApiInstance() {
+  return {
+    get: function () {
+      var _get = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee9(_url, _params) {
+        return _regenerator().w(function (_context9) {
+          while (1) switch (_context9.n) {
+            case 0:
+              return _context9.a(2, fakeApiRequest());
+          }
+        }, _callee9);
+      }));
+      function get(_x9, _x0) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }(),
+    put: function () {
+      var _put = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee0(_url, _params) {
+        return _regenerator().w(function (_context0) {
+          while (1) switch (_context0.n) {
+            case 0:
+              return _context0.a(2, fakeApiRequest());
+          }
+        }, _callee0);
+      }));
+      function put(_x1, _x10) {
+        return _put.apply(this, arguments);
+      }
+      return put;
+    }(),
+    post: function () {
+      var _post = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee1(_url, _params) {
+        return _regenerator().w(function (_context1) {
+          while (1) switch (_context1.n) {
+            case 0:
+              return _context1.a(2, fakeApiRequest());
+          }
+        }, _callee1);
+      }));
+      function post(_x11, _x12) {
+        return _post.apply(this, arguments);
+      }
+      return post;
+    }(),
+    "delete": function () {
+      var _delete2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee10(_url, _params) {
+        return _regenerator().w(function (_context10) {
+          while (1) switch (_context10.n) {
+            case 0:
+              return _context10.a(2, fakeApiRequest());
+          }
+        }, _callee10);
+      }));
+      function _delete(_x13, _x14) {
+        return _delete2.apply(this, arguments);
+      }
+      return _delete;
+    }(),
+    patch: function () {
+      var _patch = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee11(_url, _params, _signal) {
+        return _regenerator().w(function (_context11) {
+          while (1) switch (_context11.n) {
+            case 0:
+              return _context11.a(2, fakeApiRequest(_signal));
+          }
+        }, _callee11);
+      }));
+      function patch(_x15, _x16, _x17) {
+        return _patch.apply(this, arguments);
+      }
+      return patch;
+    }()
+  };
+};
+var getCurrentTimeInSeconds = function getCurrentTimeInSeconds() {
+  return Date.now() * MILLISECOND_TO_SECOND;
+};
+var groupsToRoles = function groupsToRoles(groups, authConfig) {
+  if (!Array.isArray(groups)) {
+    return [GEOWEB_ROLE_USER];
+  }
+  var requiredGroupForPresetsAdmin = authConfig == null ? void 0 : authConfig.GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN;
+  var roles = groups.reduce(function (acc, group) {
+    if (requiredGroupForPresetsAdmin && group === requiredGroupForPresetsAdmin) {
+      acc.push(GEOWEB_ROLE_PRESETS_ADMIN);
+    }
+    return acc;
+  }, [GEOWEB_ROLE_USER]);
+  return roles;
+};
+
+var authConfigKeys = {
+  GW_AUTH_LOGIN_URL: null,
+  GW_AUTH_LOGOUT_URL: null,
+  GW_AUTH_TOKEN_URL: null,
+  GW_APP_URL: null,
+  GW_BE_VERSION_BASE_URL: null,
+  GW_AUTH_CLIENT_ID: null,
+  GW_AUTH_ROLE_CLAIM_NAME: null,
+  GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN: null
+};
+var getRandomString = function getRandomString() {
+  var array = new Uint32Array(8);
+  window.crypto.getRandomValues(array);
+  var randomString = Array.from(array, function (dec) {
+    return dec.toString(16);
+  }).join('');
+  return randomString;
+};
+var getCodeChallenge = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(codeVerifier) {
+    var encoder, data, digest;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.n) {
+        case 0:
+          encoder = new TextEncoder();
+          data = encoder.encode(codeVerifier);
+          _context.n = 1;
+          return crypto.subtle.digest('SHA-256', data);
+        case 1:
+          digest = _context.v;
+          return _context.a(2, btoa(String.fromCharCode.apply(null, new Uint8Array(digest))).replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, ''));
+      }
+    }, _callee);
+  }));
+  return function getCodeChallenge(_x) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var replaceTemplateKeys = function replaceTemplateKeys(url, clientId, appUrl, oauthState, codeChallenge) {
+  return url.replace('{client_id}', clientId).replace('{app_url}', appUrl).replace('{state}', oauthState).replace('{code_challenge}', codeChallenge);
+};
+var getAuthConfig = function getAuthConfig(_configUrls) {
+  var GW_AUTH_LOGIN_URL = _configUrls.GW_AUTH_LOGIN_URL,
+    GW_AUTH_LOGOUT_URL = _configUrls.GW_AUTH_LOGOUT_URL,
+    GW_AUTH_TOKEN_URL = _configUrls.GW_AUTH_TOKEN_URL,
+    GW_APP_URL = _configUrls.GW_APP_URL,
+    GW_BE_VERSION_BASE_URL = _configUrls.GW_BE_VERSION_BASE_URL,
+    GW_AUTH_CLIENT_ID = _configUrls.GW_AUTH_CLIENT_ID,
+    GW_AUTH_ROLE_CLAIM_NAME = _configUrls.GW_AUTH_ROLE_CLAIM_NAME,
+    GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN = _configUrls.GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN;
+  var loginUrl = replaceTemplateKeys(GW_AUTH_LOGIN_URL, GW_AUTH_CLIENT_ID, GW_APP_URL, sessionStorageProvider.getOauthState(), sessionStorageProvider.getOauthCodeChallenge());
+  var logOutUrl = replaceTemplateKeys(GW_AUTH_LOGOUT_URL, GW_AUTH_CLIENT_ID, GW_APP_URL);
+  return {
+    GW_AUTH_LOGIN_URL: loginUrl,
+    GW_AUTH_LOGOUT_URL: logOutUrl,
+    GW_AUTH_TOKEN_URL: GW_AUTH_TOKEN_URL,
+    GW_APP_URL: GW_APP_URL,
+    GW_BE_VERSION_BASE_URL: GW_BE_VERSION_BASE_URL,
+    GW_AUTH_CLIENT_ID: GW_AUTH_CLIENT_ID,
+    GW_AUTH_ROLE_CLAIM_NAME: GW_AUTH_ROLE_CLAIM_NAME,
+    GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN: GW_AUTH_ROLE_CLAIM_VALUE_PRESETS_ADMIN
+  };
+};
+var AuthenticationContext = /*#__PURE__*/React.createContext({
+  isLoggedIn: null,
+  onLogin: null,
+  auth: null,
+  onSetAuth: null,
+  authConfig: null,
+  sessionStorageProvider: null,
+  currentRole: null
+});
+var authChangeListener = null;
+var setAuthChangeListener = function setAuthChangeListener(listener) {
+  authChangeListener = listener;
+};
+var useAuthenticationDefaultProps = function useAuthenticationDefaultProps() {
+  var _auth$roles$, _auth$roles;
+  var _React$useState = React.useState(false),
+    isLoggedIn = _React$useState[0],
+    setIsLoggedIn = _React$useState[1];
+  var _React$useState2 = React.useState(false),
+    hasConnectionIssue = _React$useState2[0],
+    setHasConnectionIssue = _React$useState2[1];
+  var emptyCredentials = {
+    username: '',
+    roles: [],
+    token: '',
+    refresh_token: '',
+    expires_at: 0,
+    has_connection_issue: false
+  };
+  var _React$useState3 = React.useState(Object.assign({}, emptyCredentials)),
+    auth = _React$useState3[0],
+    setAuth = _React$useState3[1];
+  // TODO clean this up.
+  // hotfix revert to ref. There are parts of the state down the tree that rely on ref to work.
+  var authRef = React.useRef(auth).current;
+  var onSetAuth = React.useCallback(function (newAuth) {
+    if (newAuth) {
+      setAuth(function (prevAuth) {
+        return Object.assign({}, prevAuth, newAuth);
+      });
+      Object.assign(authRef, newAuth);
+      if (newAuth.has_connection_issue !== undefined && hasConnectionIssue !== newAuth.has_connection_issue) {
+        setHasConnectionIssue(newAuth.has_connection_issue);
+      }
+    } else {
+      setAuth(Object.assign({}, emptyCredentials));
+      Object.assign(authRef, Object.assign({}, emptyCredentials));
+    }
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [hasConnectionIssue]);
+  var _React$useState4 = React.useState((_auth$roles$ = (_auth$roles = auth.roles) == null ? void 0 : _auth$roles[0]) != null ? _auth$roles$ : GEOWEB_ROLE_USER),
+    currentRole = _React$useState4[0],
+    setCurrentRole = _React$useState4[1];
+  useEffect(function () {
+    authChangeListener == null || authChangeListener(isLoggedIn, auth);
+  }, [isLoggedIn, auth]);
+  return {
+    isLoggedIn: isLoggedIn,
+    onLogin: setIsLoggedIn,
+    auth: isLoggedIn ? authRef : null,
+    onSetAuth: onSetAuth,
+    sessionStorageProvider: sessionStorageProvider,
+    currentRole: currentRole,
+    setCurrentRole: setCurrentRole
+  };
+};
+var AuthenticationProvider = function AuthenticationProvider(_ref2) {
+  var children = _ref2.children,
+    value = _ref2.value,
+    _ref2$configURLS = _ref2.configURLS,
+    configURLS = _ref2$configURLS === void 0 ? authConfigKeys : _ref2$configURLS;
+  var defaultValues = useAuthenticationDefaultProps();
+  var _ref3 = value != null ? value : defaultValues,
+    isLoggedIn = _ref3.isLoggedIn,
+    onLogin = _ref3.onLogin,
+    auth = _ref3.auth,
+    onSetAuth = _ref3.onSetAuth,
+    sessionStorageProvider = _ref3.sessionStorageProvider,
+    currentRole = _ref3.currentRole,
+    setCurrentRole = _ref3.setCurrentRole;
+  var authConfig = configURLS;
+  // Checks the token expiration time regularly and renews it before it expires.
+  var interval = useRef(undefined);
+  React.useEffect(function () {
+    interval.current = setInterval(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+      var currentTime, timeInSecondsLeftBeforeExpiration;
+      return _regenerator().w(function (_context2) {
+        while (1) switch (_context2.n) {
+          case 0:
+            if (!auth) {
+              _context2.n = 1;
+              break;
+            }
+            currentTime = getCurrentTimeInSeconds();
+            timeInSecondsLeftBeforeExpiration = auth.expires_at ? auth.expires_at - currentTime : 0;
+            if (!(timeInSecondsLeftBeforeExpiration < 60)) {
+              _context2.n = 1;
+              break;
+            }
+            _context2.n = 1;
+            return refreshAccessTokenAndSetAuthContext({
+              auth: auth,
+              onSetAuth: onSetAuth,
+              config: {
+                baseURL: '',
+                authTokenURL: configURLS.GW_AUTH_TOKEN_URL,
+                appURL: configURLS.GW_APP_URL,
+                authClientId: configURLS.GW_AUTH_CLIENT_ID
+              },
+              configURLS: configURLS,
+              onLogin: onLogin
+            });
+          case 1:
+            return _context2.a(2);
+        }
+      }, _callee2);
+    })), KEEP_ALIVE_POLLER_IN_SECONDS / MILLISECOND_TO_SECOND);
+    return function () {
+      clearInterval(interval.current);
+    };
+  }, [auth, configURLS.GW_APP_URL, configURLS.GW_AUTH_CLIENT_ID, configURLS.GW_AUTH_TOKEN_URL, onSetAuth, configURLS, onLogin]);
+  var contextValue = React.useMemo(function () {
+    return {
+      isLoggedIn: isLoggedIn,
+      onLogin: onLogin,
+      auth: auth,
+      onSetAuth: onSetAuth,
+      authConfig: authConfig,
+      sessionStorageProvider: sessionStorageProvider,
+      currentRole: currentRole,
+      setCurrentRole: setCurrentRole
+    };
+  }, [isLoggedIn, onLogin, auth, onSetAuth, authConfig, sessionStorageProvider, currentRole, setCurrentRole]);
+  return jsx(AuthenticationContext.Provider, {
+    value: contextValue,
+    children: children
+  });
+};
+var useAuthenticationContext = function useAuthenticationContext() {
+  return React.useContext(AuthenticationContext);
+};
+
+var axiosInstance = axios.create({
+  headers: {}
+});
+var HandleOAuth2Code = function HandleOAuth2Code() {
+  var _useAuthenticationCon = useAuthenticationContext(),
+    onSetAuth = _useAuthenticationCon.onSetAuth,
+    authConfig = _useAuthenticationCon.authConfig,
+    isLoggedIn = _useAuthenticationCon.isLoggedIn,
+    onLogin = _useAuthenticationCon.onLogin,
+    sessionStorageProvider = _useAuthenticationCon.sessionStorageProvider;
+  var _React$useState = React.useState(null),
+    error = _React$useState[0],
+    setError = _React$useState[1];
+  var _useIsMounted = useIsMounted(),
+    isMounted = _useIsMounted.isMounted;
+  var loginInProgress = React.useRef(false);
+  var authenticate = React.useCallback(/*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+    var _Object$fromEntries, code, state, isStateRequired, isPkceRequired, payload, useDefaultContentType, data, config, res, newAuth, _t;
+    return _regenerator().w(function (_context) {
+      while (1) switch (_context.p = _context.n) {
+        case 0:
+          _Object$fromEntries = Object.fromEntries(new URLSearchParams(window.location.search)), code = _Object$fromEntries.code, state = _Object$fromEntries.state;
+          isStateRequired = authConfig.GW_AUTH_LOGIN_URL.includes('&state=');
+          isPkceRequired = authConfig.GW_AUTH_LOGIN_URL.includes('&code_challenge=');
+          if (!isStateRequired) {
+            _context.n = 1;
+            break;
+          }
+          if (!(!state || state !== sessionStorageProvider.getOauthState())) {
+            _context.n = 1;
+            break;
+          }
+          setError(function () {
+            return {
+              message: 'Login failed',
+              stack: !state ? 'Missing state param' : 'State param does not match'
+            };
+          });
+          return _context.a(2);
+        case 1:
+          if (!isPkceRequired) {
+            _context.n = 2;
+            break;
+          }
+          if (!(!code || !sessionStorageProvider.getOauthCodeVerifier())) {
+            _context.n = 2;
+            break;
+          }
+          setError(function () {
+            return {
+              message: 'Login failed',
+              stack: !code ? 'Missing code param' : 'Missing code verifier'
+            };
+          });
+          return _context.a(2);
+        case 2:
+          payload = Object.assign({
+            client_id: authConfig.GW_AUTH_CLIENT_ID,
+            code: code,
+            redirect_uri: authConfig.GW_APP_URL + "/code",
+            grant_type: 'authorization_code'
+          }, isPkceRequired && {
+            code_verifier: sessionStorageProvider.getOauthCodeVerifier()
+          });
+          /* Send data in the "application/x-www-form-urlencoded" format.
+            If only JSON is supported, use Axios' default content type ("application/x-www-form-urlencoded"). */
+          useDefaultContentType = authConfig.GW_AUTH_TOKEN_URL.includes('amazonaws.com');
+          data = useDefaultContentType ? payload : new URLSearchParams(payload);
+          config = {
+            headers: {
+              'content-type': useDefaultContentType ? 'application/json' : 'application/x-www-form-urlencoded'
+            },
+            timeout: 30000
+          };
+          _context.p = 3;
+          _context.n = 4;
+          return axiosInstance.post(authConfig.GW_AUTH_TOKEN_URL, data, config);
+        case 4:
+          res = _context.v;
+          newAuth = makeCredentialsFromTokenResponse(res, authConfig);
+          if (isMounted.current) {
+            onSetAuth(newAuth);
+            onLogin(true);
+            sessionStorageProvider.setHasAuthenticated('true');
+            if (sessionStorageProvider) {
+              sessionStorageProvider.removeOauthState();
+              sessionStorageProvider.removeOauthCodeVerifier();
+              sessionStorageProvider.removeOauthCodeChallenge();
+            }
+          }
+          _context.n = 6;
+          break;
+        case 5:
+          _context.p = 5;
+          _t = _context.v;
+          if (isMounted.current) {
+            if (_t instanceof Error) {
+              setError(function () {
+                var _error$stack;
+                return {
+                  message: _t.message,
+                  stack: (_error$stack = _t.stack) != null ? _error$stack : 'Error in HandleOAuth2Code'
+                };
+              });
+            }
+            if (sessionStorageProvider) {
+              sessionStorageProvider.removeOauthState();
+              sessionStorageProvider.removeOauthCodeVerifier();
+              sessionStorageProvider.removeOauthCodeChallenge();
+              sessionStorageProvider.removeHasAuthenticated();
+            }
+          }
+        case 6:
+          return _context.a(2);
+      }
+    }, _callee, null, [[3, 5]]);
+  })), [authConfig, isMounted, onLogin, onSetAuth, sessionStorageProvider]);
+  React.useEffect(function () {
+    var authenticateWithLock = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.n) {
+            case 0:
+              if (!(!isLoggedIn && !loginInProgress.current)) {
+                _context2.n = 2;
+                break;
+              }
+              loginInProgress.current = true;
+              _context2.n = 1;
+              return authenticate();
+            case 1:
+              loginInProgress.current = false;
+            case 2:
+              return _context2.a(2);
+          }
+        }, _callee2);
+      }));
+      return function authenticateWithLock() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    authenticateWithLock()["catch"](function () {
+      loginInProgress.current = false;
+    });
+  }, [authenticate, isLoggedIn]);
+  return jsxs(Fragment, {
+    children: [error ? jsx(Navigate, {
+      replace: true,
+      state: {
+        error: {
+          message: error.message,
+          stack: error.stack
+        }
+      },
+      to: "/error"
+    }) : null, isLoggedIn ? jsx(Navigate, {
+      replace: true,
+      to: sessionStorageProvider.getCallbackUrl()
+    }) : null]
+  });
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2024 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2024 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var getCurrentUrlLocation = function getCurrentUrlLocation(url, appUrl) {
+  return url ? url.replace(appUrl, '') : '/';
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2021 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2021 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var OAuth2Login = function OAuth2Login() {
+  var _useAuthenticationCon = useAuthenticationContext(),
+    authConfig = _useAuthenticationCon.authConfig;
+  React.useEffect(function () {
+    var callbackUrl = getCurrentUrlLocation(sessionStorageProvider.getCallbackUrl(), authConfig.GW_APP_URL);
+    sessionStorageProvider.setCallbackUrl(callbackUrl);
+    window.location.assign(authConfig.GW_AUTH_LOGIN_URL);
+  });
+  return null;
+};
+
+/* *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * Copyright 2023 - Koninklijk Nederlands Meteorologisch Instituut (KNMI)
+ * Copyright 2023 - Finnish Meteorological Institute (FMI)
+ * Copyright 2024 - The Norwegian Meteorological Institute (MET Norway)
+ * */
+var API_NAMESPACE = 'api';
+var AUTH_NAMESPACE = 'auth';
+var ns = [AUTH_NAMESPACE, API_NAMESPACE, SHARED_NAMESPACE];
+var useAuthenticationTranslation = function useAuthenticationTranslation() {
+  return useTranslation(ns);
+};
+
+var OAuth2Logout = function OAuth2Logout() {
+  var _useAuthenticationCon = useAuthenticationContext(),
+    onSetAuth = _useAuthenticationCon.onSetAuth,
+    authConfig = _useAuthenticationCon.authConfig,
+    isLoggedIn = _useAuthenticationCon.isLoggedIn,
+    onLogin = _useAuthenticationCon.onLogin,
+    sessionStorageProvider = _useAuthenticationCon.sessionStorageProvider;
+  var _React$useState = React.useState(true),
+    showAlert = _React$useState[0],
+    setShowAlert = _React$useState[1];
+  var _useAuthenticationTra = useAuthenticationTranslation(),
+    t = _useAuthenticationTra.t;
+  React.useEffect(function () {
+    if (isLoggedIn) {
+      setShowAlert(false);
+      onSetAuth(null);
+      onLogin(false);
+      sessionStorageProvider.removeHasAuthenticated();
+      window.location.assign(authConfig.GW_AUTH_LOGOUT_URL);
+    }
+  }, [isLoggedIn, onSetAuth, onLogin, sessionStorageProvider, authConfig.GW_AUTH_LOGOUT_URL]);
+  return showAlert ? jsx(ThemeWrapper, {
+    children: jsx(AlertBanner, {
+      info: jsx("p", {
+        children: jsxs(Trans, {
+          i18nKey: "auth-logout-go-back-to-home-page",
+          ns: AUTH_NAMESPACE,
+          children: ["Go back to the ", jsx(Link, {
+            to: "/",
+            children: "Home Page"
+          })]
+        })
+      }),
+      severity: "info",
+      title: t('auth-logout-you-are-logged-out')
+    })
+  }) : null;
+};
+
+var UserMenuRoles = function UserMenuRoles(_ref) {
+  var currentRole = _ref.currentRole,
+    onChangeRole = _ref.onChangeRole,
+    roles = _ref.roles;
+  var _useAuthenticationTra = useAuthenticationTranslation(),
+    t = _useAuthenticationTra.t;
+  var handleChangeRole = function handleChangeRole(event) {
+    var selectedRole = roles == null ? void 0 : roles.find(function (role) {
+      return role.name === event.target.value;
+    });
+    if (selectedRole) {
+      onChangeRole == null || onChangeRole(selectedRole);
+    }
+  };
+  return jsxs(FormControl, {
+    children: [jsx(FormLabel, {
+      component: "legend",
+      sx: {
+        fontSize: 14,
+        fontWeight: 400,
+        color: 'geowebColors.typographyAndIcons.text',
+        opacity: 1
+      },
+      children: t('auth-role-title')
+    }), jsx(RadioGroup, {
+      "aria-labelledby": "user-menu-roles",
+      name: "user-menu-roles",
+      onChange: handleChangeRole,
+      value: currentRole == null ? void 0 : currentRole.name,
+      children: roles == null ? void 0 : roles.map(function (role) {
+        return jsx(FormControlLabel, {
+          control: jsx(Radio, {}),
+          label: t(role.title),
+          value: role.name
+        }, role.name);
+      })
+    })]
+  });
+};
+
+var generateRandomId = function generateRandomId() {
+  return "-" + Math.random().toString(36).substring(2, 11);
+};
+var useApi = function useApi(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+apiCall,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+params, callbacks) {
+  var _useIsMounted = useIsMounted(),
+    isMounted = _useIsMounted.isMounted;
+  // eslint-disable-next-line react/hook-use-state
+  var _useState = useState(generateRandomId()),
+    id = _useState[0];
+  var _useState2 = useState(true),
+    isLoading = _useState2[0],
+    setIsLoading = _useState2[1];
+  var _useState3 = useState(null),
+    error = _useState3[0],
+    setError = _useState3[1];
+  var _useState4 = useState(null),
+    result = _useState4[0],
+    setResult = _useState4[1];
+  var debouncedParams = useDebounce(JSON.stringify(params), 300);
+  // trick so that we don't have to include this in the useEffect dependency array (as it is likely that callbacks changes on every render)
+  var callbacksRef = useRef(undefined);
+  callbacksRef.current = callbacks;
+  var handleError = function handleError(newError) {
+    if (isMounted.current) {
+      if (!axios.isCancel(newError)) {
+        var _callbacksRef$current;
+        (_callbacksRef$current = callbacksRef.current) == null || _callbacksRef$current.onError == null || _callbacksRef$current.onError(newError);
+        setError(newError);
+      }
+    }
+  };
+  var fetchApiData = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_params) {
+      var response, _callbacksRef$current2, data, _t;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.p = _context.n) {
+          case 0:
+            setIsLoading(true);
+            setError(null);
+            _context.p = 1;
+            _context.n = 2;
+            return apiCall(_params, id);
+          case 2:
+            response = _context.v;
+            if (isMounted.current) {
+              data = Array.isArray(response) ? response.map(function (dimension) {
+                return dimension.data;
+              }) : response.data;
+              (_callbacksRef$current2 = callbacksRef.current) == null || _callbacksRef$current2.onSuccess == null || _callbacksRef$current2.onSuccess(data);
+              setResult(data);
+            }
+            _context.n = 4;
+            break;
+          case 3:
+            _context.p = 3;
+            _t = _context.v;
+            if (_t instanceof Error) {
+              handleError(_t);
+            }
+          case 4:
+            _context.p = 4;
+            setIsLoading(false);
+            return _context.f(4);
+          case 5:
+            return _context.a(2);
+        }
+      }, _callee, null, [[1, 3, 4, 5]]);
+    }));
+    return function fetchApiData(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  useEffect(function () {
+    fetchApiData(params)["catch"](function (newError) {
+      handleError(newError);
+    });
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [debouncedParams]);
+  var clearResults = function clearResults() {
+    setIsLoading(true);
+    setResult(null);
+  };
+  return {
+    isLoading: isLoading,
+    error: error,
+    result: result,
+    clearResults: clearResults,
+    fetchApiData: fetchApiData
+  };
+};
+
+export { AUTH_NAMESPACE, AuthenticationContext, AuthenticationProvider, HandleOAuth2Code as Code, GEOWEB_ROLE_PRESETS_ADMIN, GEOWEB_ROLE_USER, KEEP_ALIVE_POLLER_IN_SECONDS, OAuth2Login as Login, OAuth2Logout as Logout, MILLISECOND_TO_SECOND, REFRESH_TOKEN_WHEN_PCT_EXPIRED, UserMenuRoles, apiTranslations, authTranslations, createApiInstance, createFakeApiInstance, createNonAuthApiInstance, fakeApiRequest, getAuthConfig, getCodeChallenge, getCurrentTimeInSeconds, getCurrentUrlLocation, getRandomString, groupsToRoles, makeCredentialsFromTokenResponse, refreshAccessToken, refreshAccessTokenAndSetAuthContext, setAuthChangeListener, useApi, useAuthenticationContext, useAuthenticationDefaultProps };