@luigi-project/client 2.26.1-dev.202601280040 → 2.26.1-dev.202601281416

package/esm/luigi-client.mjs

@@ -0,0 +1,2126 @@
+/**
+ * @private
+ * @abstract
+ */
+class LuigiClientBase {
+  /**
+   * @private
+   */
+  constructor() {
+    this.promises = {};
+  }
+  /**
+   * Returns the promises object
+   * @private
+   */
+  setPromise(name, value) {
+    this.promises[name] = value;
+  }
+  /**
+   * Sets the promises object
+   * @private
+   */
+  getPromise(name) {
+    return this.promises[name];
+  }
+}
+
+/** @private */
+class Helpers {
+  /** @private */
+  constructor() {
+    this.listeners = [];
+    this.origin = '';
+
+    const helperListener = function (evt) {
+      if (!evt.data.msg) {
+        return;
+      }
+      if (evt.data.msg === 'custom') {
+        const message = this.convertCustomMessageInternalToUser(evt.data);
+        this.listeners
+          .filter((listener) => listener.name === message.id)
+          .map((listener) => listener.eventFn(message, listener.listenerId));
+      } else {
+        this.listeners
+          .filter((listener) => listener.name === evt.data.msg)
+          .map((listener) => listener.eventFn(evt, listener.listenerId));
+      }
+    }.bind(this);
+
+    window.addEventListener('message', helperListener);
+  }
+
+  convertCustomMessageInternalToUser(internalMessage) {
+    return internalMessage.data;
+  }
+
+  convertCustomMessageUserToInternal(message) {
+    return {
+      msg: 'custom',
+      data: message
+    };
+  }
+
+  convertStorageMessageToInternal(message) {
+    return {
+      msg: 'storage',
+      data: message
+    };
+  }
+
+  /**
+   * Registers a post message listener
+   * Don't forget to remove the event listener at the end of
+   * your eventFn if you do not need it anymore.
+   * @private
+   * @param {string} name - event name
+   * @param {function} eventFn - callback function
+   * @returns {string} listener id
+   */
+  addEventListener(name, eventFn) {
+    const listenerId = this.getRandomId();
+    this.listeners.push({
+      name,
+      eventFn,
+      listenerId
+    });
+    return listenerId;
+  }
+
+  /**
+   * Removes a post message listener
+   * @private
+   * @param {string} id - listenerId
+   */
+  removeEventListener(id) {
+    const listenerExists = Boolean(this.listeners.find((l) => l.listenerId === id));
+    if (listenerExists) {
+      this.listeners = this.listeners.filter((l) => l.listenerId !== id);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Creates a random Id
+   * @private
+   */
+  getRandomId() {
+    return window.crypto.getRandomValues(new Uint32Array(1))[0];
+  }
+
+  /**
+   * Simple function check.
+   * @private
+   * @param {function} item
+   * @returns {boolean}
+   */
+  isFunction(item) {
+    return typeof item === 'function';
+  }
+
+  /**
+   * Simple object check.
+   * @private
+   * @param {Object} item
+   * @returns {boolean}
+   */
+  isObject(item) {
+    return Object.prototype.toString.call(item) === '[object Object]';
+  }
+
+  getLuigiCoreDomain() {
+    return this.origin;
+  }
+
+  setLuigiCoreDomain(origin) {
+    // protect against "null" string set by at least Chrome browser when file protocol used
+    if (origin && origin !== 'null') {
+      this.origin = origin;
+    }
+  }
+
+  setTargetOrigin(origin) {
+    this.setLuigiCoreDomain(origin);
+  }
+
+  sendPostMessageToLuigiCore(msg) {
+    if (this.origin) {
+      // protect against potential postMessage problems, since origin value may be set incorrectly
+      try {
+        window.parent.postMessage(msg, this.origin);
+      } catch (error) {
+        console.warn('Unable to post message ' + msg + ' to Luigi Core from origin ' + this.origin + ': ' + error);
+      }
+    } else {
+      console.warn(
+        'There is no target origin set. You can specify the target origin by calling LuigiClient.setTargetOrigin("targetorigin") in your micro frontend.'
+      );
+    }
+  }
+
+  /**
+   * Checks if given path contains intent navigation special syntax
+   * @param {string} path - path to be checked
+   */
+  hasIntent(path) {
+    return !!path && path.toLowerCase().includes('#?intent=');
+  }
+
+  deSanitizeParamsMap(paramsMap) {
+    return Object.entries(paramsMap).reduce((sanitizedMap, paramPair) => {
+      sanitizedMap[this.deSanitizeParam(paramPair[0])] = this.deSanitizeParam(paramPair[1]);
+      return sanitizedMap;
+    }, {});
+  }
+
+  deSanitizeParam(param = '') {
+    return String(param)
+      .replaceAll('&lt;', '<')
+      .replaceAll('&gt;', '>')
+      .replaceAll('&quot;', '"')
+      .replaceAll('&#39;', "'")
+      .replaceAll('&sol;', '/');
+  }
+}
+
+const helpers = new Helpers();
+
+var version = "2.26.0";
+
+/**
+ * @summary Use the functions and parameters to define the Lifecycle of listeners, navigation nodes, and Event data.
+ * @augments LuigiClientBase
+ * @name Lifecycle
+ * @class
+ */
+class LifecycleManager extends LuigiClientBase {
+  /** @private */
+  constructor() {
+    super();
+    this.luigiInitialized = false;
+    this.defaultContextKeys = ['context', 'internal', 'nodeParams', 'pathParams', 'searchParams'];
+    this.setCurrentContext(
+      this.defaultContextKeys.reduce(function (acc, key) {
+        acc[key] = {};
+        return acc;
+      }, {})
+    );
+
+    this._onContextUpdatedFns = {};
+    this._onInactiveFns = {};
+    this._onInitFns = {};
+    this.authData = {};
+
+    if (!this._isDeferInitDefined()) {
+      this.luigiClientInit();
+    }
+  }
+
+  /**
+   * Check if the html head element contains the attribute "defer-luigi-init"
+   * @private
+   * @memberof Lifecycle
+   */
+  _isDeferInitDefined() {
+    return window.document.head.hasAttribute('defer-luigi-init');
+  }
+
+  /**
+   * Check if the html head element contains the attribute "disable-tpc-check"
+   * @private
+   * @memberof Lifecycle
+   */
+  _isTpcCheckDisabled() {
+    return (
+      window.document.head.hasAttribute('disable-tpc-check') ||
+      this.currentContext?.internal?.thirdPartyCookieCheck?.disabled
+    );
+  }
+
+  /**
+   * Check if LuigiClient is initialized
+   * @returns {boolean} client initialized state
+   * @since 1.12.0
+   * @memberof Lifecycle
+   * @example
+   * const init = LuigiClient.isLuigiClientInitialized()
+   */
+  isLuigiClientInitialized() {
+    return this.luigiInitialized;
+  }
+
+  /**
+   * Starts the handshake with Luigi Core and thereafter results in initialization of Luigi Client. It is always ran by default when importing the Luigi Client package in your micro frontend. Note that when using `defer-luigi-init` to defer default initialization, you will need to initialize the handshake using this function manually wherever needed.
+   * @since 1.12.0
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.luigiClientInit()
+   */
+  luigiClientInit() {
+    if (this.luigiInitialized) {
+      console.warn('Luigi Client has been already initialized');
+      return;
+    }
+    /**
+     * Save context data every time navigation to a different node happens
+     * @private
+     */
+    const setContext = (rawData) => {
+      for (let index = 0; index < this.defaultContextKeys.length; index++) {
+        let key = this.defaultContextKeys[index];
+        try {
+          if (typeof rawData[key] === 'string') {
+            rawData[key] = JSON.parse(rawData[key]);
+          }
+        } catch (e) {
+          console.info('unable to parse luigi context data for', key, rawData[key], e);
+        }
+      }
+      this.setCurrentContext(rawData);
+    };
+
+    const setAuthData = (eventPayload) => {
+      if (eventPayload) {
+        this.authData = eventPayload;
+      }
+    };
+
+    helpers.addEventListener('luigi.init', (e) => {
+      setContext(e.data);
+      setAuthData(e.data.authData);
+      helpers.setLuigiCoreDomain(e.origin);
+      this.luigiInitialized = true;
+      this._notifyInit(e.origin);
+      this._tpcCheck();
+      helpers.sendPostMessageToLuigiCore({ msg: 'luigi.init.ok' });
+    });
+
+    helpers.addEventListener('luigi-client.inactive-microfrontend', (e) => {
+      this._notifyInactive(e.origin);
+    });
+
+    helpers.addEventListener('luigi.auth.tokenIssued', (e) => {
+      setAuthData(e.data.authData);
+    });
+
+    helpers.addEventListener('luigi.navigate', (e) => {
+      setContext(e.data);
+      if (!this.currentContext.internal.isNavigateBack && !this.currentContext.withoutSync) {
+        const previousHash = window.location.hash;
+        history.replaceState({ luigiInduced: true }, '', e.data.viewUrl);
+        window.dispatchEvent(new PopStateEvent('popstate', { state: 'luiginavigation' }));
+        if (window.location.hash !== previousHash) {
+          window.dispatchEvent(new HashChangeEvent('hashchange'));
+        }
+      }
+      // pass additional data to context to enable micro frontend developer to act on internal routing change
+      if (this.currentContext.withoutSync) {
+        Object.assign(this.currentContext.context, {
+          viewUrl: e.data.viewUrl ? e.data.viewUrl : undefined,
+          pathParams: e.data.pathParams ? e.data.pathParams : undefined
+        });
+      }
+      // execute the context change listener if set by the micro frontend
+      this._notifyUpdate();
+      helpers.sendPostMessageToLuigiCore({ msg: 'luigi.navigate.ok' });
+    });
+
+    /**
+     * Get context once initially
+     * @private
+     */
+    window.parent.postMessage(
+      {
+        msg: 'luigi.get-context',
+        clientVersion: version
+      },
+      '*'
+    );
+  }
+
+  _tpcCheck() {
+    if (this._isTpcCheckDisabled()) {
+      return;
+    }
+
+    let tpc = 'enabled';
+    let cookies = document.cookie;
+    let luigiCookie;
+    if (cookies) {
+      luigiCookie = cookies
+        .split(';')
+        .map((cookie) => cookie.trim())
+        .find((cookie) => cookie === 'luigiCookie=true');
+    }
+    if (luigiCookie === 'luigiCookie=true') {
+      document.cookie = 'luigiCookie=; Max-Age=-99999999; SameSite=None; Secure';
+    }
+    document.cookie = 'luigiCookie=true; SameSite=None; Secure';
+    cookies = document.cookie;
+    if (cookies) {
+      luigiCookie = cookies
+        .split(';')
+        .map((cookie) => cookie.trim())
+        .find((cookie) => cookie === 'luigiCookie=true');
+    }
+    if (luigiCookie === 'luigiCookie=true') {
+      document.cookie = 'luigiCookie=; Max-Age=-99999999; SameSite=None; Secure';
+      window.parent.postMessage({ msg: 'luigi.third-party-cookie', tpc }, '*');
+    } else {
+      tpc = 'disabled';
+      window.parent.postMessage({ msg: 'luigi.third-party-cookie', tpc }, '*');
+      console.warn('Third party cookies are not supported!');
+    }
+  }
+
+  /**
+   * Iterates over an object and executes all top-level functions
+   * with a given payload.
+   * @private
+   * @memberof Lifecycle
+   */
+  _callAllFns(objWithFns, payload, origin) {
+    for (let id in objWithFns) {
+      if (objWithFns.hasOwnProperty(id) && helpers.isFunction(objWithFns[id])) {
+        objWithFns[id](payload, origin);
+      }
+    }
+  }
+
+  /**
+   * Notifies all context init listeners.
+   * @private
+   * @memberof Lifecycle
+   */
+  _notifyInit(origin) {
+    this._callAllFns(this._onInitFns, this.currentContext.context, origin);
+  }
+
+  /**
+   * Notifies all context update listeners.
+   * @private
+   * @memberof Lifecycle
+   */
+  _notifyUpdate() {
+    this._callAllFns(this._onContextUpdatedFns, this.currentContext.context);
+  }
+
+  /**
+   * Notifies all inactive listeners.
+   * @private
+   * @memberof Lifecycle
+   */
+  _notifyInactive() {
+    this._callAllFns(this._onInactiveFns);
+  }
+
+  /**
+   * @private
+   * @memberof Lifecycle
+   */
+  setCurrentContext(value) {
+    this.currentContext = value;
+  }
+
+  /**
+   * Registers a listener called with the context object and the Luigi Core domain as soon as Luigi is instantiated. Defer your application bootstrap if you depend on authentication data coming from Luigi.
+   * @param {Lifecycle~initListenerCallback} initFn - the function that is called once Luigi is initialized, receives current context and origin as parameters
+   * @param {boolean} disableTpcCheck - if set to `true` third party cookie check will be disabled via LuigiClient.
+   * @memberof Lifecycle
+   * @example
+   * const initListenerId = LuigiClient.addInitListener((context) => storeContextToMF(context))
+   */
+  addInitListener(initFn, disableTpcCheck) {
+    const id = helpers.getRandomId();
+    this._onInitFns[id] = initFn;
+    if (disableTpcCheck) {
+      document.head.setAttribute('disable-tpc-check', '');
+    }
+    if (this.luigiInitialized && helpers.isFunction(initFn)) {
+      initFn(this.currentContext.context, helpers.getLuigiCoreDomain());
+    }
+    return id;
+  }
+
+  /**
+   * Callback of the addInitListener <br><br>
+   * Type: [Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)
+   * @callback Lifecycle~initListenerCallback
+   * @kind function
+   * @param {Object} context - current context data
+   * @param {string} origin - Luigi Core URL
+   */
+  /**
+   * Removes an init listener.
+   * @param {string} id - the id that was returned by the `addInitListener` function
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.removeInitListener(initListenerId)
+   */
+  removeInitListener(id) {
+    if (this._onInitFns[id]) {
+      this._onInitFns[id] = undefined;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Registers a listener called with the context object when the URL is changed. For example, you can use this when changing environments in a context switcher in order for the micro frontend to do an API call to the environment picked.
+   * @param {function} contextUpdatedFn - the listener function called each time Luigi context changes
+   * @memberof Lifecycle
+   * @example
+   * const updateListenerId = LuigiClient.addContextUpdateListener((context) => storeContextToMF(context))
+   */
+  addContextUpdateListener(contextUpdatedFn) {
+    const id = helpers.getRandomId();
+    this._onContextUpdatedFns[id] = contextUpdatedFn;
+    if (this.luigiInitialized && helpers.isFunction(contextUpdatedFn)) {
+      contextUpdatedFn(this.currentContext.context);
+    }
+    return id;
+  }
+
+  /**
+   * Removes a context update listener.
+   * @param {string} id - the id that was returned by the `addContextUpdateListener` function
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.removeContextUpdateListener(updateListenerId)
+   */
+  removeContextUpdateListener(id) {
+    if (this._onContextUpdatedFns[id]) {
+      this._onContextUpdatedFns[id] = undefined;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Registers a listener called upon micro frontend inactivity. This happens when a new micro frontend gets shown while keeping the old one cached.
+   * Gets called when:
+   * - navigating with **preserveView**
+   * - navigating from or to a **viewGroup**
+   *
+   * Does not get called when navigating normally, or when `openAsModal` or `openAsSplitView` are used.
+   * Once the micro frontend turns back into active state, the `addContextUpdateListener` receives an updated context.
+   * @param {function} inactiveFn - the listener function called each time a micro frontend turns into an inactive state
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.addInactiveListener(() => mfIsInactive = true)
+   * const inactiveListenerId = LuigiClient.addInactiveListener(() => mfIsInactive = true)
+   */
+  addInactiveListener(inactiveFn) {
+    const id = helpers.getRandomId();
+    this._onInactiveFns[id] = inactiveFn;
+    return id;
+  }
+
+  /**
+   * Removes a listener for inactive micro frontends.
+   * @param {string} id - the id that was returned by the `addInactiveListener` function
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.removeInactiveListener(inactiveListenerId)
+   */
+  removeInactiveListener(id) {
+    if (this._onInactiveFns[id]) {
+      this._onInactiveFns[id] = undefined;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Registers a listener called when the micro frontend receives a custom message.
+   * @param {string} customMessageId - the custom message id
+   * @param {Lifecycle~customMessageListenerCallback} customMessageListener - the function that is called when the micro frontend receives the corresponding event
+   * @memberof Lifecycle
+   * @since 0.6.2
+   * @example
+   * const customMsgId = LuigiClient.addCustomMessageListener('myapp.project-updated', (data) => doSomething(data))
+   */
+  addCustomMessageListener(customMessageId, customMessageListener) {
+    return helpers.addEventListener(customMessageId, (customMessage, listenerId) => {
+      return customMessageListener(customMessage, listenerId);
+    });
+  }
+
+  /**
+   * Callback of the customMessageListener <br><br>
+   * Type: [Function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function)
+   * @callback Lifecycle~customMessageListenerCallback
+   * @kind function
+   * @param {Object} customMessage - custom message object
+   * @param {string} customMessage.id - message id
+   * @param {*} customMessage.MY_DATA_FIELD - any other message data field
+   * @param {string} listenerId - custom message listener id to be used for unsubscription
+   */
+  /**
+   * Removes a custom message listener.
+   * @param {string} id - the id that was returned by the `addInitListener` function
+   * @memberof Lifecycle
+   * @since 0.6.2
+   * @example
+   * LuigiClient.removeCustomMessageListener(customMsgId)
+   */
+  removeCustomMessageListener(id) {
+    return helpers.removeEventListener(id);
+  }
+
+  /**
+   * Returns the currently valid access token.
+   * @returns {string} current access token
+   * @memberof Lifecycle
+   * @example
+   * const accessToken = LuigiClient.getToken()
+   */
+  getToken() {
+    return this.authData.accessToken;
+  }
+
+  /**
+   * Returns the context object. Typically it is not required as the {@link #addContextUpdateListener addContextUpdateListener()} receives the same values.
+   * @returns {Object} current context data
+   * @memberof Lifecycle
+   * @example
+   * const context = LuigiClient.getContext()
+   */
+  getContext() {
+    return this.getEventData();
+  }
+
+  /**
+   * Returns the context object. It is an alias function for getContext().
+   * @returns {Object} current context data
+   * @memberof Lifecycle
+   * @deprecated
+   */
+  getEventData() {
+    return this.currentContext.context;
+  }
+
+  /**
+   * Returns a list of active feature toggles
+   * @returns {Array} a list of feature toggle names
+   * @memberof Lifecycle
+   * @since 1.4.0
+   * @example
+   * const activeFeatureToggleList = LuigiClient.getActiveFeatureToggles()
+   */
+  getActiveFeatureToggles() {
+    return this.currentContext.internal.activeFeatureToggleList ?? [];
+  }
+
+  /**
+   * Sets node parameters in Luigi Core. The parameters will be added to the URL.
+   * @param {Object} params
+   * @param {boolean} keepBrowserHistory
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.addNodeParams({luigi:'rocks'}, true);
+   */
+  addNodeParams(params, keepBrowserHistory = true) {
+    if (params) {
+      helpers.sendPostMessageToLuigiCore({
+        msg: 'luigi.addNodeParams',
+        data: params,
+        keepBrowserHistory
+      });
+    }
+  }
+
+  /**
+   * Returns the node parameters of the active URL.
+   * Node parameters are defined like URL query parameters but with a specific prefix allowing Luigi to pass them to the micro frontend view. The default prefix is **~** and you can use it in the following way: `https://my.luigi.app/home/products?~sort=asc&~page=3`.
+   * <!-- add-attribute:class:warning -->
+   * > **NOTE:** some special characters (`<`, `>`, `"`, `'`, `/`) in node parameters are HTML-encoded.
+   * @param {boolean} shouldDesanitise - defines whether the specially encoded characters should be desanitised
+   * @returns {Object} node parameters, where the object property name is the node parameter name without the prefix, and its value is the value of the node parameter. For example `{sort: 'asc', page: 3}`
+   * @memberof Lifecycle
+   * @example
+   * const nodeParams = LuigiClient.getNodeParams()
+   * const nodeParams = LuigiClient.getNodeParams(true)
+   */
+  getNodeParams(shouldDesanitise = false) {
+    return shouldDesanitise
+      ? helpers.deSanitizeParamsMap(this.currentContext.nodeParams)
+      : this.currentContext.nodeParams;
+  }
+
+  /**
+   * Returns the dynamic path parameters of the active URL.
+   * Path parameters are defined by navigation nodes with a dynamic **pathSegment** value starting with **:**, such as **productId**.
+   * All path parameters in the current navigation path (as defined by the active URL) are returned.
+   * <!-- add-attribute:class:warning -->
+   * > **NOTE:** some special characters (`<`, `>`, `"`, `'`, `/`) in path parameters are HTML-encoded.
+   * @returns {Object} path parameters, where the object property name is the path parameter name without the prefix, and its value is the actual value of the path parameter. For example ` {productId: 1234, ...}`
+   * @memberof Lifecycle
+   * @example
+   * const pathParams = LuigiClient.getPathParams()
+   */
+  getPathParams() {
+    return this.currentContext.pathParams;
+  }
+
+  /**
+   * Read search query parameters which are sent from Luigi Core
+   * @memberof Lifecycle
+   * @returns Core search query parameters
+   * @example
+   * LuigiClient.getCoreSearchParams();
+   */
+  getCoreSearchParams() {
+    return this.currentContext.searchParams || {};
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Sends search query parameters to Luigi Core. The search parameters will be added to the URL if they are first allowed on a node level using {@link navigation-parameters-reference.md#clientpermissionsurlparameters clientPermissions.urlParameters}.
+
+   * @param {Object} searchParams
+   * @param {boolean} keepBrowserHistory
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.addCoreSearchParams({luigi:'rocks'}, false);
+   */
+  addCoreSearchParams(searchParams, keepBrowserHistory = true) {
+    if (searchParams) {
+      helpers.sendPostMessageToLuigiCore({
+        msg: 'luigi.addSearchParams',
+        data: searchParams,
+        keepBrowserHistory
+      });
+    }
+  }
+
+  /**
+   * Returns the current client permissions as specified in the navigation node or an empty object. For details, see [Node parameters](navigation-parameters-reference.md).
+   * @returns {Object} client permissions as specified in the navigation node
+   * @memberof Lifecycle
+   * @example
+   * const permissions = LuigiClient.getClientPermissions()
+   */
+  getClientPermissions() {
+    return this.currentContext.internal.clientPermissions || {};
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * When the micro frontend is not embedded in the Luigi Core application and there is no init handshake you can set the target origin that is used in postMessage function calls by Luigi Client. Typically used only in custom micro-frontend frameworks that are compatible with LuigiClient API.
+   * @param {string} origin - target origin
+   * @memberof Lifecycle
+   * @since 0.7.3
+   * @example
+   * LuigiClient.setTargetOrigin(window.location.origin)
+   */
+  setTargetOrigin(origin) {
+    helpers.setTargetOrigin(origin);
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Sends a custom message to the Luigi Core application.
+   * @param {Object} message - an object containing data to be sent to the Luigi Core to process it further. This object is set as an input parameter of the custom message listener on the Luigi Core side
+   * @param {string} message.id - a string containing the message id
+   * @param {*} message.MY_DATA_FIELD - any other message data field
+   * @example
+   * LuigiClient.sendCustomMessage({id: 'environment.created', production: false})
+   * LuigiClient.sendCustomMessage({id: 'environment.created', data: environmentDataObj})
+   * @memberof Lifecycle
+   * @since 0.6.2
+   */
+  sendCustomMessage(message) {
+    const customMessageInternal = helpers.convertCustomMessageUserToInternal(message);
+    helpers.sendPostMessageToLuigiCore(customMessageInternal);
+  }
+
+  /**
+   * Returns the current user settings based on the selected node.
+   * @returns {Object} current user settings
+   * @since 1.7.1
+   * @memberof Lifecycle
+   * @example
+   * const userSettings = LuigiClient.getUserSettings()
+   */
+  getUserSettings() {
+    return this.currentContext.internal.userSettings;
+  }
+
+  /**
+   * Returns the current anchor based on active URL.
+   * @memberof Lifecycle
+   * @since 1.21.0
+   * @returns anchor of URL
+   * @example
+   * LuigiClient.getAnchor();
+   */
+  getAnchor() {
+    return this.currentContext.internal.anchor || '';
+  }
+
+  /**
+   * Sends anchor to Luigi Core. The anchor will be added to the URL.
+   * @param {string} anchor
+   * @since 1.21.0
+   * @memberof Lifecycle
+   * @example
+   * LuigiClient.setAnchor('luigi');
+   */
+  setAnchor(anchor) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.setAnchor',
+      anchor
+    });
+  }
+
+  /**
+   * This function allows you to change node labels within the same {@link navigation-advanced.md#view-groups view group}, e.g. in your node config: `label: 'my Node {viewGroupData.vg1}'`.
+   * @since 2.2.0
+   * @param {Object} data - a data object containing the view group name and desired label
+   * @memberof Lifecycle
+   * @example LuigiClient.setViewGroupData({'vg1':' Luigi rocks!'})
+   */
+  setViewGroupData(data) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.setVGData',
+      data
+    });
+  }
+}
+const lifecycleManager$1 = new LifecycleManager();
+
+/**
+ * @summary Split view allows to open a micro frontend in a split screen in the lower part of the content area. Open it by calling `const splitViewHandle = LuigiClient.linkManager().openAsSplitView`. At a given time, you can open only one split view. It closes automatically when you navigate to a different route. When you call `handle.collapse()`, the split view gets destroyed. It recreates when you use `handle.expand()`. `openAsSplitView` returns an instance of the split view handle. The functions, actions, and event handlers listed below allow you to control and manage the split view.
+ * @augments LuigiClientBase
+ * @name splitView
+ * @since 0.6.0
+ * @class
+ */
+class splitViewHandle extends LuigiClientBase {
+  /**
+   * @private
+   */
+  constructor(settings) {
+    super();
+
+    this.validSplitViewEvents = ['expand', 'collapse', 'resize', 'close'];
+
+    this.splitView = {
+      exists: true,
+      size: 40,
+      collapsed: false
+    };
+
+    Object.assign(this.splitView, settings);
+
+    const removeSplitViewListeners = () => {
+      this.splitView.listeners.forEach((id) => helpers.removeEventListener(id));
+    };
+
+    this.splitView.listeners = [
+      helpers.addEventListener(`luigi.navigation.splitview.internal`, (e) => {
+        Object.assign(this.splitView, e.data.data);
+      })
+    ];
+    this.on('resize', (newSize) => {
+      this.splitView.size = newSize;
+    });
+    this.on('close', removeSplitViewListeners);
+  }
+  /*
+   * @private
+   */
+  sendSplitViewEvent(action, data) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: `luigi.navigation.splitview.${action}`,
+      data
+    });
+  }
+
+  /**
+   * Collapses the split view
+   * @memberof splitView
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.collapse();
+   */
+  collapse() {
+    this.sendSplitViewEvent('collapse');
+  }
+  /**
+   * Expands the split view
+   * @memberof splitView
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.expand();
+   */
+  expand() {
+    this.sendSplitViewEvent('expand');
+  }
+
+  /**
+   * Closes and destroys the split view
+   * @memberof splitView
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.close();
+   */
+  close() {
+    this.sendSplitViewEvent('close');
+  }
+  /**
+   * Sets the height of the split view
+   * @memberof splitView
+   * @param {number} value - lower height in percent
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.setSize(60);
+   */
+  setSize(value) {
+    this.sendSplitViewEvent('resize', value);
+  }
+  /**
+   * Registers a listener for split view events
+   * @memberof splitView
+   * @param {('expand'|'collapse'|'resize'|'close')} name - event name
+   * @param {function} callback - gets called when this event gets triggered by Luigi
+   * @returns {string} listener id
+   * @since 0.6.0
+   * @example
+   * const listenerId = splitViewHandle.on('expand', () => {});
+   * const listenerId = splitViewHandle.on('collapse', () => {});
+   * const listenerId = splitViewHandle.on('resize', () => {});
+   * const listenerId = splitViewHandle.on('close', () => {});
+   **/
+  on(name, callback) {
+    if (!this.validSplitViewEvents.includes(name)) {
+      console.warn(name + ' is not a valid split view event');
+      return false;
+    }
+    const id = helpers.addEventListener(`luigi.navigation.splitview.${name}.ok`, (e) => {
+      const filterParam = typeof e.data.data == 'number' ? e.data.data : undefined;
+      callback(filterParam);
+    });
+    this.splitView.listeners.push(id);
+    return id;
+  }
+  /**
+   * Unregisters a split view listener
+   * @memberof splitView
+   * @param {string} id - listener id
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.removeEventListener(listenerId);
+   */
+  removeEventListener(id) {
+    return helpers.removeEventListener(id);
+  }
+
+  /**
+   * Gets the split view status
+   * @memberof splitView
+   * @returns {boolean} true if a split view is loaded
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.exists();
+   */
+  exists() {
+    return this.splitView.exists;
+  }
+  /**
+   * Reads the size of the split view
+   * @memberof splitView
+   * @returns {number} height in percent
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.getSize();
+   */
+  getSize() {
+    return this.splitView.size;
+  }
+  /**
+   * Reads the collapse status
+   * @memberof splitView
+   * @returns {boolean} true if the split view is currently collapsed
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.isCollapsed();
+   */
+  isCollapsed() {
+    return this.splitView.collapsed;
+  }
+  /**
+   * Reads the expand status
+   * @memberof splitView
+   * @returns {boolean} true if the split view is currently expanded
+   * @since 0.6.0
+   * @example
+   * splitViewHandle.isExpanded();
+   */
+  isExpanded() {
+    return !this.splitView.collapsed;
+  }
+}
+
+/**
+ * @summary The Link Manager allows you to navigate to another route. Use it instead of an internal router to:
+  - Provide routing inside micro frontends.
+  - Reflect the route.
+  - Keep the navigation state in Luigi.
+  * @augments LuigiClientBase
+  * @name linkManager
+  * @class
+  */
+let linkManager$1 = class linkManager extends LuigiClientBase {
+  /**
+   * @private
+   */
+  constructor(values) {
+    super();
+    Object.assign(this, values);
+
+    this.options = {
+      preserveView: false,
+      nodeParams: {},
+      errorSkipNavigation: false,
+      fromContext: null,
+      fromClosestContext: false,
+      fromVirtualTreeRoot: false,
+      fromParent: false,
+      relative: false,
+      link: '',
+      newTab: false,
+      preserveQueryParams: false,
+      anchor: '',
+      preventContextUpdate: false,
+      preventHistoryEntry: false
+    };
+  }
+
+  /**
+   * Navigates to the given path in the application hosted by Luigi. It contains either a full absolute path or a relative path without a leading slash that uses the active route as a base. This is the standard navigation.
+   * @memberof linkManager
+   * @param {string} path - path to be navigated to
+   * @param {string} sessionId - current Luigi **sessionId**
+   * @param {boolean} preserveView - preserve a view by setting it to `true`. It keeps the current view opened in the background and opens the new route in a new frame. Use the {@link #goBack goBack()} function to navigate back. You can use this feature across different levels. Preserved views are discarded as soon as you use the standard {@link #navigate navigate()} function instead of {@link #goBack goBack()}
+   * @param {Object} modalSettings - opens a view in a modal. Use these settings to configure the modal's title and size
+   * @param {string} modalSettings.title - modal title. By default, it is the node label. If there is no label, it is left empty
+   * @param {('fullscreen'|'l'|'m'|'s')} [modalSettings.size="l"] - size of the modal
+   * @param {string} modalSettings.width - updates the `width` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'.
+   * @param {string} modalSettings.height - updates the `height` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'.
+   * @param {boolean} modalSettings.keepPrevious - lets you open multiple modals. Keeps the previously opened modal and allows to open another modal on top of the previous one. By default the previous modals are discarded.
+   * @param {string} modalSettings.closebtn_data_testid - lets you specify a `data_testid` for the close button. Default value is `lui-modal-index-0`. If multiple modals are opened the index will be increased per modal.
+   * @param {Object} splitViewSettings - opens a view in a split view. Use these settings to configure the split view's behaviour
+   * @param {string} splitViewSettings.title - split view title. By default, it is the node label. If there is no label, it is left empty
+   * @param {number} [splitViewSettings.size=40] - height of the split view in percent
+   * @param {boolean} [splitViewSettings.collapsed=false] - creates split view but leaves it closed initially
+   * @param {Object} drawerSettings - opens a view in a drawer. Use these settings to configure if the drawer has a header, backdrop and size
+   * @param {any} drawerSettings.header - by default, the header is visible. The default title is the node label, but the header could also be an object with a `title` attribute allowing you to specify your own title.  An 'x' icon is displayed to close the drawer view
+   * @param {boolean} drawerSettings.backdrop - by default, it is set to `false`. If it is set to `true` the rest of the screen has a backdrop
+   * @param {('l'|'m'|'s'|'xs')} [drawerSettings.size="s"] - size of the drawer
+   * @example
+   * LuigiClient.linkManager().navigate('/overview')
+   * LuigiClient.linkManager().navigate('users/groups/stakeholders')
+   * LuigiClient.linkManager().navigate('/settings', null, true) // preserve view
+   * LuigiClient.linkManager().navigate('#?Intent=Sales-order?id=13') // intent navigation
+   */
+  navigate(path, sessionId, preserveView, modalSettings, splitViewSettings, drawerSettings) {
+    if (this.options.errorSkipNavigation) {
+      this.options.errorSkipNavigation = false;
+      return;
+    }
+    if (modalSettings && splitViewSettings && drawerSettings) {
+      console.warn(
+        'modalSettings, splitViewSettings and drawerSettings cannot be used together. Only modal setting will be taken into account.'
+      );
+    }
+
+    this.options.preserveView = preserveView;
+    const relativePath = path[0] !== '/';
+
+    if (path === '/' && (modalSettings || splitViewSettings || drawerSettings)) {
+      console.warn('Navigation with an absolute path prevented.');
+      return;
+    }
+    const navigationOpenMsg = {
+      msg: 'luigi.navigation.open',
+      sessionId: sessionId,
+      params: Object.assign(this.options, {
+        link: path,
+        relative: relativePath,
+        intent: helpers.hasIntent(path),
+        modal: modalSettings,
+        splitView: splitViewSettings,
+        drawer: drawerSettings
+      })
+    };
+    helpers.sendPostMessageToLuigiCore(navigationOpenMsg);
+  }
+
+  /**
+   * Updates path of the modalPathParam when internal navigation occurs.
+   * @memberof linkManager
+   * @param {string} path
+   * @param {boolean} addHistoryEntry - adds an entry in the history
+   * @param {Object} [modalSettings] - opens a view in a modal. Use these settings to configure the modal's title and size
+   * @since 1.21.0
+   * @example
+   * LuigiClient.linkManager().updateModalPathInternalNavigation('microfrontend')
+   */
+  updateModalPathInternalNavigation(path, modalSettings = {}, addHistoryEntry = false) {
+    if (!path) {
+      console.warn('Updating path of the modal upon internal navigation prevented. No path specified.');
+      return;
+    }
+
+    const navigationOpenMsg = {
+      msg: 'luigi.navigation.updateModalDataPath',
+      params: Object.assign(this.options, {
+        link: path,
+        modal: modalSettings,
+        history: addHistoryEntry
+      })
+    };
+    helpers.sendPostMessageToLuigiCore(navigationOpenMsg);
+  }
+
+  /**
+   * Offers an alternative way of navigating with intents. This involves specifying a semanticSlug and an object containing
+   * parameters.
+   * This method internally generates a URL of the form `#?intent=<semantic object>-<action>?<param_name>=<param_value>` through the given
+   * input arguments. This then follows a call to the original `linkManager.navigate(...)` function.
+   * Consequently, the following calls shall have the exact same effect:
+   * - linkManager().navigateToIntent('Sales-settings', {project: 'pr2', user: 'john'})
+   * - linkManager().navigate('/#?intent=Sales-settings?project=pr2&user=john')
+   * @param {string} semanticSlug - concatenation of semantic object and action connected with a dash (-), i.e.: `<semanticObject>-<action>`
+   * @param {Object} params - an object representing all the parameters passed, i.e.: `{param1: '1', param2: 2, param3: 'value3'}`
+   * @example
+   * LuigiClient.linkManager().navigateToIntent('Sales-settings', {project: 'pr2', user: 'john'})
+   * LuigiClient.linkManager().navigateToIntent('Sales-settings')
+   */
+  navigateToIntent(semanticSlug, params = {}) {
+    let newPath = '#?intent=';
+    newPath += semanticSlug;
+    if (params && Object.keys(params)?.length) {
+      const paramList = Object.entries(params);
+      // append parameters to the path if any
+      if (paramList.length > 0) {
+        newPath += '?';
+        for (const [key, value] of paramList) {
+          newPath += key + '=' + value + '&';
+        }
+        // trim potential excessive ampersand & at the end
+        newPath = newPath.slice(0, -1);
+      }
+    }
+    this.navigate(newPath);
+  }
+
+  /**
+   * Opens a view in a modal. You can specify the modal's title and size. If you don't specify the title, it is the node label. If there is no node label, the title remains empty.  The default size of the modal is `l`, which means 80%. You can also use `m` (60%) and `s` (40%) to set the modal size. Optionally, use it in combination with any of the navigation functions.
+   * @memberof linkManager
+   * @param {string} path - navigation path
+   * @param {Object} [modalSettings] - opens a view in a modal. Use these settings to configure the modal's title and size
+   * @param {string} modalSettings.title - modal title. By default, it is the node label. If there is no label, it is left empty
+   * @param {('fullscreen'|'l'|'m'|'s')} [modalSettings.size="l"] - size of the modal
+   * @param {string} modalSettings.width - updates the `width` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'
+   * @param {string} modalSettings.height - updates the `height` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'
+   * @param {boolean} modalSettings.keepPrevious - lets you open multiple modals. Keeps the previously opened modal and allows to open another modal on top of the previous one. By default the previous modals are discarded
+   * @param {string} modalSettings.closebtn_data_testid - lets you specify a `data_testid` for the close button. Default value is `lui-modal-index-0`. If multiple modals are opened the index will be increased per modal
+   * @returns {promise} which is resolved when closing the modal. By using LuigiClient.linkManager().goBack({ foo: 'bar' }) to close the modal you have access to the `goBackContext` when the promise will be resolved.
+   * @example
+   * LuigiClient.linkManager().openAsModal('projects/pr1/users', {title:'Users', size:'m'}).then((res) => {
+   *     // Logic to execute when the modal will be closed
+   *     console.log(res.data) //=> {foo: 'bar'}
+   *  });
+   */
+  openAsModal(path, modalSettings = {}) {
+    helpers.addEventListener('luigi.navigation.modal.close', (e, listenerId) => {
+      const promise = this.getPromise('modal');
+      if (promise) {
+        promise.resolveFn({ ...e.data, goBackValue: e.data?.data });
+        this.setPromise('modal', undefined);
+      }
+      helpers.removeEventListener(listenerId);
+    });
+    const modalPromise = {};
+    modalPromise.promise = new Promise((resolve, reject) => {
+      modalPromise.resolveFn = resolve;
+      modalPromise.rejectFn = reject;
+    });
+    this.setPromise('modal', modalPromise);
+    this.navigate(path, 0, true, modalSettings);
+    return modalPromise.promise;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Updates the current title and size of a modal. If `routing.showModalPathInUrl` is set to `true`, the URL will be updated with the modal settings data.
+   * In addition, you can specify if a new history entry will be created with the updated URL.
+   * @memberof linkManager
+   * @param {Object} updatedModalSettings - possibility to update the active modal
+   * @param {Object} updatedModalSettings.title - update the `title` of the active modal
+   * @param {Object} updatedModalSettings.size - update the `size` of the active modal
+   * @param {string} updatedModalSettings.width - updates the `width` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'
+   * @param {string} updatedModalSettings.height - updates the `height` of the modal. Allowed units are 'px', '%', 'rem', 'em', 'vh' and 'vw'
+   * @param {boolean} addHistoryEntry - adds an entry in the history, by default it's `false`.
+   * @example
+   * LuigiClient.linkManager().updateModalSettings({title:'LuigiModal', size:'l'});
+   */
+  updateModalSettings(updatedModalSettings = {}, addHistoryEntry = false) {
+    const message = {
+      msg: 'luigi.navigation.updateModalSettings',
+      updatedModalSettings,
+      addHistoryEntry
+    };
+    helpers.sendPostMessageToLuigiCore(message);
+  }
+
+  /**
+   * Opens a view in a split view. You can specify the split view's title and size. If you don't specify the title, it is the node label. If there is no node label, the title remains empty. The default size of the split view is `40`, which means 40% height of the split view.
+   * @memberof linkManager
+   * @param {string} path - navigation path
+   * @param {Object} splitViewSettings - opens a view in a split view. Use these settings to configure the split view's behaviour
+   * @param {string} splitViewSettings.title - split view title. By default, it is the node label. If there is no label, it is left empty
+   * @param {number} [splitViewSettings.size=40] - height of the split view in percent
+   * @param {boolean} [splitViewSettings.collapsed=false] - opens split view in collapsed state
+   * @returns {Object} instance of the SplitView. It provides Event listeners and you can use the available functions to control its behavior.
+   * @see {@link splitView} for further documentation about the returned instance
+   * @since 0.6.0
+   * @example
+   * const splitViewHandle = LuigiClient.linkManager().openAsSplitView('projects/pr1/logs', {title: 'Logs', size: 40, collapsed: true});
+   */
+  openAsSplitView(path, splitViewSettings = {}) {
+    this.navigate(path, 0, true, undefined, splitViewSettings);
+    return new splitViewHandle(splitViewSettings);
+  }
+
+  /**
+   * Opens a view in a drawer. You can specify the size of the drawer, whether the drawer has a header, and whether a backdrop is active in the background. By default, the header is shown. The backdrop is not visible and has to be activated. The size of the drawer is set to `s` by default, which means 25% of the micro frontend size. You can also use `l`(75%), `m`(50%) or `xs`(15.5%). Optionally, use it in combination with any of the navigation functions.
+   * @memberof linkManager
+   * @param {string} path - navigation path
+   * @param {Object} drawerSettings - opens a view in a drawer. Use these settings to configure if the drawer has a header, backdrop and size.
+   * @param {any} drawerSettings.header - by default, the header is visible. The default title is the node label, but the header could also be an object with a `title` attribute allowing you to specify your own title.  An 'x' icon is displayed to close the drawer view.
+   * @param {boolean} drawerSettings.backdrop - by default, it is set to `false`. If it is set to `true` the rest of the screen has a backdrop.
+   * @param {('l'|'m'|'s'|'xs')} [drawerSettings.size="s"] - size of the drawer
+   * @param {boolean} [drawerSettings.overlap=true] - enable resizing of main microfrontend iFrame after drawer open
+   * @since 1.6.0
+   * @example
+   * LuigiClient.linkManager().openAsDrawer('projects/pr1/drawer', {header:true, backdrop:true, size:'s'});
+   * LuigiClient.linkManager().openAsDrawer('projects/pr1/drawer', {header:{title:'My drawer component'}, backdrop:true, size:'xs'});
+   */
+  openAsDrawer(path, drawerSettings = {}) {
+    this.navigate(path, 0, true, undefined, undefined, drawerSettings);
+  }
+
+  /**
+   * Sets the current navigation context to that of a specific parent node which has the {@link navigation-configuration.md navigationContext} field declared in the navigation configuration. This navigation context is then used by the `navigate` function.
+   * @memberof linkManager
+   * @param {string} navigationContext
+   * @returns {linkManager} link manager instance
+   * @example
+   * LuigiClient.linkManager().fromContext('project').navigate('/settings')
+   */
+  fromContext(navigationContext) {
+    const navigationContextInParent =
+      this.currentContext.context.parentNavigationContexts &&
+      this.currentContext.context.parentNavigationContexts.indexOf(navigationContext) !== -1;
+    if (navigationContextInParent) {
+      this.options.fromContext = navigationContext;
+    } else {
+      this.options.errorSkipNavigation = true;
+      console.error('Navigation not possible, navigationContext ' + navigationContext + ' not found.');
+    }
+    return this;
+  }
+
+  /**
+   * Sets the current navigation context which is then used by the `navigate` function. This has to be a parent navigation context, it is not possible to use the child navigation contexts.
+   * @memberof linkManager
+   * @returns {linkManager} link manager instance
+   * @example
+   * LuigiClient.linkManager().fromClosestContext().navigate('/users/groups/stakeholders')
+   */
+  fromClosestContext() {
+    const hasParentNavigationContext = this.currentContext?.context.parentNavigationContexts.length > 0;
+    if (hasParentNavigationContext) {
+      this.options.fromContext = null;
+      this.options.fromClosestContext = true;
+    } else {
+      console.error('Navigation not possible, no parent navigationContext found.');
+    }
+    return this;
+  }
+
+  /**
+   * Sets the current navigation base to the parent node that is defined as virtualTree. This method works only when the currently active micro frontend is inside a virtualTree.
+   * @memberof linkManager
+   * @returns {linkManager} link manager instance
+   * @since 1.0.1
+   * @example
+   * LuigiClient.linkManager().fromVirtualTreeRoot().navigate('/users/groups/stakeholders')
+   */
+  fromVirtualTreeRoot() {
+    this.options.fromContext = null;
+    this.options.fromClosestContext = false;
+    this.options.fromVirtualTreeRoot = true;
+    return this;
+  }
+
+  /**
+   * Enables navigating to sibling nodes without knowing the absolute path.
+   * @memberof linkManager
+   * @returns {linkManager} link manager instance
+   * @since 1.0.1
+   * @example
+   * LuigiClient.linkManager().fromParent().navigate('/sibling')
+   */
+  fromParent() {
+    this.options.fromParent = true;
+    return this;
+  }
+
+  /**
+   * Sends node parameters to the route. The parameters are used by the `navigate` function. Use it optionally in combination with any of the navigation functions and receive it as part of the context object in Luigi Client.
+   * @memberof linkManager
+   * @param {Object} nodeParams
+   * @returns {linkManager} link manager instance
+   * @example
+   * LuigiClient.linkManager().withParams({foo: "bar"}).navigate("path")
+   *
+   * // Can be chained with context setting functions such as:
+   * LuigiClient.linkManager().fromContext("currentTeam").withParams({foo: "bar"}).navigate("path")
+   */
+  withParams(nodeParams) {
+    if (nodeParams) {
+      Object.assign(this.options.nodeParams, nodeParams);
+    }
+    return this;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Sets options to customise route changing behaviour. The parameters are used by the `navigate` function. Use it optionally in combination with any of the navigation functions and receive it as part of the context object in Luigi Client.
+   * @memberof linkManager
+   * @param {Object} options - navigation options
+   * @param {boolean} options.preventHistoryEntry - by default, it is set to `false`. If it is set to `true`, there is no browser history being kept.
+   * @param {boolean} options.preventContextUpdate - by default, it is set to `false`. If it is set to `true`, there is no context update being triggered.
+   * @returns {linkManager} link manager instance
+   * @since 1.25.0
+   * @example
+   * LuigiClient.linkManager().withOptions(
+   * { preventContextUpdate:true, preventHistoryEntry: true }
+   * ).navigate('/overview')
+   */
+  withOptions(options) {
+    if (!helpers.isObject(options)) return this;
+
+    if (options['preventHistoryEntry'] !== undefined) {
+      this.options.preventHistoryEntry = options['preventHistoryEntry'];
+    }
+
+    if (options['preventContextUpdate'] !== undefined) {
+      this.options.preventContextUpdate = options['preventContextUpdate'];
+    }
+
+    return this;
+  }
+
+  /** @lends linkManager */
+  /**
+   * Checks if the path you can navigate to exists in the main application. For example, you can use this helper method conditionally to display a DOM element like a button.
+   * @memberof linkManager
+   * @param {string} path - path which existence you want to check
+   * @returns {promise} a promise which resolves to a Boolean variable specifying whether the path exists or not
+   * @example
+   *  let pathExists;
+   *  LuigiClient
+   *  .linkManager()
+   *  .pathExists('projects/pr2')
+   *  .then(
+   *    (pathExists) => {  }
+   *  );
+   */
+  pathExists(path) {
+    const currentId = helpers.getRandomId();
+    const pathExistsPromises = this.getPromise('pathExistsPromises') || {};
+    pathExistsPromises[currentId] = {
+      resolveFn: function () {},
+      then: function (resolveFn) {
+        this.resolveFn = resolveFn;
+      }
+    };
+    this.setPromise('pathExistsPromises', pathExistsPromises);
+
+    // register event listener, which will be cleaned up after this usage
+    helpers.addEventListener(
+      'luigi.navigation.pathExists.answer',
+      function (e, listenerId) {
+        const data = e.data.data;
+        const pathExistsPromises = this.getPromise('pathExistsPromises') || {};
+        if (data.correlationId === currentId) {
+          if (pathExistsPromises[data.correlationId]) {
+            pathExistsPromises[data.correlationId].resolveFn(data.pathExists);
+            delete pathExistsPromises[data.correlationId];
+            this.setPromise('pathExistsPromises', pathExistsPromises);
+          }
+          helpers.removeEventListener(listenerId);
+        }
+      }.bind(this)
+    );
+
+    const pathExistsMsg = {
+      msg: 'luigi.navigation.pathExists',
+      data: Object.assign(this.options, {
+        id: currentId,
+        link: path,
+        intent: helpers.hasIntent(path),
+        relative: path[0] !== '/'
+      })
+    };
+    helpers.sendPostMessageToLuigiCore(pathExistsMsg);
+    return pathExistsPromises[currentId];
+  }
+
+  /**
+   * Checks if there is one or more preserved views. You can use it to show a **back** button.
+   * @memberof linkManager
+   * @returns {boolean} indicating if there is a preserved view you can return to
+   */
+  hasBack() {
+    return !!this.currentContext.internal.modal || this.currentContext.internal.viewStackSize !== 0;
+  }
+
+  /**
+   * Discards the active view and navigates back to the last visited view. Works with preserved views, and also acts as the substitute of the browser **back** button. **goBackContext** is only available when using preserved views.
+   * @memberof linkManager
+   * @param {any} goBackValue - data that is passed in the **goBackContext** field to the last visited view when using preserved views
+   * @example
+   * LuigiClient.linkManager().goBack({ foo: 'bar' });
+   * LuigiClient.linkManager().goBack(true);
+   */
+  goBack(goBackValue) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.navigation.back',
+      goBackContext: goBackValue && JSON.stringify(goBackValue)
+    });
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Disables the navigation handling for a single navigation request.
+   * It prevents Luigi Core from handling the URL change after `navigate()`.
+   * Used for auto-navigation.
+   * @since 0.7.7
+   * @example
+   * LuigiClient.linkManager().withoutSync().navigate('/projects/xy/foobar');
+   * LuigiClient.linkManager().withoutSync().fromClosestContext().navigate('settings');
+   */
+  withoutSync() {
+    this.options.withoutSync = true;
+    return this;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Enables navigating to a new tab.
+   * @since 1.16.0
+   * @example
+   * LuigiClient.linkManager().newTab().navigate('/projects/xy/foobar');
+   */
+  newTab() {
+    this.options.newTab = true;
+    return this;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Keeps the URL's query parameters for a navigation request.
+   * @param {boolean} preserve - by default, it is set to `false`. If it is set to `true`, the URL's query parameters will be kept after navigation.
+   * @since 1.19.0
+   * @example
+   * LuigiClient.linkManager().preserveQueryParams(true).navigate('/projects/xy/foobar');
+   * LuigiClient.linkManager().preserveQueryParams(false).navigate('/projects/xy/foobar');
+   */
+  preserveQueryParams(preserve = false) {
+    this.options.preserveQueryParams = preserve;
+    return this;
+  }
+
+  /**
+   * Gets the luigi route associated with the current micro frontend.
+   * @returns {promise} a promise which resolves to a String value specifying the current luigi route
+   * @since 1.23.0
+   * @example
+   * LuigiClient.linkManager().getCurrentRoute();
+   * LuigiClient.linkManager().fromContext('project').getCurrentRoute();
+   * LuigiClient.linkManager().fromVirtualTreeRoot().getCurrentRoute();
+   */
+  getCurrentRoute() {
+    const currentId = helpers.getRandomId();
+
+    const currentRoutePromise = this.getPromise('getCurrentRoute') || {};
+    currentRoutePromise[currentId] = {
+      resolveFn: function () {},
+      then: function (resolveFn) {
+        this.resolveFn = resolveFn;
+      }
+    };
+
+    this.setPromise('getCurrentRoute', currentRoutePromise);
+
+    helpers.addEventListener('luigi.navigation.currentRoute.answer', (e, listenerId) => {
+      const data = e.data.data;
+      const currentRoutePromise = this.getPromise('getCurrentRoute') || {};
+
+      if (data.correlationId === currentId) {
+        if (currentRoutePromise[data.correlationId]) {
+          currentRoutePromise[data.correlationId].resolveFn(data.route);
+          delete currentRoutePromise[data.correlationId];
+          this.setPromise('getCurrentRoute', currentRoutePromise);
+        }
+        helpers.removeEventListener(listenerId);
+      }
+      helpers.removeEventListener(listenerId);
+    });
+
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.navigation.currentRoute',
+      data: Object.assign(this.options, {
+        id: currentId
+      })
+    });
+
+    return currentRoutePromise[currentId];
+  }
+};
+
+/**
+ * @summary Use the UX Manager to manage the appearance features in Luigi.
+ * @augments LuigiClientBase
+ * @name uxManager
+ * @class
+ */
+class UxManager extends LuigiClientBase {
+  /** @private */
+  constructor() {
+    super();
+    helpers.addEventListener('luigi.current-locale-changed', (e) => {
+      if (e.data.currentLocale && lifecycleManager$1.currentContext?.internal) {
+        lifecycleManager$1.currentContext.internal.currentLocale = e.data.currentLocale;
+        lifecycleManager$1._notifyUpdate();
+      }
+    });
+  }
+
+  /**
+   * Adds a backdrop with a loading indicator for the micro frontend frame. This overrides the {@link navigation-parameters-reference.md#node-parameters loadingIndicator.enabled} setting.
+   * @memberof uxManager
+   */
+  showLoadingIndicator() {
+    helpers.sendPostMessageToLuigiCore({ msg: 'luigi.show-loading-indicator' });
+  }
+
+  /**
+   * Removes the loading indicator. Use it after calling {@link #showLoadingIndicator showLoadingIndicator()} or to hide the indicator when you use the {@link navigation-parameters-reference.md#node-parameters loadingIndicator.hideAutomatically: false} node configuration.
+   * @memberof uxManager
+   */
+  hideLoadingIndicator() {
+    helpers.sendPostMessageToLuigiCore({ msg: 'luigi.hide-loading-indicator' });
+  }
+
+  /**
+   * Closes the currently opened micro frontend modal.
+   * @memberof uxManager
+   */
+  closeCurrentModal() {
+    helpers.sendPostMessageToLuigiCore({ msg: 'luigi.close-modal' });
+  }
+
+  /**
+   * Adds a backdrop to block the top and side navigation. It is based on the Fundamental UI Modal, which you can use in your micro frontend to achieve the same behavior.
+   * @memberof uxManager
+   */
+  addBackdrop() {
+    helpers.sendPostMessageToLuigiCore({ msg: 'luigi.add-backdrop' });
+  }
+
+  /**
+   * Removes the backdrop.
+   * @memberof uxManager
+   */
+  removeBackdrop() {
+    helpers.sendPostMessageToLuigiCore({ msg: 'luigi.remove-backdrop' });
+  }
+
+  /**
+   * This method informs the main application that there are unsaved changes in the current view in the iframe. It can be used to prevent navigation away from the current view, for example with form fields which were edited but not submitted. However, this functionality is not restricted to forms. If you use `withoutSync()` together with `setDirtyStatus()`, this is a special case in which the dirty state logic needs to be handled by the micro frontend. For example, if the user navigates with an Angular router, which would trigger `withoutSync()`, Angular needs to take care about dirty state, prevent the navigation and ask for permission to navigate away, through `uxManager().showConfirmationModal(settings)`.
+   * @param {boolean} isDirty - indicates if there are any unsaved changes on the current page or in the component
+   * @memberof uxManager
+   */
+  setDirtyStatus(isDirty) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.set-page-dirty',
+      dirty: isDirty
+    });
+  }
+
+  /**
+   * Shows a confirmation modal.
+   * @memberof uxManager
+   * @param {Object} settings - the settings of the confirmation modal. If you don't provide any value for any of the fields, a default value is used
+   * @param {('confirmation'|'success'|'warning'|'error'|'information')} settings.type - the content of the modal type. (Optional)
+   * @param {string} [settings.header="Confirmation"] - the content of the modal header
+   * @param {string} [settings.body="Are you sure you want to do this?"] - the content of the modal body. It supports HTML formatting elements such as `<br>`, `<b>`, `<strong>`, `<i>`, `<em>`, `<mark>`, `<small>`, `<del>`, `<ins>`, `<sub>`, `<sup>`.
+   * @param {string|false} [settings.buttonConfirm="Yes"] - the label for the modal confirmation button. If set to `false`, the button will not be shown.
+   * @param {string} [settings.buttonDismiss="No"] - the label for the modal dismiss button
+   * @returns {promise} which is resolved when accepting the confirmation modal and rejected when dismissing it
+   * @example
+   * import LuigiClient from '@luigi-project/client';
+   * const settings = {
+   *  type: "confirmation",
+   *  header: "Confirmation",
+   *  body: "Are you sure you want to do this?",
+   *  buttonConfirm: "Yes",
+   *  buttonDismiss: "No"
+   * }
+   * LuigiClient
+   *  .uxManager()
+   *  .showConfirmationModal(settings)
+   *  .then(() => {
+   *     // Logic to execute when the confirmation modal is dismissed
+   *  });
+   */
+  showConfirmationModal(settings) {
+    helpers.addEventListener('luigi.ux.confirmationModal.hide', (e, listenerId) => {
+      this.hideConfirmationModal(e.data.data);
+      helpers.removeEventListener(listenerId);
+    });
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.ux.confirmationModal.show',
+      data: { settings }
+    });
+
+    const confirmationModalPromise = {};
+    confirmationModalPromise.promise = new Promise((resolve, reject) => {
+      confirmationModalPromise.resolveFn = resolve;
+      confirmationModalPromise.rejectFn = reject;
+    });
+    this.setPromise('confirmationModal', confirmationModalPromise);
+    return confirmationModalPromise.promise;
+  }
+
+  /**
+   * @private
+   * @memberof uxManager
+   * @param {Object} modal - confirmed boolean value if ok or cancel has been pressed
+   */
+  hideConfirmationModal(modal) {
+    const promise = this.getPromise('confirmationModal');
+    if (promise) {
+      modal.confirmed ? promise.resolveFn() : promise.rejectFn();
+      this.setPromise('confirmationModal', undefined);
+    }
+  }
+
+  /**
+   * Shows an alert.
+   * @memberof uxManager
+   * @param {Object} settings - the settings for the alert
+   * @param {string} settings.text - the content of the alert. To add a link to the content, you have to set up the link in the `links` object. The key(s) in the `links` object must be used in the text to reference the links, wrapped in curly brackets with no spaces. If you don't specify any text, the alert is not displayed
+   * @param {('info'|'success'|'warning'|'error')} settings.type - sets the type of alert
+   * @param {Object} settings.links - provides links data
+   * @param {Object} settings.links.LINK_KEY - object containing the data for a particular link. To properly render the link in the alert message refer to the description of the **settings.text** parameter
+   * @param {string} settings.links.LINK_KEY.text - text which replaces the link identifier in the alert content
+   * @param {string} settings.links.LINK_KEY.url - URL to navigate when you click the link. Currently, only internal links are supported in the form of relative or absolute paths
+   * @param {string} settings.links.LINK_KEY.dismissKey - dismissKey which represents the key of the link
+   * @param {number} settings.closeAfter - (optional) time in milliseconds that tells Luigi when to close the Alert automatically. If not provided, the Alert will stay on until closed manually. It has to be greater than `100`
+   * @returns {promise} which is resolved when the alert is dismissed
+   * @example
+   * import LuigiClient from '@luigi-project/client';
+   * const settings = {
+   *  text: "Ut enim ad minim veniam, {goToHome} quis nostrud exercitation ullamco {relativePath}. Duis aute irure dolor {goToOtherProject} or {neverShowItAgain}",
+   *  type: 'info',
+   *  links: {
+   *    goToHome: { text: 'homepage', url: '/overview' },
+   *    goToOtherProject: { text: 'other project', url: '/projects/pr2' },
+   *    relativePath: { text: 'relative hide side nav', url: 'hideSideNav' },
+   *    neverShowItAgain: { text: 'Never show it again', dismissKey: 'neverShowItAgain' }
+   *  },
+   *  closeAfter: 3000
+   * }
+   * LuigiClient
+   *  .uxManager()
+   *  .showAlert(settings)
+   *  .then(() => {
+   *     // Logic to execute when the alert is dismissed
+   *  });
+   */
+  showAlert(settings) {
+    //generate random ID
+    settings.id = helpers.getRandomId();
+
+    helpers.addEventListener('luigi.ux.alert.hide', (e, listenerId) => {
+      if (e.data.id === settings.id) {
+        this.hideAlert(e.data);
+        helpers.removeEventListener(listenerId);
+      }
+    });
+
+    if (settings?.closeAfter < 100) {
+      console.warn(`Message with id='${settings.id}' has too small 'closeAfter' value. It needs to be at least 100ms.`);
+      settings.closeAfter = undefined;
+    }
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'luigi.ux.alert.show',
+      data: { settings }
+    });
+
+    const alertPromises = this.getPromise('alerts') || {};
+    alertPromises[settings.id] = {};
+    alertPromises[settings.id].promise = new Promise((resolve) => {
+      alertPromises[settings.id].resolveFn = resolve;
+    });
+    this.setPromise('alerts', alertPromises);
+    return alertPromises[settings.id].promise;
+  }
+
+  /**
+   * @private
+   * @memberof uxManager
+   * @param {Object} alertObj
+   * @param {string} alertObj.id - alert id
+   * @param {string} alertObj.dismissKey - key of the link
+   */
+  hideAlert({ id, dismissKey }) {
+    const alerts = this.getPromise('alerts');
+    if (id && alerts[id]) {
+      alerts[id].resolveFn(dismissKey ? dismissKey : id);
+      delete alerts[id];
+      this.setPromise('alerts', alerts);
+    }
+  }
+
+  /**
+   * Gets the current locale.
+   * @returns {string} current locale
+   * @memberof uxManager
+   */
+  getCurrentLocale() {
+    return lifecycleManager$1.currentContext?.internal?.currentLocale;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Sets current locale to the specified one.
+   *
+   * **NOTE:** this must be explicitly allowed on the navigation node level by setting `clientPermissions.changeCurrentLocale` to `true`. (See {@link navigation-parameters-reference.md Node parameters}.)
+   *
+   * @param {string} locale - locale to be set as the current locale
+   * @memberof uxManager
+   */
+  setCurrentLocale(locale) {
+    if (locale) {
+      helpers.sendPostMessageToLuigiCore({
+        msg: 'luigi.ux.set-current-locale',
+        data: {
+          currentLocale: locale
+        }
+      });
+    }
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Checks if the current micro frontend is displayed inside a split view
+   * @returns {boolean} indicating if it is loaded inside a split view
+   * @memberof uxManager
+   * @since 0.6.0
+   */
+  isSplitView() {
+    return lifecycleManager$1.currentContext?.internal?.splitView;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Checks if the current micro frontend is displayed inside a modal
+   * @returns {boolean} indicating if it is loaded inside a modal
+   * @memberof uxManager
+   * @since 0.6.0
+   */
+  isModal() {
+    return lifecycleManager$1.currentContext?.internal?.modal;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Checks if the current micro frontend is displayed inside a drawer
+   * @returns {boolean} indicating if it is loaded inside a drawer
+   * @memberof uxManager
+   * @since 1.26.0
+   */
+  isDrawer() {
+    return lifecycleManager$1.currentContext?.internal?.drawer;
+  }
+
+  /**
+   * Gets the current theme.
+   * @returns {*} current themeObj
+   * @memberof uxManager
+   */
+  getCurrentTheme() {
+    return lifecycleManager$1.currentContext?.internal?.currentTheme;
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Gets the CSS variables from Luigi Core with their key and value.
+   * @returns {Object} CSS variables with their key and value.
+   * @memberof uxManager
+   * @since 2.3.0
+   * @example LuigiClient.uxManager().getCSSVariables();
+   */
+  getCSSVariables() {
+    return lifecycleManager$1.currentContext?.internal?.cssVariables || {};
+  }
+
+  /**
+   * <!-- label-success: Web App API only  -->
+   * Adds the CSS variables from Luigi Core in a <style> tag to the document <head> section.
+   * @memberof uxManager
+   * @since 2.3.0
+   * @example LuigiClient.uxManager().applyCSS();
+   */
+  applyCSS() {
+    document.querySelectorAll('head style[luigi-injected]').forEach((luigiInjectedStyleTag) => {
+      luigiInjectedStyleTag.remove();
+    });
+    const vars = lifecycleManager$1.currentContext?.internal?.cssVariables;
+    if (vars) {
+      let cssString = ':root {\n';
+      Object.keys(vars).forEach((key) => {
+        const val = vars[key];
+        cssString += (key.startsWith('--') ? '' : '--') + key + ':' + val + ';\n';
+      });
+      cssString += '}';
+      const themeStyle = document.createElement('style');
+      themeStyle.setAttribute('luigi-injected', true);
+      themeStyle.innerHTML = cssString;
+      document.head.appendChild(themeStyle);
+    }
+  }
+}
+const uxManager$1 = new UxManager();
+
+const pendingOperation = new Map();
+
+/**
+ * <!-- label-success: Web App API only  -->
+ * StorageManager allows you to use browser local storage of key/values. Every storage operation is sent to be managed by Luigi Core.
+ * The idea is that different micro frontends can share or persist items using local storage, as long as they come from the same domain and follow the [same-origin policy](https://developer.mozilla.org/en-US/docs/Web/Security/Same-origin_policy).
+ * Since all storage operations are asynchronous (sending an event to Luigi Core that will reply once operation is finished), all the methods return Promises.
+ * @augments LuigiClientBase
+ * @name storageManager
+ * @class
+ */
+class StorageManager extends LuigiClientBase {
+  /** @private */
+  constructor() {
+    super();
+    this.storageEventProcessor = new StorageEventProcessor();
+    helpers.addEventListener('storage', (evt, listenerId) => this.storageEventProcessor.processEvent(evt, listenerId));
+  }
+
+  /**
+   * Stores an item for a specific key.
+   * @memberof storageManager
+   * @param {string} key - key used to identify the value
+   * @param {Object} value - item to store; object must be stringifyable
+   * @returns {Promise<void>} resolves an empty value when the storage operation is over. It will launch an error if storage is not supported, the value cannot be stringified, or if you are using a Luigi reserved key.
+   * @example
+   * LuigiClient.storageManager().setItem('keyExample','valueExample').then(() => console.log('Value stored'))
+   * @since 1.6.0
+   */
+  setItem(key, value) {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'setItem', {
+        key,
+        value
+      });
+    });
+  }
+
+  /**
+   * Retrieves an item for a specific key.
+   * @memberof storageManager
+   * @param {string} key - used to identify the value
+   * @returns {Promise<Object>} resolves an item retrieved from storage. It will launch an error if storage is not supported.
+   * @example
+   * LuigiClient.storageManager().getItem('keyExample').then((value) => console.log);
+   * @since 1.6.0
+   */
+  getItem(key) {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'getItem', { key });
+    });
+  }
+
+  /**
+   * Removes an item for a specific key.
+   * @memberof storageManager
+   * @param {string} key - used to identify the value
+   * @returns {Promise<Object>} resolves an item just removed from storage. It will launch an error if storage is not supported or if you are using a Luigi reserved key.
+   * @example
+   * LuigiClient.storageManager().removeItem('keyExample').then((value) => console.log(value + ' just removed')
+   * @since 1.6.0
+   */
+  removeItem(key) {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'removeItem', {
+        key
+      });
+    });
+  }
+
+  /**
+   * Clears all the storage key/values.
+   * @memberof storageManager
+   * @returns {Promise<void>} resolves when storage clear is over.
+   * @example
+   * LuigiClient.storageManager().clear().then(() => console.log('storage cleared'))
+   * @since 1.6.0
+   */
+  clear() {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'clear', {});
+    });
+  }
+
+  /**
+   * Checks if a key is present in storage.
+   * @memberof storageManager
+   * @param {string} key - key in the storage
+   * @returns {Promise<boolean>} `true` if key is present, `false` if it is not
+   * @example
+   * LuigiClient.storageManager().has(key).then((present) => console.log('item is present '+present))
+   * @since 1.6.0
+   */
+  has(key) {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'has', { key });
+    });
+  }
+
+  /**
+   * Gets all the keys used in the storage.
+   * @memberof storageManager
+   * @returns {Promise<string[]>} keys currently present in the storage
+   * @example
+   * LuigiClient.storageManager().getAllKeys().then((keys) => console.log('keys are '+keys))
+   * @since 1.6.0
+   */
+  getAllKeys() {
+    return new Promise((resolve, reject) => {
+      this.storageEventProcessor.execute(resolve, reject, 'getAllKeys', {});
+    });
+  }
+}
+
+class StorageEventProcessor {
+  processEvent(evt, listenerId) {
+    try {
+      const data = evt.data.data;
+      if (!pendingOperation.has(data.id)) {
+        console.log('Impossible to find Promise method for message ' + data.id);
+        return;
+      }
+      const promiseOperations = pendingOperation.get(data.id);
+      if (data.status === 'ERROR') {
+        promiseOperations.reject(data.result);
+      } else {
+        promiseOperations.resolve(data.result);
+      }
+      pendingOperation.delete(data.id);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+
+  waitForSyncResult(id) {
+    let start = new Date().getTime();
+    while (!syncOperation.has(id)) {
+      let exec = new Date().getTime() - start;
+      if (exec > 10000) {
+        throw 'Storage operation is taking more than 1 second...Some problem with Luigi Core communication';
+      }
+    }
+    const result = syncOperation.get(id);
+    pendingOperation.delete(id);
+    return result;
+  }
+
+  execute(resolve, reject, operation, params) {
+    let id = helpers.getRandomId();
+    this.createPendingOperation(id, resolve, reject);
+    this.sendMessage(id, operation, params);
+  }
+
+  createPendingOperation(id, resolve, reject) {
+    pendingOperation.set(id, {
+      resolve,
+      reject
+    });
+  }
+  sendMessage(id, operation, params) {
+    helpers.sendPostMessageToLuigiCore({
+      msg: 'storage',
+      data: {
+        id,
+        operation,
+        params
+      }
+    });
+  }
+}
+
+const storageManager$1 = new StorageManager();
+
+/**
+ * @name LuigiClient
+ * @private
+ */
+class LuigiClient {
+  constructor() {
+    if (window !== window.top) {
+      if (window.document.head.getAttribute('disable-luigi-history-handling') !== 'true') {
+        history.pushState = history.replaceState.bind(history);
+      }
+      if (window.document.head.getAttribute('disable-luigi-runtime-error-handling') !== 'true') {
+        window.addEventListener('error', ({ filename, message, lineno, colno, error }) => {
+          const msg = {
+            msg: 'luigi-runtime-error-handling',
+            errorObj: { filename, message, lineno, colno, error }
+          };
+          helpers.sendPostMessageToLuigiCore(msg);
+        });
+      }
+    }
+  }
+
+  addInitListener(initFn, disableTpcCheck) {
+    return lifecycleManager$1.addInitListener(initFn, disableTpcCheck);
+  }
+  removeInitListener(id) {
+    return lifecycleManager$1.removeInitListener(id);
+  }
+  addContextUpdateListener(contextUpdatedFn) {
+    return lifecycleManager$1.addContextUpdateListener(contextUpdatedFn);
+  }
+  removeContextUpdateListener(id) {
+    return lifecycleManager$1.removeContextUpdateListener(id);
+  }
+  getToken() {
+    return lifecycleManager$1.getToken();
+  }
+  getEventData() {
+    return lifecycleManager$1.getEventData();
+  }
+  getContext() {
+    return lifecycleManager$1.getContext();
+  }
+  addNodeParams(params, keepBrowserHistory) {
+    return lifecycleManager$1.addNodeParams(params, keepBrowserHistory);
+  }
+  getNodeParams(shouldDesanitise) {
+    return lifecycleManager$1.getNodeParams(shouldDesanitise);
+  }
+  getActiveFeatureToggles() {
+    return lifecycleManager$1.getActiveFeatureToggles();
+  }
+  getPathParams() {
+    return lifecycleManager$1.getPathParams();
+  }
+  getCoreSearchParams() {
+    return lifecycleManager$1.getCoreSearchParams();
+  }
+  addCoreSearchParams(searchParams, keepBrowserHistory) {
+    return lifecycleManager$1.addCoreSearchParams(searchParams, keepBrowserHistory);
+  }
+  getClientPermissions() {
+    return lifecycleManager$1.getClientPermissions();
+  }
+  sendCustomMessage(message) {
+    return lifecycleManager$1.sendCustomMessage(message);
+  }
+  addCustomMessageListener(messageId, listener) {
+    return lifecycleManager$1.addCustomMessageListener(messageId, listener);
+  }
+  removeCustomMessageListener(listenerId) {
+    return lifecycleManager$1.removeCustomMessageListener(listenerId);
+  }
+  addInactiveListener(messageId, listener) {
+    return lifecycleManager$1.addInactiveListener(messageId, listener);
+  }
+  removeInactiveListener(listenerId) {
+    return lifecycleManager$1.removeInactiveListener(listenerId);
+  }
+  setTargetOrigin(origin) {
+    return lifecycleManager$1.setTargetOrigin(origin);
+  }
+  getUserSettings() {
+    return lifecycleManager$1.getUserSettings();
+  }
+  isLuigiClientInitialized() {
+    return lifecycleManager$1.isLuigiClientInitialized();
+  }
+  luigiClientInit() {
+    return lifecycleManager$1.luigiClientInit();
+  }
+  getAnchor() {
+    return lifecycleManager$1.getAnchor();
+  }
+  setAnchor(value) {
+    return lifecycleManager$1.setAnchor(value);
+  }
+  setViewGroupData(value) {
+    return lifecycleManager$1.setViewGroupData(value);
+  }
+
+  /**
+   * @private
+   */
+  linkManager() {
+    return new linkManager$1({
+      currentContext: lifecycleManager$1.currentContext
+    });
+  }
+  /**
+   * @private
+   */
+  uxManager() {
+    return uxManager$1;
+  }
+  /**
+   * @private
+   */
+  lifecycleManager() {
+    return lifecycleManager$1;
+  }
+  /**
+   * @private
+   */
+  storageManager() {
+    return storageManager$1;
+  }
+}
+var LuigiClient$1 = LuigiClient = new LuigiClient();
+
+const uxManager = LuigiClient$1.uxManager;
+const linkManager = LuigiClient$1.linkManager;
+const lifecycleManager = LuigiClient$1.lifecycleManager;
+const storageManager = LuigiClient$1.storageManager;
+
+export { LuigiClient$1 as default, lifecycleManager, linkManager, storageManager, uxManager };