@sapui5/sap.ushell_abap 1.145.1 → 1.147.0

package/src/main/js/sap/ushell_abap/bootstrap/BootTask/RequestTargetMappings.js

@@ -0,0 +1,29 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/base/util/ObjectPath",
+    "sap/ushell_abap/bootstrap/StartupRequestHandler",
+    "sap/ushell/bootstrap/Config"
+], (
+    ObjectPath,
+    StartupRequestHandler,
+    BootstrapConfig
+) => {
+    "use strict";
+
+    class RequestTargetMappings {
+        async run () {
+            const oUshellConfig = BootstrapConfig.get();
+
+            const pResult = StartupRequestHandler.requestFullTM();
+
+            ObjectPath.set("services.ClientSideTargetResolution.adapter.config.navTargetDataPromise", pResult, oUshellConfig);
+            // Do not issue the separate compact request for the launchpage adapter, as it was done in the earlier FLP versions.
+            // Reuse the existing full target mappings request that is sent in any case.
+            ObjectPath.set("services.LaunchPage.adapter.config.compactTMPromise", pResult, oUshellConfig);
+            ObjectPath.set("services.FlpLaunchPage.adapter.config.compactTMPromise", pResult, oUshellConfig);
+            ObjectPath.set("services.VisualizationDataProvider.adapter.config.compactTMPromise", pResult, oUshellConfig);
+        }
+    }
+
+    return new RequestTargetMappings();
+});

package/src/main/js/sap/ushell_abap/bootstrap/BootTask.js

@@ -0,0 +1,47 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/base/Log",
+    "sap/ui/performance/trace/initTraces",
+    "sap/ushell_abap/bootstrap/BootTask/PrepareDirectAppStart",
+    "sap/ushell_abap/bootstrap/BootTask/RequestTargetMappings",
+    "sap/ushell_abap/bootstrap/BootTask/RequestGroups"
+], (
+    Log,
+    initTraces,
+    PrepareDirectAppStart,
+    RequestTargetMappings,
+    RequestGroups
+) => {
+    "use strict";
+
+    class BootTask {
+        async run (fnCallback, fnErrorCallback) {
+            try {
+                performance?.mark("FLP - boottask start");
+
+                // initialize UI5 performance tracing (FESR) before first request is sent, so that this is also instrumented
+                initTraces();
+
+                PrepareDirectAppStart.run().catch((oError) => {
+                    Log.error("Error during the preparation of direct app start", oError, "sap.ushell_abap.bootstrap.BootTask");
+                });
+
+                RequestGroups.run().catch((oError) => {
+                    Log.error("Error during request of groups", oError, "sap.ushell_abap.bootstrap.BootTask");
+                });
+
+                RequestTargetMappings.run().catch((oError) => {
+                    Log.error("Error during request of target mappings", oError, "sap.ushell_abap.bootstrap.BootTask");
+                });
+
+                performance?.mark("FLP - boottask end");
+
+                fnCallback();
+            } catch (oError) {
+                fnErrorCallback(oError);
+            }
+        }
+    }
+
+    return new BootTask();
+});

package/src/main/js/sap/ushell_abap/bootstrap/ConfigurationProvider.js

@@ -0,0 +1,87 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileoverview ABAP bootstrap configuration provider.
+ *
+ * Coordinates the initialization of BootstrapConfig, PlatformConfig, and
+ * the merged UI5 configuration for the ABAP platform. Returns a singleton.
+ */
+sap.ui.define([
+    "sap/base/util/deepExtend",
+    "sap/ushell_abap/bootstrap/abapConstants",
+    "sap/ushell_abap/bootstrap/PlatformConfig",
+    "sap/ushell/bootstrap/Config"
+], (
+    deepExtend,
+    abapConstants,
+    PlatformConfig,
+    BootstrapConfig
+) => {
+    "use strict";
+
+    /**
+     * @alias sap.ushell_abap.bootstrap.ConfigurationProvider
+     * @namespace
+     * @description Configuration provider for the ABAP bootstrap.
+     *
+     * Initializes the ushell configuration with ABAP defaults, applies
+     * platform-specific settings, and merges the resulting UI5 configuration.
+     *
+     * @since 1.147.0
+     * @private
+     */
+    class ConfigurationProvider {
+        /** @type {object} The merged UI5 configuration */
+        #oUI5Config;
+
+        constructor () {
+            this.#init();
+        }
+
+        /**
+         * Runs the initialization sequence: initializes BootstrapConfig with ABAP
+         * defaults, configures the ushell via PlatformConfig, merges UI5 configs,
+         * and applies module paths.
+         *
+         * @since 1.147.0
+         * @private
+         */
+        #init () {
+            BootstrapConfig.initialize(abapConstants.defaultUshellConfig);
+
+            // Extend the default config with platform specific config inplace
+            PlatformConfig.configureUshell();
+
+            this.#oUI5Config = deepExtend({}, BootstrapConfig.getUI5Config(), PlatformConfig.getUI5Config());
+
+            BootstrapConfig.applyModulePaths();
+        }
+
+        /**
+         * Returns the value of a UI5 configuration property.
+         *
+         * @param {string} sCamelizedKey The camelCase key of the UI5 configuration property (e.g. "sapUiTheme", "sapUiLanguage")
+         * @returns {any} The value of the requested key, or <code>undefined</code>
+         *
+         * @since 1.147.0
+         * @private
+         */
+        get (sCamelizedKey) {
+            return this.#oUI5Config[sCamelizedKey];
+        }
+
+        /**
+         * Only for testing purposes!
+         * Resets the configuration and re-runs initialization.
+         *
+         * @since 1.147.0
+         * @private
+         */
+        reset () {
+            BootstrapConfig.reset();
+            this.#init();
+        }
+    }
+
+    return new ConfigurationProvider();
+});

package/src/main/js/sap/ushell_abap/bootstrap/DirectAppStart.js

@@ -0,0 +1,231 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/base/Log",
+    "sap/base/util/ObjectPath",
+    "sap/ushell_abap/bootstrap/StartupRequestHandler",
+    "sap/ushell/bootstrap/Config",
+    "sap/ushell/base/promisify",
+    "sap/ushell/base/requireAsync",
+    "sap/ushell/base/UrlParsing"
+], (
+    Log,
+    ObjectPath,
+    StartupRequestHandler,
+    BootstrapConfig,
+    promisify,
+    requireAsync,
+    UrlParsing
+) => {
+    "use strict";
+
+    class DirectAppStart {
+        #aInternTargets = [
+            "#Shell-home",
+            "#Launchpad-openFLPPage",
+            "#Shell-appfinder",
+            "#Shell-catalog",
+            "#shell-catalog",
+            "#Action-search"
+        ];
+
+        #isRelevant () {
+            const sHash = this.#getFullHash();
+
+            return sHash !== "#" && !this.#aInternTargets.some((sTarget) => sHash.startsWith(sTarget));
+        }
+
+        async prepare () {
+            const oUshellConfig = BootstrapConfig.get();
+
+            if (!this.#isRelevant()) {
+                ObjectPath.set("services.ClientSideTargetResolution.adapter.config.initialSegmentPromise", Promise.resolve(null), oUshellConfig);
+                ObjectPath.set("services.AppState.config.initialAppStatesPromise", Promise.resolve({}), oUshellConfig);
+                return;
+            }
+
+            const oParsedHash = UrlParsing.parseShellHash(this.#getFullHash(), true);
+            const oInitialKeys = {
+                "sap-xapp-state": oParsedHash.params?.["sap-xapp-state"]?.[0],
+                "sap-intent-param": oParsedHash.params?.["sap-intent-param"]?.[0],
+                "sap-system": oParsedHash.params?.["sap-system"]?.[0],
+                "sap-iapp-state": oParsedHash.params?.["sap-iapp-state"]?.[0]
+            };
+
+            // consider iapp-state also from appSpecificRoute
+            if (!oInitialKeys["sap-iapp-state"] && oParsedHash.appSpecificRoute?.includes("sap-iapp-state")) {
+                const rRegex = /(\?|&|[/])(sap-iapp-state=[A-Z0-9]+)/;
+                const aMatch = oParsedHash.appSpecificRoute.match(rRegex);
+                if (aMatch?.[2]) {
+                    oInitialKeys["sap-iapp-state"] = aMatch[2].split("=")[1];
+                }
+            }
+
+            // remove all undefined values, as they would cause issues in the query
+            Object.keys(oInitialKeys).forEach((sKey) => {
+                if (oInitialKeys[sKey] === undefined) {
+                    delete oInitialKeys[sKey];
+                }
+            });
+
+            const oSegment = {
+                semanticObject: oParsedHash.semanticObject,
+                action: oParsedHash.action
+            };
+
+            const pTargetMappings = StartupRequestHandler.requestDirectStart(oSegment, oInitialKeys);
+
+            const pInitialSegmentPromise = pTargetMappings.then((oResult) => {
+                if (!oResult.targetMappings) {
+                    return null;
+                }
+                return [
+                    [oSegment],
+                    oResult.targetMappings,
+                    oResult.systemAliases,
+                    oResult.urlTemplates
+                ];
+            });
+            ObjectPath.set("services.ClientSideTargetResolution.adapter.config.initialSegmentPromise", pInitialSegmentPromise, oUshellConfig);
+
+            const pInitialAppStatesPromise = pTargetMappings.then((oResult) => {
+                const oInitialAppStates = [
+                    { key: "sap-intent-param", startUpKey: "iparState" },
+                    { key: "sap-iapp-state", startUpKey: "iappState" },
+                    { key: "sap-xapp-state", startUpKey: "xappState" }
+                ].reduce((oAppStates, { key, startUpKey }) => {
+                    const sAppStateKey = oInitialKeys[key];
+
+                    if (sAppStateKey && oResult[startUpKey]) {
+                        oAppStates[sAppStateKey] = oResult[startUpKey];
+                    }
+
+                    return oAppStates;
+                }, {});
+
+                ObjectPath.set("services.AppState.config.initialAppStates", oInitialAppStates, oUshellConfig);
+            });
+            ObjectPath.set("services.AppState.config.initialAppStatesPromise", pInitialAppStatesPromise, oUshellConfig);
+
+            return Promise.all([
+                pTargetMappings,
+                pInitialSegmentPromise,
+                pInitialAppStatesPromise
+            ]);
+        }
+
+        async startApp () {
+            if (!this.#isRelevant()) {
+                return;
+            }
+
+            window["sap-ushell-async-libs-promise-directstart"] = this.#startApp();
+
+            await window["sap-ushell-async-libs-promise-directstart"];
+        }
+
+        async #startApp () {
+            let sHash = this.#getFullHash();
+            if (sHash.includes("sap-ssb-eval-id")) {
+                sHash = await this.#resolveEvalId(sHash);
+            }
+
+            const [Container] = await requireAsync(["sap/ushell/Container"]);
+            const NavTargetResolutionInternal = await Container.getServiceAsync("NavTargetResolutionInternal");
+            const oDeferred = NavTargetResolutionInternal.resolveHashFragment(UrlParsing.ensureLeadingHash(sHash));
+
+            const oResolvedHashFragment = await promisify(oDeferred);
+
+            const [AppConfiguration] = await requireAsync(["sap/ushell/services/AppConfiguration"]);
+
+            AppConfiguration.setCurrentApplication(oResolvedHashFragment);
+
+            if (oResolvedHashFragment?.ui5ComponentName) {
+                // create UI5 component early
+                const Ui5ComponentLoader = await Container.getServiceAsync("Ui5ComponentLoader");
+
+                const oResolvedHashFragmentWithComponentHandle = await Ui5ComponentLoader.createComponent(
+                    oResolvedHashFragment,
+                    [this.#createWaitForRendererCreatedPromise(Container)],
+                    "Application"
+                );
+
+                return {
+                    resolvedHashFragment: oResolvedHashFragmentWithComponentHandle,
+                    dependenciesLoaded: true
+                };
+            }
+
+            // non-ui5 app
+            return {
+                resolvedHashFragment: oResolvedHashFragment,
+                dependenciesLoaded: false
+            };
+        }
+
+        /**
+         * For a Smart Business direct start the parameter sap-ssb-eval-id has to be
+         * resolved by Smart Business early so that the resolved parameters are already
+         * passed to the app component during the early component creation.
+         * @param {string} sHash the current hash
+         */
+        async #resolveEvalId (sHash) {
+            const [SmartBusiness] = await requireAsync(["sap/ushell/utils/SmartBusiness"]);
+
+            // At this early point in time the Smart Business library has not been loaded yet.
+            // Load it to avoid single file requests.
+            // On ABAP, the path where the library is loaded from differs from the
+            // common namespace so it has to be mapped.
+            await SmartBusiness.loadSmartBusinessLibrary("/sap/bc/ui5_ui5/sap/ssbtileslibs1");
+
+            let oParsedShellHash = UrlParsing.parseShellHash(sHash);
+            oParsedShellHash = await SmartBusiness.resolveEvaluationId(oParsedShellHash, true);
+            return UrlParsing.constructShellHash(oParsedShellHash);
+        }
+
+        /**
+         * Creates an ECMA6 Promise which resolves after the shell renderer has been created. This
+         * is necessary to delay the component creation in direct start case, so that the shell renderer
+         * had time to initialize (e.g. init shell navigation service).
+         *
+         * This method must only be called after the shell bootstrap!
+         * @param {sap.ushell.Container} Container The shell container instance
+         * @returns {Promise} A promise to chain following steps.
+         * @private
+         */
+        async #createWaitForRendererCreatedPromise (Container) {
+            const [EventHub] = await requireAsync(["sap/ushell/EventHub"]);
+            const oDeferred = Promise.withResolvers();
+
+            function fnOnRendererCreated () {
+                Log.info("Direct application start: resolving component waitFor promise after shell renderer created event fired.");
+                Container.detachRendererCreatedInternal(fnOnRendererCreated);
+                oDeferred.resolve();
+            }
+
+            EventHub.once("ShellNavigationInitialized").do(() => {
+                if (Container.getRendererInternal()) {
+                    Log.info("Direct application start: resolving component waitFor promise immediately (shell renderer already created).");
+                    oDeferred.resolve();
+                } else {
+                    // the renderer should be created when the shell navigation is initialized, just to but be robust
+                    Container.attachRendererCreatedInternal(fnOnRendererCreated);
+                }
+            });
+
+            return oDeferred.promise;
+        }
+
+        #getFullHash () {
+            const sHash = this.getLocationHash();
+            const sSanitizedHash = sHash.startsWith("#") ? sHash : `#${sHash}`;
+            // decode hash: identical behavior to ShellNavigationInternal.hrefForExternal
+            return decodeURI(sSanitizedHash);
+        }
+
+        getLocationHash () {
+            return window.location.hash;
+        }
+    }
+
+    return new DirectAppStart();
+});

package/src/main/js/sap/ushell_abap/bootstrap/LoadLaunchpad/CreateRenderer.js

@@ -0,0 +1,43 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/ushell/Container",
+    "sap/ushell/state/StateManager",
+    "sap/ushell/renderer/ShellLayout",
+    "sap/ushell/ui/shell/SysInfoBar"
+], (
+    Container,
+    StateManager,
+    ShellLayout,
+    SysInfoBar
+) => {
+    "use strict";
+
+    // shortcut for sap.ushell.state.StateManager.ShellMode
+    const ShellMode = StateManager.ShellMode;
+
+    class CreateRenderer {
+        async run () {
+            const oRenderer = await Container.createRendererInternal("fiori2");
+            oRenderer.placeAt("canvas", "only");
+            const oSystem = Container.getLogonSystem();
+            const sCurrentShellMode = StateManager.getShellMode();
+
+            if (!oSystem.getSysInfoBar() || sCurrentShellMode === ShellMode.Headerless) {
+                return;
+            }
+
+            const sSystemInfoHtml = "<div id='systemInfo-shellArea'></div>";
+            const oShellHeaderShellArea = document.getElementById(ShellLayout.ShellArea.ShellHeader);
+            oShellHeaderShellArea.insertAdjacentHTML("beforebegin", sSystemInfoHtml);
+
+            new SysInfoBar({
+                icon: oSystem.getSysInfoBarIcon(),
+                text: oSystem.getSysInfoBarMainText(),
+                subText: oSystem.getSysInfoBarSecondaryText(),
+                color: oSystem.getSysInfoBarColor()
+            }).placeAt("systemInfo-shellArea");
+        }
+    }
+
+    return new CreateRenderer();
+});

package/src/main/js/sap/ushell_abap/bootstrap/LoadLaunchpad/InitXhrLogon.js

@@ -0,0 +1,148 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/ushell_abap/bootstrap/XhrLogonLibLoader", // triggers loading of the XHR logon lib, once required
+    "sap/ushell_abap/bootstrap/XhrLogonEventHandler",
+    "sap/ushell/bootstrap/Config",
+    "sap/base/Log",
+    "sap/ushell/Container"
+], (
+    XhrLogonLibLoader,
+    XhrLogonEventHandler,
+    BootstrapConfig,
+    Log,
+    Container
+) => {
+    "use strict";
+
+    class InitXhrLogon {
+        async run () {
+            await Promise.all([
+                this.#initXhrLogon(),
+                this.#initFrameLogonManager()
+            ]);
+        }
+
+        /**
+         * Determines the XHR logon mode based on the bootstrap configuration
+         * and the URL parameters sap-ushell-xhrLogon-mode and saml2.
+         * @returns {string} the logon mode
+         */
+        #getLogonMode () {
+            const oUshellConfig = BootstrapConfig.get();
+            const sSearch = this.getWindowLocationSearch();
+            const oUrlParameters = new URLSearchParams(sSearch);
+
+            return oUrlParameters.get("sap-ushell-xhrLogon-mode")
+            || (oUrlParameters.get("saml2")?.toLowerCase() === "disabled" ? "logoffAndRedirect" : undefined)
+            || oUshellConfig?.xhrLogon?.mode
+            || "frame";
+        }
+
+        /**
+         * Initializes and starts XHR logon lib based on a given configuration.
+         * <p>
+         *
+         * @private
+         */
+        async #initXhrLogon () {
+            const oXhrLogonLib = await XhrLogonLibLoader.getLib();
+
+            const sLogonMode = this.#getLogonMode();
+            const oXhrLogonEventHandler = this.createXhrLogonEventHandler(window, sLogonMode);
+            const oLogonManager = oXhrLogonLib.LogonManager.getInstance();
+            const oXHRLogonManager = oXhrLogonLib.XHRLogonManager.getInstance();
+            const oXhrLibConfig = {
+                explicitMatchOnCORS: true // avoids to send XHRLib HTTP headers to thirdparty services
+            };
+
+            oXhrLogonLib.start(oXhrLibConfig);
+
+            if (sLogonMode === "reload" || sLogonMode === "logoffAndRedirect") {
+                oLogonManager.unregisterAllHandlers();
+                oLogonManager.registerAuthHandler("*", (oEvent) => {
+                    oXhrLogonEventHandler.handleEvent(oEvent);
+                });
+            } else if (sLogonMode !== "frame") {
+                Log.warning(`Unknown setting for xhrLogonMode: '${sLogonMode}'. Using default mode 'frame'.`, null, "sap.ushell_abap.bootstrap.XhrLogon");
+            }
+
+            oXhrLogonLib.Log.set(this.#createUi5ConnectedXhrLogger());
+            this.#initXhrLogonIgnoreList(oXHRLogonManager);
+        }
+
+        async #initFrameLogonManager () {
+            const oXhrLogonLib = await XhrLogonLibLoader.getLib();
+            const oFrameLogonManager = oXhrLogonLib.FrameLogonManager.getInstance();
+            Container.oFrameLogonManager = oFrameLogonManager;
+        }
+
+        /**
+         * Creates a logger for XMLHttpRequest(s) that logs errors, warnings, info
+         * and debug messages via Log.
+         *
+         * @returns {object}
+         *    A logger that can be assigned to XMLHttpRequest.
+         *
+         * @private
+         */
+        #createUi5ConnectedXhrLogger () {
+            return ["error", "warning", "info", "debug"].reduce((oXhrLogger, sLevel) => {
+                oXhrLogger[sLevel] = function (sMsg) {
+                    return Log[sLevel](sMsg);
+                };
+                return oXhrLogger;
+            }, {});
+        }
+
+        /**
+         * Initializes the ignore list of the XHR logon manager.
+         * <p>
+         * If the UI5 resources (including the own bootstrap script) are loaded from an absolute URL
+         * (in case CDN is activated),
+         * this URL is added to the ignore list to prevent CORS preflight requests due to the X headers.
+         * We expect that all resources can be loaded without authentication in this case.
+         *
+         * @param {object} oXHRLogonManager
+         *     the logon frame manager instance to use
+         *
+         * @private
+         */
+        #initXhrLogonIgnoreList (oXHRLogonManager) {
+            const sOrigin = this.getLocationOrigin();
+            const sUi5ResourceRootUrl = sap.ui.require.toUrl("");
+
+            // add "/" to origin, as otherwise the following use case will match:
+            //      sUi5ResourceRootUrl: http://sap.com:123
+            //      sOrigin:             http://sap.com
+            if (sUi5ResourceRootUrl && sUi5ResourceRootUrl.indexOf(`${sOrigin}/`) === -1) {
+                // In case UI5 is loaded from a different domain (CDN / AKAMAI), that URL
+                // needs to be ignored for the XHR logon, as we expect that the resources
+                // are not protected.
+                oXHRLogonManager.ignore.add(sUi5ResourceRootUrl);
+            }
+        }
+
+        /**
+         * We expose a factory method for the tests and allow to pass a test double for the window object
+         *
+         * @param {object} oWindow the window object
+         * @param {string} sXhrLogonMode logon mode
+         * @returns {XhrLogonEventHandler} a new XhrLogonEventHandler
+         *
+         * @private
+         */
+        createXhrLogonEventHandler (oWindow, sXhrLogonMode) {
+            return new XhrLogonEventHandler(oWindow, sXhrLogonMode);
+        }
+
+        getWindowLocationSearch () {
+            return window.location.search;
+        }
+
+        getLocationOrigin () {
+            return window.location.origin;
+        }
+    }
+
+    return new InitXhrLogon();
+});

package/src/main/js/sap/ushell_abap/bootstrap/LoadLaunchpad/RequestPages.js

@@ -0,0 +1,86 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+sap.ui.define([
+    "sap/base/util/ObjectPath",
+    "sap/ushell/bootstrap/Config",
+    "sap/ushell/Container",
+    "sap/ushell/components/pages/controller/PagesAndSpaceId",
+    "sap/ushell/resources"
+], (
+    ObjectPath,
+    BootstrapConfig,
+    Container,
+    PagesAndSpaceId,
+    ushellResources
+) => {
+    "use strict";
+
+    class RequestPages {
+        #aInternTargets = [
+            "Shell-home",
+            "Launchpad-openFLPPage"
+        ];
+
+        #isRelevant () {
+            const oUshellConfig = BootstrapConfig.get();
+            if (!ObjectPath.get("ushell.spaces.enabled", oUshellConfig)) {
+                return false;
+            }
+
+            let sHash = this.getLocationHash();
+            sHash = sHash.startsWith("#") ? sHash.slice(1) : sHash;
+
+            return !sHash || this.#aInternTargets.some((sTarget) => sHash.startsWith(sTarget));
+        }
+
+        async run () {
+            if (!this.#isRelevant()) {
+                return;
+            }
+
+            await Promise.all([
+                this.#requestPagesPersonalization(),
+                this.#requestPagesContent()
+            ]);
+        }
+
+        async #requestPagesPersonalization () {
+            const PersonalizationV2 = await Container.getServiceAsync("PersonalizationV2");
+            const oPersId = {
+                container: "sap.ushell.cdm3-1.personalization",
+                item: "data"
+            };
+
+            const oScope = {
+                validity: "Infinity",
+                keyCategory: PersonalizationV2.KeyCategory.GENERATED_KEY,
+                writeFrequency: PersonalizationV2.WriteFrequency.HIGH,
+                clientStorageAllowed: false
+            };
+            const oPersonalizer = await PersonalizationV2.getPersonalizer(oPersId, oScope);
+            return oPersonalizer.getPersData();
+        }
+
+        async #requestPagesContent () {
+            await ushellResources.awaitResourceBundle();
+
+            const pId = PagesAndSpaceId.getPageAndSpaceId(this.getLocationHash());
+            const pPagePersistenceService = Container.getServiceAsync("PagePersistence");
+
+            const [
+                oIds,
+                PagePersistence
+            ] = await Promise.all([
+                pId,
+                pPagePersistenceService
+            ]);
+
+            await PagePersistence.getPage(oIds.pageId);
+        }
+
+        getLocationHash () {
+            return window.location.hash;
+        }
+    }
+
+    return new RequestPages();
+});