@entur-partner/app-shell 6.1.6 → 6.1.7

package/dist/app-shell.cjs.development.js

@@ -0,0 +1,815 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var auth0React = require('@auth0/auth0-react');
+var alert = require('@entur/alert');
+var loader = require('@entur/loader');
+var tokens = require('@entur/tokens');
+var typography = require('@entur/typography');
+var common = require('@entur-partner/common');
+var util = require('@entur-partner/util');
+var React = require('react');
+var postHog = require('posthog-js');
+var react = require('posthog-js/react');
+
+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 _construct(t, e, r) {
+  if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
+  var o = [null];
+  o.push.apply(o, e);
+  var p = new (t.bind.apply(t, o))();
+  return r && _setPrototypeOf(p, r.prototype), p;
+}
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+function _getPrototypeOf(t) {
+  return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
+    return t.__proto__ || Object.getPrototypeOf(t);
+  }, _getPrototypeOf(t);
+}
+function _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _isNativeFunction(t) {
+  try {
+    return -1 !== Function.toString.call(t).indexOf("[native code]");
+  } catch (n) {
+    return "function" == typeof t;
+  }
+}
+function _isNativeReflectConstruct() {
+  try {
+    var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+  } catch (t) {}
+  return (_isNativeReflectConstruct = function () {
+    return !!t;
+  })();
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+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 = !1,
+        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 = !0, 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), !0), 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);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _wrapNativeSuper(t) {
+  var r = "function" == typeof Map ? new Map() : void 0;
+  return _wrapNativeSuper = function (t) {
+    if (null === t || !_isNativeFunction(t)) return t;
+    if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
+    if (void 0 !== r) {
+      if (r.has(t)) return r.get(t);
+      r.set(t, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(t, arguments, _getPrototypeOf(this).constructor);
+    }
+    return Wrapper.prototype = Object.create(t.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: !1,
+        writable: !0,
+        configurable: !0
+      }
+    }), _setPrototypeOf(Wrapper, t);
+  }, _wrapNativeSuper(t);
+}
+
+var EnvironmentBanner = function EnvironmentBanner(_ref) {
+  var environment = _ref.environment;
+  return React.createElement("div", {
+    className: "epp-environment-banner",
+    style: {
+      position: "fixed",
+      zIndex: 9999,
+      top: 0,
+      left: 0,
+      right: 0,
+      width: "100vw",
+      height: "16px",
+      backgroundColor: common.getColorForEnvironment(environment)
+    }
+  });
+};
+
+function userLogout(logout) {
+  var _window$location = window.location,
+    protocol = _window$location.protocol,
+    hostname = _window$location.hostname,
+    port = _window$location.port;
+  return logout({
+    logoutParams: {
+      returnTo: protocol + "//" + hostname + ":" + port
+    }
+  });
+}
+var Authenticate = function Authenticate(_ref) {
+  var children = _ref.children,
+    decorateUser = _ref.decorateUser;
+  var _useState = React.useState(undefined),
+    userWithPermission = _useState[0],
+    setUserWithPermission = _useState[1];
+  var _useAuth = auth0React.useAuth0(),
+    user = _useAuth.user,
+    getAccessTokenSilently = _useAuth.getAccessTokenSilently,
+    loginWithRedirect = _useAuth.loginWithRedirect,
+    _logout = _useAuth.logout,
+    isLoading = _useAuth.isLoading,
+    isAuthenticated = _useAuth.isAuthenticated,
+    error = _useAuth.error;
+  React.useEffect(function () {
+    var fetchUserData = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var token, decoratedUser, _t;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return getAccessTokenSilently();
+            case 1:
+              token = _context.v;
+              _context.n = 2;
+              return decorateUser(user, token);
+            case 2:
+              decoratedUser = _context.v;
+              setUserWithPermission(decoratedUser);
+              _context.n = 4;
+              break;
+            case 3:
+              _context.p = 3;
+              _t = _context.v;
+              console.error("Error fetching user data:", _t);
+            case 4:
+              return _context.a(2);
+          }
+        }, _callee, null, [[0, 3]]);
+      }));
+      return function fetchUserData() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    if (isAuthenticated) {
+      fetchUserData();
+    }
+  }, [decorateUser, getAccessTokenSilently, isAuthenticated, user]);
+  if (!isLoading && !isAuthenticated) {
+    loginWithRedirect();
+    return React.createElement(loader.Loader, {
+      style: {
+        marginTop: tokens.space.extraLarge9
+      }
+    }, "Redirecting to login page");
+  }
+  if (isLoading || !userWithPermission) {
+    return React.createElement(loader.Loader, {
+      style: {
+        marginTop: tokens.space.extraLarge9
+      }
+    }, "Authenticating");
+  }
+  if (error) {
+    console.error(error);
+    return React.createElement(alert.BannerAlertBox, {
+      variant: "error",
+      title: "Authentication failed",
+      style: {
+        maxWidth: "600px",
+        margin: "0 auto"
+      }
+    }, React.createElement(typography.Paragraph, null, "Something went wrong while trying to authenticate you. If the problem persists you should contact", " ", React.createElement(typography.Link, {
+      href: "mailto:support@entur.org"
+    }, "support@entur.org"), " to get it resolved."), React.createElement(typography.Paragraph, null, "Authentication failed with: ", React.createElement(typography.CodeText, null, error == null ? void 0 : error.toString())));
+  }
+  util.assertIsDefined(userWithPermission);
+  return React.createElement(React.Fragment, null, children({
+    user: userWithPermission,
+    logout: function logout() {
+      return userLogout(_logout);
+    },
+    getToken: getAccessTokenSilently
+  }));
+};
+var AppShell = function AppShell(_ref3) {
+  var children = _ref3.children,
+    audience = _ref3.audience,
+    domain = _ref3.domain,
+    clientId = _ref3.clientId,
+    decorateUser = _ref3.decorateUser,
+    environment = _ref3.environment;
+  return React.createElement(auth0React.Auth0Provider, {
+    domain: domain,
+    clientId: clientId,
+    authorizationParams: {
+      redirect_uri: window.location.origin,
+      audience: audience
+    }
+  }, React.createElement(Authenticate, {
+    decorateUser: decorateUser
+  }, function (params) {
+    return React.createElement(React.Fragment, null, environment && environment !== common.Environment.Production && React.createElement(EnvironmentBanner, {
+      environment: environment
+    }), children(params));
+  }));
+};
+
+var ORGANISATION_STORAGE_KEY = "EP::activeOrgId";
+var organisationStorage = {
+  get: function get() {
+    return localStorage.getItem(ORGANISATION_STORAGE_KEY);
+  },
+  set: function set(value) {
+    return localStorage.setItem(ORGANISATION_STORAGE_KEY, value);
+  }
+};
+var LANGUAGE_STORAGE_KEY = "EP::locale";
+var languageStorage = {
+  get: function get() {
+    return localStorage.getItem(LANGUAGE_STORAGE_KEY);
+  },
+  set: function set(value) {
+    return localStorage.setItem(LANGUAGE_STORAGE_KEY, value);
+  }
+};
+var UC_UI_STORAGE_KEY = "ucData";
+var ucUiStorage = {
+  get: function get() {
+    return localStorage.getItem(UC_UI_STORAGE_KEY);
+  }
+};
+
+var SERVICE_NAMES = {
+  Usercentrics: "Usercentrics Consent Management Platform",
+  PostHog: "PostHog.com",
+  Sentry: "Sentry"
+};
+
+var DEFAULT_CONSENT_GIVEN = {
+  Usercentrics: {
+    consentGiven: false
+  },
+  PostHog: {
+    consentGiven: false
+  },
+  Sentry: {
+    consentGiven: false
+  }
+};
+var convertUCServicesToConsents = function convertUCServicesToConsents(services) {
+  return services.map(function (service) {
+    var _Object$entries$find, _ref3;
+    var serviceName = (_Object$entries$find = Object.entries(SERVICE_NAMES).find(function (keyValue) {
+      return keyValue[1] === service.name;
+    })) == null ? void 0 : _Object$entries$find[0];
+    // Ensure the service name exists in SERVICE_NAMES
+    util.assertIsDefined(serviceName, "Service name " + service.name + " not found in SERVICE_NAMES");
+    if (typeof service.consent === "boolean") {
+      var _ref;
+      var consentGiven = service.consent;
+      return _ref = {}, _ref[serviceName] = {
+        consentGiven: consentGiven
+      }, _ref;
+    } else if (typeof service.consent === "object" && "given" in service.consent) {
+      var _ref2;
+      var _consentGiven = service.consent.given;
+      return _ref2 = {}, _ref2[serviceName] = {
+        consentGiven: _consentGiven
+      }, _ref2;
+    }
+    return _ref3 = {}, _ref3[serviceName] = {
+      consentGiven: false
+    }, _ref3;
+  }).reduce(
+  // biome-ignore lint/performance/noAccumulatingSpread: Ignore it for now. No changes in code.
+  function (acc, curr) {
+    return _extends({}, acc, curr);
+  }, DEFAULT_CONSENT_GIVEN);
+};
+
+var ConsentContext = /*#__PURE__*/React.createContext(DEFAULT_CONSENT_GIVEN);
+var useConsentManager = function useConsentManager() {
+  var context = React.useContext(ConsentContext);
+  return context;
+};
+var ConsentManagerProvider = function ConsentManagerProvider(_ref) {
+  var children = _ref.children;
+  var _useState = React.useState(DEFAULT_CONSENT_GIVEN),
+    consentManager = _useState[0],
+    setConsentManager = _useState[1];
+  // Initialize consent manager from local storage once
+  React.useEffect(function () {
+    if (typeof window === "undefined") return;
+    var ucData = ucUiStorage.get();
+    if (ucData) {
+      var data = JSON.parse(ucData);
+      var services = convertUCServicesToConsents(Object.values(data.consent.services));
+      setConsentManager(services);
+    }
+  }, []);
+  // Listen for Usercentrics consent events and update consent manager state
+  React.useEffect(function () {
+    var handleConsentEvent = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(event) {
+        var customEvent, services, updatedConsentManager;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              if (!(typeof window === "undefined")) {
+                _context.n = 1;
+                break;
+              }
+              return _context.a(2);
+            case 1:
+              customEvent = event;
+              services = Object.values(customEvent.detail.services);
+              updatedConsentManager = convertUCServicesToConsents(services);
+              setConsentManager(updatedConsentManager);
+            case 2:
+              return _context.a(2);
+          }
+        }, _callee);
+      }));
+      return function handleConsentEvent(_x) {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    window.addEventListener("UC_CONSENT", handleConsentEvent);
+    return function () {
+      return window.removeEventListener("UC_CONSENT", handleConsentEvent);
+    };
+  }, []);
+  return React.createElement(ConsentContext.Provider, {
+    value: consentManager
+  }, children);
+};
+
+var LanguageContext = /*#__PURE__*/React.createContext(undefined);
+var useLanguageState = function useLanguageState(language) {
+  var _useState = React.useState(language),
+    activeLanguage = _useState[0],
+    setLanguage = _useState[1];
+  React.useEffect(function () {
+    languageStorage.set(activeLanguage);
+  }, [activeLanguage]);
+  return [activeLanguage, setLanguage];
+};
+var useLanguage = function useLanguage() {
+  var context = React.useContext(LanguageContext);
+  util.assertIsDefined(context);
+  return context;
+};
+var LanguageProvider = function LanguageProvider(_ref) {
+  var children = _ref.children,
+    language = _ref.language;
+  var _useLanguageState = useLanguageState(language),
+    activeLanguage = _useLanguageState[0],
+    setLanguage = _useLanguageState[1];
+  return React.createElement(LanguageContext.Provider, {
+    value: {
+      language: activeLanguage,
+      setLanguage: setLanguage
+    }
+  }, children);
+};
+
+var MenuContext = /*#__PURE__*/React.createContext({
+  addItems: function addItems() {},
+  getItemsForPath: function getItemsForPath() {
+    return [];
+  },
+  getMFNavigate: function getMFNavigate() {
+    return undefined;
+  },
+  setMFNavigate: function setMFNavigate() {}
+});
+var useMenuGroupItems = function useMenuGroupItems(path) {
+  var context = React.useContext(MenuContext);
+  return context.getItemsForPath(path);
+};
+var useMenu = function useMenu() {
+  return React.useContext(MenuContext);
+};
+var useMFNavigation = function useMFNavigation(path) {
+  var _useMenu = useMenu(),
+    getMFNavigate = _useMenu.getMFNavigate;
+  return getMFNavigate(path);
+};
+var MenuProvider = function MenuProvider(_ref) {
+  var children = _ref.children;
+  var _useState = React.useState({}),
+    groups = _useState[0],
+    setGroups = _useState[1];
+  var _useState2 = React.useState({}),
+    navFuncs = _useState2[0],
+    setNavFuncs = _useState2[1];
+  var addItems = React.useCallback(function (newItems, path) {
+    setGroups(function (prevState) {
+      var _extends2;
+      return _extends({}, prevState, (_extends2 = {}, _extends2[path] = newItems, _extends2));
+    });
+  }, []);
+  var getMFNavigate = function getMFNavigate(path) {
+    return navFuncs[path];
+  };
+  var setMFNavigate = function setMFNavigate(path, navigation) {
+    return setNavFuncs(function (prev) {
+      var _extends3;
+      return _extends({}, prev, (_extends3 = {}, _extends3[path] = navigation, _extends3));
+    });
+  };
+  return React.createElement(MenuContext.Provider, {
+    value: {
+      addItems: addItems,
+      getItemsForPath: function getItemsForPath(path) {
+        var _groups$path;
+        return (_groups$path = groups[path]) != null ? _groups$path : [];
+      },
+      getMFNavigate: getMFNavigate,
+      setMFNavigate: setMFNavigate
+    }
+  }, children);
+};
+
+var _excluded$1 = ["navigate", "children", "onClick", "target"];
+function isModifiedEvent(event) {
+  return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+}
+var MicroFrontendLink = function MicroFrontendLink(_ref) {
+  var navigate = _ref.navigate,
+    children = _ref.children,
+    _onClick = _ref.onClick,
+    target = _ref.target,
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded$1);
+  return (
+    // biome-ignore lint/a11y/noStaticElementInteractions: Ignore lint rule for now. No changes in code.
+    React.createElement("a", _extends({
+      // biome-ignore lint/a11y/useValidAnchor: Ignore lint rule for now. No changes in code.
+      onClick: function onClick(event) {
+        try {
+          if (_onClick) _onClick(event);
+        } catch (ex) {
+          event.preventDefault();
+          throw ex;
+        }
+        if (!event.defaultPrevented &&
+        // onClick prevented default
+        event.button === 0 && (
+        // ignore everything but right clicks
+        !target || target === "_self") &&
+        // let browser handle "target=_blank" etc.
+        !isModifiedEvent(event) // ignore clicks with modifier keys
+        ) {
+          event.preventDefault();
+          navigate();
+        }
+      },
+      target: target
+    }, rest), children)
+  );
+};
+
+var OrganisationContext = /*#__PURE__*/React.createContext(undefined);
+var useOrganisation = function useOrganisation() {
+  var context = React.useContext(OrganisationContext);
+  util.assertIsDefined(context);
+  return context;
+};
+var useOrganisationId = function useOrganisationId() {
+  var context = React.useContext(OrganisationContext);
+  util.assertIsDefined(context);
+  return context.organisationId;
+};
+var useOrganisationState = function useOrganisationState(initialOrganisationId) {
+  var _useState = React.useState(Number(initialOrganisationId)),
+    organisationId = _useState[0],
+    setOrganisationId = _useState[1];
+  React.useEffect(function () {
+    organisationStorage.set(organisationId.toString());
+  }, [organisationId]);
+  return [organisationId, setOrganisationId];
+};
+var OrganisationProvider = function OrganisationProvider(_ref) {
+  var children = _ref.children,
+    organisationId = _ref.organisationId;
+  var _useOrganisationState = useOrganisationState(organisationId),
+    orgId = _useOrganisationState[0],
+    setOrganisationId = _useOrganisationState[1];
+  return React.createElement(OrganisationContext.Provider, {
+    value: {
+      organisationId: orgId,
+      setOrganisationId: setOrganisationId
+    }
+  }, children);
+};
+
+var OrganisationsError = /*#__PURE__*/function (_Error) {
+  function OrganisationsError() {
+    var _this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    _this = _Error.call.apply(_Error, [this].concat(args)) || this;
+    _this.message = "Failed fetching organisations";
+    return _this;
+  }
+  _inheritsLoose(OrganisationsError, _Error);
+  return OrganisationsError;
+}(/*#__PURE__*/_wrapNativeSuper(Error));
+
+var _excluded = ["getToken", "getOrganisations", "selectedOrganisationId", "onChange"];
+var OrganisationSelector = function OrganisationSelector(_ref) {
+  var getToken = _ref.getToken,
+    getOrganisations = _ref.getOrganisations,
+    selectedOrganisationId = _ref.selectedOrganisationId,
+    onChange = _ref.onChange,
+    rest = _objectWithoutPropertiesLoose(_ref, _excluded);
+  var _useState = React.useState([]),
+    organisations = _useState[0],
+    setOrganisations = _useState[1];
+  var _useLanguage = useLanguage(),
+    language = _useLanguage.language;
+  var _useState2 = React.useState("LOADING"),
+    status = _useState2[0],
+    setStatus = _useState2[1];
+  React.useEffect(function () {
+    var fetchOrganisations = /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var token, organisations;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
+            case 0:
+              _context.n = 1;
+              return getToken();
+            case 1:
+              token = _context.v;
+              if (!(typeof getOrganisations === "string")) {
+                _context.n = 3;
+                break;
+              }
+              _context.n = 2;
+              return fetch(getOrganisations, {
+                headers: {
+                  Authorization: "Bearer " + token,
+                  Accept: "application/json"
+                }
+              }).then(function (response) {
+                return response.json();
+              });
+            case 2:
+              organisations = _context.v;
+              _context.n = 5;
+              break;
+            case 3:
+              _context.n = 4;
+              return getOrganisations(token);
+            case 4:
+              organisations = _context.v;
+            case 5:
+              setOrganisations(organisations);
+              setStatus("SUCCESS");
+            case 6:
+              return _context.a(2);
+          }
+        }, _callee);
+      }));
+      return function fetchOrganisations() {
+        return _ref2.apply(this, arguments);
+      };
+    }();
+    fetchOrganisations()["catch"](function (error) {
+      {
+        console.error(error);
+      }
+      setStatus("ERROR");
+    });
+  }, [getOrganisations, getToken]);
+  switch (status) {
+    case "LOADING":
+      return React.createElement("div", {
+        className: "eds-contrast"
+      }, React.createElement(loader.SkeletonRectangle, {
+        style: {
+          height: "2.4rem"
+        }
+      }));
+    case "SUCCESS":
+      return React.createElement(common.OrganisationDropDown, _extends({
+        label: language === "nb" || language === "nb-NO" ? "Organisasjon" : "Organisation",
+        selectedOrganisationId: selectedOrganisationId,
+        organisations: organisations,
+        onChange: onChange
+      }, rest));
+    case "ERROR":
+      throw new OrganisationsError();
+    default:
+      return null;
+  }
+};
+
+var PostHogProviderWrapper = function PostHogProviderWrapper(_ref) {
+  var _ref$debug = _ref.debug,
+    debug = _ref$debug === void 0 ? false : _ref$debug,
+    postHogApiKey = _ref.postHogApiKey,
+    isStandalone = _ref.isStandalone,
+    project = _ref.project,
+    _ref$forceDisablePost = _ref.forceDisablePostHog,
+    forceDisablePostHog = _ref$forceDisablePost === void 0 ? false : _ref$forceDisablePost,
+    children = _ref.children;
+  var consents = useConsentManager();
+  React.useEffect(function () {
+    if (!postHogApiKey || forceDisablePostHog) {
+      return;
+    }
+    if (consents != null && consents.PostHog.consentGiven) {
+      postHog.opt_in_capturing();
+    } else {
+      postHog.opt_out_capturing();
+    }
+  }, [consents.PostHog.consentGiven, forceDisablePostHog, postHogApiKey]);
+  // If no API key is provided or PostHog is forced to be disabled, do not initialize PostHog
+  if (!postHogApiKey || forceDisablePostHog) {
+    if (!forceDisablePostHog) {
+      console.warn("AppShellStandalone Warning: PostHog API key is not provided. PostHog will not be initialized.");
+    } else {
+      console.warn("AppShellStandalone Warning: PostHog tracking is disabled by force. PostHog will not be initialized.");
+    }
+    return React.createElement(React.Fragment, null, children);
+  }
+  postHog.init(postHogApiKey, {
+    debug: debug,
+    api_host: isStandalone ? "https://eu.posthog.com" : "/ingest",
+    ui_host: "https://eu.posthog.com",
+    opt_out_capturing_by_default: true,
+    autocapture: isStandalone
+  }, project);
+  return React.createElement(react.PostHogProvider, {
+    client: postHog
+  }, children);
+};
+
+exports.AppShell = AppShell;
+exports.ConsentManagerProvider = ConsentManagerProvider;
+exports.LanguageProvider = LanguageProvider;
+exports.MenuProvider = MenuProvider;
+exports.MicroFrontendLink = MicroFrontendLink;
+exports.OrganisationProvider = OrganisationProvider;
+exports.OrganisationSelector = OrganisationSelector;
+exports.OrganisationsError = OrganisationsError;
+exports.PostHogProviderWrapper = PostHogProviderWrapper;
+exports.languageStorage = languageStorage;
+exports.organisationStorage = organisationStorage;
+exports.useConsentManager = useConsentManager;
+exports.useLanguage = useLanguage;
+exports.useMFNavigation = useMFNavigation;
+exports.useMenu = useMenu;
+exports.useMenuGroupItems = useMenuGroupItems;
+exports.useOrganisation = useOrganisation;
+exports.useOrganisationId = useOrganisationId;
+//# sourceMappingURL=app-shell.cjs.development.js.map