@sapui5/sap.ushell_abap 1.153.0 → 1.154.0

package/src/main/js/sap/ushell_abap/adapters/local/MenuAdapter.js

@@ -0,0 +1,92 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileOverview MenuAdapter for the local (abap) platform.
+ *
+ * Intended for OPA and standalone test scenarios.
+ *
+ * A thin subclass of the ABAP MenuAdapter that adds the metatag
+ * before calling the original adapter
+ *
+ * @version 1.154.0
+ */
+sap.ui.define([
+    "sap/base/util/LoaderExtensions",
+    "sap/ushell_abap/adapters/abap/MenuAdapter"
+], (
+    LoaderExtensions,
+    AbapMenuAdapter
+) => {
+    "use strict";
+
+    /**
+     * Constructs a new local instance of the MenuAdapter for the ABAP platform.
+     *
+     * @param {object} oSystem The system served by the adapter
+     * @param {string} sParameter Parameter string, not in use
+     * @param {object} oAdapterConfiguration Adapter configuration.
+     *
+     * @class
+     * @since 1.154.0
+     * @private
+     */
+    function MenuAdapter (oSystem, sParameter, oAdapterConfiguration) {
+        const oConfig = oAdapterConfiguration?.config || {};
+
+        const aData = this._fetchData(oConfig);
+        const oMetatag = document.createElement("meta");
+        oMetatag.content = JSON.stringify(aData);
+        oMetatag.setAttribute("name", "sap.ushell.assignedSpaces");
+        document.head.appendChild(oMetatag);
+
+        AbapMenuAdapter.call(this, oSystem, sParameter, {});
+    }
+
+    MenuAdapter.prototype = Object.create(AbapMenuAdapter.prototype);
+    MenuAdapter.prototype.constructor = MenuAdapter;
+
+    /**
+     * Loads spaces and pages from the configured JSON resources and assembles
+     * the space list structure expected by the base ABAP MenuAdapter.
+     *
+     * @param {object} oConfig Adapter config with <code>spacesPath</code> and <code>pagesPath</code>.
+     * @returns {object[]} Space entries including embedded page references.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    MenuAdapter.prototype._fetchData = function (oConfig) {
+        const aSpacesData = oConfig.spaces || LoaderExtensions.loadResource(oConfig.spacesPath);
+        const aPagesData = oConfig.pages || LoaderExtensions.loadResource(oConfig.pagesPath);
+
+        return aSpacesData.map((oSpaceData) => {
+            return {
+                id: oSpaceData.id || "",
+                title: oSpaceData.title || "",
+                description: oSpaceData.description || "",
+                hasWorkarea: oSpaceData.hasWorkarea || false,
+                visibility: {
+                    desktop: true,
+                    phone: true,
+                    tablet: true
+                },
+                pages: oSpaceData.pages.map((oPageReference) => {
+                    const oPageData = aPagesData.find((oPage) => oPage.id === oPageReference.id);
+                    return {
+                        type: oPageData ? "page" : "IBN",
+                        id: oPageReference.id,
+                        title: oPageData?.title || "",
+                        description: oPageData?.description || "",
+                        visibility: {
+                            desktop: true,
+                            phone: true,
+                            tablet: true
+                        }
+                    };
+                })
+            };
+        });
+    };
+
+    return MenuAdapter;
+});

package/src/main/js/sap/ushell_abap/adapters/local/PageBuildingAdapter.js

@@ -0,0 +1,242 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileOverview PageBuildingAdapter for the local (abap) platform.
+ *
+ * Intended for OPA and standalone test scenarios with no backend.
+ *
+ * @version 1.154.0
+ */
+sap.ui.define([
+    "sap/base/util/LoaderExtensions",
+    "sap/ui/core/util/MockServer",
+    "sap/ushell_abap/pbServices/ui2/Factory",
+    // Contracts need to be loaded first
+    "sap/ushell_abap/pbServices/ui2/contracts/bag",
+    "sap/ushell_abap/pbServices/ui2/contracts/configuration",
+    "sap/ushell_abap/pbServices/ui2/contracts/configurationUi",
+    "sap/ushell_abap/pbServices/ui2/contracts/fullscreen",
+    "sap/ushell_abap/pbServices/ui2/contracts/preview",
+    "sap/ushell_abap/pbServices/ui2/contracts/visible",
+    "sap/ushell_abap/pbServices/ui2/contracts/refresh",
+    "sap/ushell_abap/pbServices/ui2/contracts/search",
+    "sap/ushell_abap/pbServices/ui2/contracts/url",
+    "sap/ushell_abap/pbServices/ui2/contracts/actions",
+    "sap/ushell_abap/pbServices/ui2/contracts/types"
+], (
+    LoaderExtensions,
+    MockServer,
+    Factory
+) => {
+    "use strict";
+
+    /**
+     * Constructs a new local instance of the PageBuildingAdapter for the ABAP platform.
+     *
+     * @param {object} oSystem The system served by the adapter
+     * @param {string} sParameter Parameter string, not in use
+     * @param {object} [oAdapterConfiguration] The configuration.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    function PageBuildingAdapter (oSystem, sParameter, oAdapterConfiguration) {
+        // fetch sync to avoid race conditions
+        this._aBaseChips = oAdapterConfiguration.config.baseChips || LoaderExtensions.loadResource(oAdapterConfiguration.config.baseChipsPath);
+        this._aBaseChips.forEach((oBaseChip) => {
+            oBaseChip.chipPathAbsolute = new URL(sap.ui.require.toUrl(oBaseChip.chipPath), document.baseURI).toString();
+        });
+
+        this._aCatalogsData = oAdapterConfiguration.config.catalogs || LoaderExtensions.loadResource(oAdapterConfiguration.config.catalogsPath);
+        // patch service url to absolute
+        this._aCatalogsData.forEach((oCatalog) => {
+            oCatalog.chips.forEach((oChip) => {
+                const oTileConfiguration = oChip.configuration?.tileConfiguration;
+                if (oTileConfiguration?.service_url) {
+                    const aUrlParts = oTileConfiguration.service_url.split("?"); // query might contain non parsable UserDefault references
+                    const sAbsoluteUrl = new URL(sap.ui.require.toUrl(aUrlParts[0]), document.baseURI).toString();
+                    const sQuery = aUrlParts[1] ? `?${aUrlParts[1]}` : "";
+                    oTileConfiguration.service_url = `${sAbsoluteUrl}${sQuery}`;
+                }
+            });
+        });
+
+        const oServer = new MockServer({
+            rootUri: "/local/PageBuilding"
+        });
+        MockServer.config({
+            autoRespond: true,
+            autoRespondAfter: 0
+        });
+
+        oServer.setRequests([
+            ...this._getBaseChipRequests(),
+            ...this._getAllCatalogsRequests()
+        ]);
+        oServer.start();
+
+        this._oFactory = Factory.createFactory(
+            "/local/PageBuilding",
+            undefined,
+            "PERS",
+            undefined
+        );
+    }
+
+    /**
+     * Returns the UI2 page building factory.
+     *
+     * @returns {sap.ushell_abap.pbServices.ui2.Factory} The page building factory.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PageBuildingAdapter.prototype.getFactory = function () {
+        return this._oFactory;
+    };
+
+    /**
+     * Builds MockServer request handlers that serve individual chip descriptors
+     * from the in-memory base chip data.
+     *
+     * @returns {object[]} MockServer request configuration objects for base chip GET requests.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PageBuildingAdapter.prototype._getBaseChipRequests = function () {
+        return this._aBaseChips.map((oBaseChip) => {
+            return {
+                method: "GET",
+                path: new RegExp(`/Chips\\('${encodeURIComponent(`X-SAP-UI2-CHIP:${oBaseChip.id}`)}'\\).*`),
+                response: (oXhr) => {
+                    oXhr.respondJSON(200, {} /* Headers */, {
+                        d: {
+                            id: `X-SAP-UI2-CHIP:${oBaseChip.id}`,
+                            title: "",
+                            description: "",
+                            configuration: "",
+                            url: oBaseChip.chipPathAbsolute,
+                            baseChipId: `X-SAP-UI2-CHIP:${oBaseChip.id}`,
+                            catalogId: "/UI2/CATALOG_ALL",
+                            catalogPageChipInstanceId: "",
+                            referenceChipId: "",
+                            isReadOnly: "",
+                            Catalog: {},
+                            ReferenceChip: {},
+                            ChipBags: {
+                                results: []
+                            },
+                            CatalogPageChipInstance: {}
+                        }
+                    });
+                }
+            };
+        });
+    };
+
+    /**
+     * Builds a MockServer request handler that serves the <code>allCatalogs</code> OData response
+     * from the in-memory catalog data.
+     *
+     * @returns {object[]} MockServer request configuration object for the allCatalogs endpoint.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PageBuildingAdapter.prototype._getAllCatalogsRequests = function () {
+        return [{
+            method: "GET",
+            path: new RegExp("/Pages\\('.*'\\)/allCatalogs.*"),
+            response: (oXhr) => {
+                oXhr.respondJSON(200, {} /* Headers */, {
+                    d: {
+                        results: this._aCatalogsData.map((oCatalog) => {
+                            return {
+                                __metadata: {},
+                                id: `X-SAP-UI2-CATALOGPAGE:${oCatalog.id}`,
+                                type: "CATALOG_PAGE",
+                                domainId: oCatalog.id,
+                                remoteType: "",
+                                title: oCatalog.title,
+                                systemAlias: "",
+                                remoteId: "",
+                                isReadOnly: "",
+                                originalLanguage: "en",
+                                scope: "CUSTOMIZING",
+                                baseUrl: "",
+                                chipCount: oCatalog.chips.length.toString().padStart(4, "0"),
+                                outdated: "",
+                                CatalogPage: {},
+                                Chips: {
+                                    results: oCatalog.chips.map((oCatalogTile) => {
+                                        const oBaseChip = this._aBaseChips.find((oBaseChip) => oBaseChip.id === oCatalogTile.baseChipId);
+                                        if (!oBaseChip) {
+                                            throw new Error(`Missing Base Chip 'X-SAP-UI2-CHIP:${oCatalogTile.baseChipId}'`);
+                                        }
+
+                                        return {
+                                            __metadata: {},
+                                            id: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oCatalog.id}:${oCatalogTile.id}`,
+                                            catalogId: `X-SAP-UI2-CATALOGPAGE:${oCatalog.id}`,
+                                            catalogPageChipInstanceId: oCatalogTile.id,
+                                            baseChipId: `X-SAP-UI2-CHIP:${oCatalogTile.baseChipId}`,
+                                            url: oBaseChip.chipPathAbsolute,
+                                            referenceChipId: "",
+                                            isReadOnly: "",
+                                            title: "<non translatable title>",
+                                            description: "",
+                                            Catalog: {},
+                                            ReferenceChip: {},
+                                            configuration: JSON.stringify(Object.keys(oCatalogTile.configuration).reduce((oConfiguration, sConfigurationKey) => {
+                                                oConfiguration[sConfigurationKey] = JSON.stringify(oCatalogTile.configuration[sConfigurationKey]);
+                                                return oConfiguration;
+                                            }, {})),
+                                            ChipBags: {
+                                                results: Object.keys(oCatalogTile.bags).map((sBagId) => {
+                                                    const oBag = oCatalogTile.bags[sBagId];
+                                                    return {
+                                                        __metadata: {},
+                                                        chipId: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oCatalog.id}:${oCatalogTile.id}`,
+                                                        id: sBagId,
+                                                        ChipProperties: {
+                                                            results: [
+                                                                ...Object.keys(oBag.texts || {}).map((sBagTextKey) => {
+                                                                    return {
+                                                                        __metadata: {},
+                                                                        chipId: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oCatalog.id}:${oCatalogTile.id}`,
+                                                                        bagId: sBagId,
+                                                                        name: sBagTextKey,
+                                                                        value: oBag.texts[sBagTextKey],
+                                                                        translatable: "X"
+                                                                    };
+                                                                }),
+                                                                ...Object.keys(oBag.properties || {}).map((sBagPropertyKey) => {
+                                                                    return {
+                                                                        __metadata: {},
+                                                                        chipId: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oCatalog.id}:${oCatalogTile.id}`,
+                                                                        bagId: sBagId,
+                                                                        name: sBagPropertyKey,
+                                                                        value: oBag.properties[sBagPropertyKey],
+                                                                        translatable: ""
+                                                                    };
+                                                                })
+                                                            ]
+                                                        }
+                                                    };
+                                                })
+                                            },
+                                            CatalogPageChipInstance: {}
+                                        };
+                                    })
+                                }
+                            };
+                        })
+                    }
+                });
+            }
+        }];
+    };
+
+    return PageBuildingAdapter;
+});

package/src/main/js/sap/ushell_abap/adapters/local/PagePersistenceAdapter.js

@@ -0,0 +1,308 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileOverview PagePersistenceAdapter for the local (abap) platform.
+ *
+ * Intended for OPA and standalone test scenarios with no backend.
+ *
+ * A thin subclass of the ABAP PagePersistenceAdapter that overwrites the fetch from the backend.
+ *
+ * @version 1.154.0
+ */
+sap.ui.define([
+    "sap/base/util/LoaderExtensions",
+    "sap/ushell/library",
+    "sap/ushell_abap/adapters/abap/PagePersistenceAdapter"
+], (
+    LoaderExtensions,
+    ushellLibrary,
+    AbapPagePersistenceAdapter
+) => {
+    "use strict";
+
+    // shortcut for sap.ushell.DisplayFormat
+    const DisplayFormat = ushellLibrary.DisplayFormat;
+
+    /**
+     * Constructs a new local instance of the PagePersistenceAdapter for the ABAP platform.
+     *
+     * @param {object} oSystem The system information. This is not used in a local environment.
+     * @param {string} sParameter The Adapter parameter.
+     * @param {object} oAdapterConfiguration The Adapter configuration.
+     *
+     * @since 1.154.0
+     * @class
+     * @private
+     */
+    function PagePersistenceAdapter (oSystem, sParameter, oAdapterConfiguration) {
+        AbapPagePersistenceAdapter.call(this, oSystem, sParameter, {});
+
+        this._bEnableValidationErrors = !oAdapterConfiguration.config.ignoreValidationErrors;
+        this._pData = this._fetchData(oAdapterConfiguration.config);
+    }
+
+    PagePersistenceAdapter.prototype = Object.create(AbapPagePersistenceAdapter.prototype);
+    PagePersistenceAdapter.prototype.constructor = PagePersistenceAdapter;
+
+    /**
+     * Loads pages, catalogs, and base chip data from the configured JSON resources
+     * and transforms them into the OData-shaped structure the base adapter expects.
+     *
+     * @param {object} oConfig Adapter config with <code>pagesPath</code>, <code>catalogsPath</code>, and <code>baseChipsPath</code>.
+     * @returns {Promise<Object<string, object>>} Page data keyed by page ID.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PagePersistenceAdapter.prototype._fetchData = async function (oConfig) {
+        const [
+            aPagesData,
+            aCatalogsData,
+            aBaseChipData
+        ]
+        = await Promise.all([
+            oConfig.pages || LoaderExtensions.loadResource(oConfig.pagesPath, { async: true }),
+            oConfig.catalogs || LoaderExtensions.loadResource(oConfig.catalogsPath, { async: true }),
+            Promise.resolve(oConfig.baseChips || LoaderExtensions.loadResource(oConfig.baseChipsPath, { async: true })).then((aBaseChipData) => {
+                return Promise.all(aBaseChipData.map(async (oBaseChip) => {
+                    const oXml = await LoaderExtensions.loadResource(oBaseChip.chipPath, { async: true });
+
+                    const sDefaultType = oXml.querySelector("chip contracts consume[id=types] parameter[name=defaultType]")?.textContent;
+                    const sSupportedTypes = oXml.querySelector("chip contracts consume[id=types] parameter[name=supportedTypes]")?.textContent;
+                    const sCol = oXml.querySelector("chip contracts consume[id=configuration] parameter[name=col]")?.textContent;
+
+                    return {
+                        ...oBaseChip,
+                        defaultType: this._mapDisplayFormat(sDefaultType, sCol),
+                        supportedTypes: sSupportedTypes.split(",").map((sType) => {
+                            return this._mapDisplayFormat(sType, sCol);
+                        })
+                    };
+                }));
+            })
+        ]);
+
+        // patch service url to absolute
+        aCatalogsData.forEach((oCatalog) => {
+            oCatalog.chips.forEach((oChip) => {
+                const oTileConfiguration = oChip.configuration?.tileConfiguration;
+                if (oTileConfiguration?.service_url) {
+                    const aUrlParts = oTileConfiguration.service_url.split("?"); // query might contain non parsable UserDefault references
+                    const sAbsoluteUrl = new URL(sap.ui.require.toUrl(aUrlParts[0]), document.baseURI).toString();
+                    const sQuery = aUrlParts[1] ? `?${aUrlParts[1]}` : "";
+                    oTileConfiguration.service_url = `${sAbsoluteUrl}${sQuery}`;
+                }
+            });
+        });
+
+        return aPagesData.reduce((oPages, oPageToAdd) => {
+            if (this._bEnableValidationErrors && oPages[oPageToAdd.id]) {
+                throw new Error(`Conflicting page ids '${oPageToAdd.id}'`);
+            }
+
+            const aUsedCatalogTileIds = new Set();
+            const aUsedBaseChipIds = new Set();
+
+            oPages[oPageToAdd.id] = {
+                __metadata: {},
+                id: oPageToAdd.id,
+                title: oPageToAdd.title,
+                description: oPageToAdd.description,
+                sections: {
+                    results: oPageToAdd.sections.map((oSection, iSectionIndex) => {
+                        return {
+                            __metadata: {},
+                            id: oSection.id || `${oPageToAdd.id}-section_${iSectionIndex}`, // stable id for personalization
+                            title: oSection.title,
+                            sectionIndex: iSectionIndex + 1,
+                            viz: {
+                                results: oSection.viz.map((oVizRef, iVizRefIndex) => {
+                                    aUsedCatalogTileIds.add(oVizRef.catalogTileId);
+
+                                    return {
+                                        __metadata: {},
+                                        id: oVizRef.id || `${oPageToAdd.id}-section_${iSectionIndex}-viz_${iVizRefIndex}`, // stable id for personalization
+                                        catalogTileId: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oVizRef.catalogTileId}`,
+                                        catalogTileIdStable: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${oVizRef.catalogTileId}`,
+                                        targetMappingId: "",
+                                        targetMappingIdStable: "",
+                                        displayFormatHint: oVizRef.displayFormatHint,
+                                        itemIndex: iVizRefIndex + 1,
+                                        vizReference: {}
+                                    };
+                                })
+                            }
+                        };
+                    })
+                },
+                vizReferences: { // actually means visualizations/ catalogTiles
+                    results: Array.from(aUsedCatalogTileIds).map((sCatalogTileId) => {
+                        const [sCatalogId, sChipId] = sCatalogTileId.split(":");
+                        const oCatalogTile = aCatalogsData.find((oCatalog) => oCatalog.id === sCatalogId)?.chips.find((oChip) => oChip.id === sChipId);
+
+                        if (!oCatalogTile) {
+                            if (this._bEnableValidationErrors) {
+                                throw new Error(`Missing Catalog Tile 'X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${sCatalogTileId}'`);
+                            }
+                            return;
+                        }
+
+                        aUsedBaseChipIds.add(oCatalogTile.baseChipId);
+
+                        return {
+                            __metadata: {},
+                            id: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${sCatalogTileId}`,
+                            catalogDisplayId: `X-SAP-UI2-CATALOGPAGE:${sCatalogId}`,
+                            catalogTileId: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${sCatalogTileId}`,
+                            catalogTileIdStable: `X-SAP-UI2-PAGE:X-SAP-UI2-CATALOGPAGE:${sCatalogTileId}`,
+                            targetMappingId: "",
+                            targetMappingIdStable: "",
+                            title: oCatalogTile.bags?.tileProperties?.texts?.display_title_text,
+                            subTitle: oCatalogTile.bags?.tileProperties?.texts?.display_subtitle_text,
+                            iconUrl: oCatalogTile.configuration?.tileConfiguration?.display_icon_url,
+                            semanticObject: "",
+                            semanticAction: "",
+                            deviceDesktop: true,
+                            deviceTablet: true,
+                            devicePhone: true,
+                            tileType: `X-SAP-UI2-CHIP:${oCatalogTile.baseChipId}`,
+                            fromPersonalization: false,
+                            parameters: "",
+                            configuration: JSON.stringify(Object.keys(oCatalogTile.configuration || {}).reduce((oConfiguration, sConfigurationKey) => {
+                                oConfiguration[sConfigurationKey] = JSON.stringify(oCatalogTile.configuration[sConfigurationKey]);
+                                return oConfiguration;
+                            }, {})),
+                            chipBags: {
+                                results: Object.keys(oCatalogTile.bags || {}).map((sBagId) => {
+                                    const oBag = oCatalogTile.bags[sBagId];
+                                    return {
+                                        __metadata: {},
+                                        id: sBagId,
+                                        properties: {
+                                            results: [
+                                                ...Object.keys(oBag.texts || {}).map((sBagTextKey) => {
+                                                    return {
+                                                        __metadata: {},
+                                                        id: sBagTextKey,
+                                                        value: oBag.texts[sBagTextKey],
+                                                        translatable: true
+                                                    };
+                                                }),
+                                                ...Object.keys(oBag.properties || {}).map((sBagPropertyKey) => {
+                                                    return {
+                                                        __metadata: {},
+                                                        id: sBagPropertyKey,
+                                                        value: oBag.properties[sBagPropertyKey],
+                                                        translatable: false
+                                                    };
+                                                })
+                                            ]
+                                        }
+                                    };
+                                })
+                            }
+                        };
+                    }).filter((oVizReference) => !!oVizReference)
+                },
+                tileTypes: {
+                    results: Array.from(aUsedBaseChipIds).map((sBaseChipId) => {
+                        const oBaseChip = aBaseChipData.find((oChip) => oChip.id === sBaseChipId);
+                        if (!oBaseChip) {
+                            if (this._bEnableValidationErrors) {
+                                throw new Error(`Missing Base Chip 'X-SAP-UI2-CHIP:${sBaseChipId}'`);
+                            }
+                            return;
+                        }
+
+                        return {
+                            __metadata: {},
+                            id: `X-SAP-UI2-CHIP:${sBaseChipId}`,
+                            url: "",
+                            vizOptions: {
+                                __metadata: {},
+                                id: `X-SAP-UI2-CHIP:${sBaseChipId}`,
+                                displayFormats: {
+                                    __metadata: {},
+                                    preferred: oBaseChip.defaultType,
+                                    id: `X-SAP-UI2-CHIP:${sBaseChipId}`,
+                                    supported: {
+                                        results: oBaseChip.supportedTypes.map((sType) => {
+                                            return {
+                                                __metadata: {},
+                                                id: sType
+                                            };
+                                        })
+                                    }
+                                }
+                            }
+                        };
+                    }).filter((oTileType) => !!oTileType)
+                }
+            };
+
+            return oPages;
+        }, {});
+    };
+
+    /**
+     * Maps a chip-XML type string to the corresponding {@link sap.ushell.DisplayFormat} enum value,
+     * taking the column count into account.
+     *
+     * @param {string} sType Tile type from the chip XML (e.g. <code>"tile"</code>, <code>"link"</code>).
+     * @param {string} sCol Column count from the chip XML (<code>"1"</code> or <code>"2"</code>).
+     * @returns {sap.ushell.DisplayFormat} The mapped display format.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PagePersistenceAdapter.prototype._mapDisplayFormat = function (sType, sCol) {
+        const oDisplayFormatMap = {
+            tile: DisplayFormat.Standard,
+            link: DisplayFormat.Compact,
+            flat: DisplayFormat.Flat,
+            flatwide: DisplayFormat.FlatWide,
+            tilewide: DisplayFormat.StandardWide
+        };
+
+        let sDisplayFormat = oDisplayFormatMap[sType.toLowerCase()];
+
+        if (sCol === "2" && sDisplayFormat === DisplayFormat.Standard) {
+            sDisplayFormat = DisplayFormat.StandardWide;
+        }
+
+        return sDisplayFormat;
+    };
+
+    /**
+     * Returns the OData-shaped page object for the given page ID.
+     *
+     * @param {string} sPageId The page ID to retrieve.
+     * @returns {Promise<object>} The page data object.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PagePersistenceAdapter.prototype.readPage = async function (sPageId) {
+        const oData = await this._pData;
+        return oData[sPageId];
+    };
+
+    /**
+     * Returns OData-shaped page objects for the given page IDs.
+     *
+     * @param {string[]} aPageIds The page IDs to retrieve.
+     * @returns {Promise<{results: object[]}>} Object with a results array of page data objects.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    PagePersistenceAdapter.prototype.readPages = async function (aPageIds) {
+        return {
+            results: await Promise.all(aPageIds.map(async (sPageId) => {
+                return this.readPage(sPageId);
+            }))
+        };
+    };
+
+    return PagePersistenceAdapter;
+});