@sapui5/sap.ushell_abap 1.153.0 → 1.154.0

package/src/main/js/sap/ushell_abap/components/tiles/applauncherdynamic/DynamicTile.view.js

@@ -0,0 +1,106 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * This copy of the DynamicTile.view is needed for compatibility reasons until the changes to applauncher_dynamic.chip.xml have been delivered.
+ * Afterwards this file can be used in all scenarios and DynamicTile.view.js can be replaced by it.
+ */
+sap.ui.define([
+    "sap/ui/core/mvc/View",
+    "sap/m/GenericTile",
+    "sap/m/TileContent",
+    "sap/m/library",
+    "sap/m/NumericContent",
+    "sap/ushell_abap/components/tiles/applauncherdynamic/DynamicTile.controller" // Controller needs to be loaded
+], (
+    View,
+    GenericTile,
+    TileContent,
+    mobileLibrary,
+    NumericContent
+) => {
+    "use strict";
+
+    // shortcut for sap.m.ValueColor
+    const ValueColor = mobileLibrary.ValueColor;
+
+    return View.extend("sap.ushell_abap.components.tiles.applauncherdynamic.DynamicTile", {
+        getControllerName: function () {
+            return "sap.ushell_abap.components.tiles.applauncherdynamic.DynamicTile";
+        },
+
+        createContent: function () {
+            this.setHeight("100%");
+            this.setWidth("100%");
+
+            return this.getTileControl();
+        },
+
+        getTileControl: function () {
+            const oController = this.getController();
+
+            // Return the GenericTile if it already exists instead of creating a new one
+            if (this.getContent().length === 1) {
+                return this.getContent()[0];
+            }
+
+            return new GenericTile({
+                mode: "{/mode}",
+                frameType: "{/frameType}",
+                header: "{/data/display_title_text}",
+                subheader: "{/data/display_subtitle_text}",
+                sizeBehavior: "{/sizeBehavior}",
+                wrappingType: "{/wrappingType}",
+                appShortcut: "{/config/display_transaction_code_effective}",
+                url: {
+                    parts: ["/targetURL", "/nav/navigation_target_url"],
+                    formatter: oController.formatters.leanURL
+                },
+                tileContent: [new TileContent({
+                    footer: "{/data/display_info_text}",
+                    footerColor: {
+                        path: "/data/display_info_state",
+                        formatter: function (sFooterColor) {
+                            if (sFooterColor === "Positive") {
+                                sFooterColor = ValueColor.Good;
+                            }
+                            if (sFooterColor === "Negative") {
+                                sFooterColor = ValueColor.Error;
+                            }
+
+                            if (!ValueColor[sFooterColor]) {
+                                sFooterColor = ValueColor.Neutral;
+                            }
+
+                            return sFooterColor;
+                        }
+                    },
+                    unit: "{/data/display_number_unit}",
+                    // We'll utilize NumericContent for the "Dynamic" content.
+                    content: [new NumericContent({
+                        scale: "{/data/display_number_factor}",
+                        value: "{/data/display_number_value}",
+                        truncateValueTo: 5, // Otherwise, The default value is 4.
+                        indicator: "{/data/display_state_arrow}",
+                        valueColor: {
+                            path: "/data/display_number_state",
+                            formatter: function (sState) {
+                                if (!sState || sState === "Neutral" || !ValueColor[sState]) {
+                                    return ValueColor.None;
+                                }
+                                return sState;
+                            }
+                        },
+                        icon: "{/data/display_icon_url}",
+                        width: "100%",
+                        withMargin: false
+                    })]
+                })],
+                press: [oController.onPress, oController]
+            });
+        },
+
+        getMode: function () {
+            return this.getModel().getProperty("/mode");
+        }
+    });
+});

package/src/main/js/sap/ushell_abap/library.js

@@ -13,6 +13,13 @@ sap.ui.define([
 ) => {
     "use strict";
 
+    /**
+     * @namespace sap.ushell_abap.api
+     * @since 1.154.0
+     * @private
+     * @ui5-restricted
+     */
+
     /**
      * @namespace sap.ushell_abap.components
      * @since 1.121.0
@@ -32,11 +39,15 @@ sap.ui.define([
     const ushellAbapLib = Library.init({
         name: "sap.ushell_abap",
         apiVersion: 2,
-        version: "1.153.0",
+        version: "1.154.0",
         dependencies: [
             "sap.ui.core",
             "sap.m",
             "sap.ushell"
+        ],
+        controls: [
+            "sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbap",
+            "sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbapLink"
         ]
     });
 

package/src/main/js/sap/ushell_abap/messagebundle.properties

@@ -1,9 +1,11 @@
-#This is the resource bundle for the sap.ushell_abap library
-#__ldi.translation.uuid=865e4af1-8cca-465c-8b85-97f19b98ef6a
+# Resource bundle for the "sap.ushell_abap" library
+# __ldi.translation.uuid=865e4af1-8cca-465c-8b85-97f19b98ef6a
 
 #XBUT: Close button for the SAML authentication dialog
 samlCloseBtn=Close
+
 #XTIT: Title of the SAML authentication dialog
 samlDialogTitle=Authentication Information
-#XFLD: Placeholder text shown on a tile when the transaction code has not been configured
+
+#XTXT: Fallback text shown on tiles without transaction code
 tileTransactionCodeNotMaintained=No Transaction

package/src/main/js/sap/ushell_abap/pbServices/ui2/Chip.js

@@ -544,9 +544,13 @@ sap.ui.define([
             };
             const oImplementation = oDefinition.implementation.sapui5;
 
-            // In case the chip is used in FLP wave 2 or later context we load it from the standard path
-            const sBaseChipId = this.getBaseChipId();
-            if ((sBaseChipId !== "X-SAP-UI2-CHIP:/UI2/STATIC_APPLAUNCHER") && (sBaseChipId !== "X-SAP-UI2-CHIP:/UI2/DYNAMIC_APPLAUNCHER")) {
+            const sBaseChipId = this.getBaseChipId() || this.getId(); // base chip id might be empty fallback to actual id
+            const bIsStandardChip = [
+                "X-SAP-UI2-CHIP:/UI2/STATIC_APPLAUNCHER",
+                "X-SAP-UI2-CHIP:/UI2/DYNAMIC_APPLAUNCHER"
+            ].includes(sBaseChipId);
+
+            if (!bIsStandardChip) {
                 if (oImplementation.$VirtualNamespace) {
                     oImplementation.$absolutePath = this.toAbsoluteUrl(oImplementation.basePath);
                     sap.ui.loader.config({ paths: JSON.parse(`{"${oImplementation.$Namespace.replace(/\./g, "/")}":"${oImplementation.$absolutePath}"}`) });

package/src/main/js/sap/ushell_abap/pbServices/ui2/ODataWrapper.js

@@ -758,7 +758,7 @@ sap.ui.define([
          *   cannot be parsed or is not returned in the OData error response.<br />
          *
          *   <b>NOTE:</b> the second parameter is returned since version 1.28.6.
-         * @param {object} [oDeferred] Deferred object from Promise.withResolvers
+         * @param {PromiseWithResolvers<any>} [oDeferred] Deferred object from Promise.withResolvers
          * @param {object} oError
          *   error object provided by datajs, should contain the response
          *

package/src/main/js/sap/ushell_abap/pbServices/ui2/contracts/configuration.js

@@ -91,10 +91,14 @@ sap.ui.define([
             // The FLP directly changes the configuration data of the bookmark tile and can notify the bookmark
             // tiles afterwards about the changes, so the bookmark tiles can update themselves with the new data.
             if (typeof fnHandler !== "function") {
-                throw new SrvcError("The given handler is not a function",
-                    "chip.configuration");
+                throw new SrvcError("The given handler is not a function", "chip.configuration");
             }
             fnUpdatedHandler = fnHandler;
+
+            // additionally attach to changes on the display transaction code setting
+            UserPersonalization.attachDisplayTransactionCodeChanged(() => {
+                fnHandler(["tileConfiguration"]);
+            });
         };
 
         /**

package/src/main/js/sap/ushell_abap/services/NavigationDataProvider.js

@@ -9,7 +9,7 @@
  *
  * Configured with the ClientSideTargetResolutionAdapter.
  *
- * @version 1.153.0
+ * @version 1.154.0
  */
 sap.ui.define([
     "sap/ui/core/Lib",

package/src/main/js/sap/ushell_abap/ui/VisualizationInstantiation/ChipInstanceWrapper.js

@@ -0,0 +1,248 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileOverview Helper class wrapping a CHIP instance for use inside a VizInstance.
+ * @version 1.154.0
+ */
+sap.ui.define([
+    "sap/base/Log",
+    "sap/m/library",
+    "sap/ushell/Container",
+    "sap/ushell/library",
+    "sap/ushell/utils/chipsUtils"
+], (
+    Log,
+    mobileLibrary,
+    Container,
+    ushellLibrary,
+    chipsUtils
+) => {
+    "use strict";
+
+    // shortcut for sap.m.LoadState
+    const LoadState = mobileLibrary.LoadState;
+
+    // shortcut for sap.ushell.DisplayFormat
+    const DisplayFormat = ushellLibrary.DisplayFormat;
+
+    /**
+     * @alias sap.ushell_abap.ui.VisualizationInstantiation.ChipInstanceWrapper
+     * @class
+     * @classdesc Helper class to manage the lifecycle of a CHIP instance inside a VizInstance.
+     * Coordinates chip creation, loading, visibility, and type detection.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    class ChipInstanceWrapper {
+        #oLoadDeferred = Promise.withResolvers();
+        #oChipInstanceDeferred = Promise.withResolvers();
+        #oChipInstance;
+        #oInstantiationData;
+        #oTargetControl;
+        #bInitialized = false;
+
+        /**
+         * @param {sap.ushell.ui.launchpad.VizInstanceBase} oTargetControl The VizInstance that owns this wrapper.
+         */
+        constructor (oTargetControl) {
+            this.#oTargetControl = oTargetControl;
+        }
+
+        /**
+         * Initializes the CHIP instance from the provided instantiation data.
+         * No-op if called more than once.
+         *
+         * @param {object} oInstantiationData The instantiation data from the visualization.
+         * @returns {Promise<undefined>} Resolves when the CHIP instance is created.
+         * @since 1.154.0
+         * @private
+         */
+        async init (oInstantiationData) {
+            if (this.#bInitialized) {
+                return;
+            }
+
+            this.#oInstantiationData = oInstantiationData;
+            this.#bInitialized = true;
+
+            const PageBuilding = await Container.getServiceAsync("PageBuilding");
+            const oFactory = PageBuilding.getFactory();
+
+            let oRawChipInstanceData;
+            let oBags;
+
+            if (!this.#oInstantiationData.simplifiedChipFormat) {
+                oRawChipInstanceData = {
+                    chipId: this.#oInstantiationData?.chip?.id,
+                    chip: this.#oInstantiationData?.chip
+                };
+            } else {
+                const oSimplifiedChip = this.#oInstantiationData?.chip || {};
+                oBags = oSimplifiedChip?.bags;
+                oRawChipInstanceData = {
+                    chipId: oSimplifiedChip?.chipId,
+                    // string is expected
+                    configuration: oSimplifiedChip?.configuration ? JSON.stringify(oSimplifiedChip?.configuration) : "{}"
+                };
+            }
+
+            const oChipInstance = oFactory.createChipInstance(oRawChipInstanceData);
+
+            chipsUtils.addBagDataToChipInstance(oChipInstance, oBags);
+            this.#oChipInstanceDeferred.resolve(oChipInstance);
+        }
+
+        /**
+         * A function which sets the content of the VizInstance to a UI5 view.
+         * @returns {Promise<undefined>} Resolves when the chip instance is loaded.
+         *
+         * @since 1.154.0
+         * @private
+         */
+        async load () {
+            try {
+                this.#oChipInstance = await this.#oChipInstanceDeferred.promise;
+                await new Promise(this.#oChipInstance.load);
+
+                if (this.#oTargetControl.getPreview()) {
+                    const oPreviewContract = this.#oChipInstance.getContract("preview");
+                    // the preview contract doesn't have to be implemented as it might just not be needed
+                    // e.g. for tiles that don't display any dynamic data anyway
+                    if (oPreviewContract) {
+                        oPreviewContract.setEnabled(true);
+                    }
+                }
+                // apply current visibility, default for chips is visible
+                // this might lead to instant requests when tileView is fetched
+                this.setVisible(this.#oTargetControl.getActive());
+
+                const oChipControl = await this.#oChipInstance.getImplementationAsSapui5Async();
+
+                this.#setChipInstanceType();
+                this.#oTargetControl.setContent?.(oChipControl);
+                // Fix parent relation for the component instance to make GridContainer DnD work
+                // BCP: 2170186464
+                if (oChipControl.getComponentInstance?.()) {
+                    oChipControl.getComponentInstance().setParent(this.#oTargetControl);
+                }
+
+                this.#oLoadDeferred.resolve();
+            } catch (oError) {
+                this.#oTargetControl.setState(LoadState.Failed);
+
+                this.#oLoadDeferred.reject(oError);
+            }
+
+            return this.loaded();
+        }
+
+        /**
+         * @returns {Promise<undefined>} Resolves when the chip instance has finished loading.
+         * @since 1.154.0
+         * @private
+         */
+        loaded () {
+            return this.#oLoadDeferred.promise;
+        }
+
+        /**
+         * Returns the transaction code from the inner CHIP instance
+         * Requires {@link #load} to be called first.
+         *
+         * @returns {Promise<string>} Resolves the transaction code to display.
+         *
+         * @since 1.154.0
+         * @private
+         */
+        async getTransactionCode () {
+            await this.#oLoadDeferred.promise;
+
+            return chipsUtils.getCatalogTileTransactionCode(this.#oChipInstance);
+        }
+
+        /**
+         * Sets the display format of the CHIP instance via the instance's types contract
+         *
+         * @since 1.154.0
+         */
+        #setChipInstanceType () {
+            const oTypesContract = this.#oChipInstance.getContract("types");
+            if (oTypesContract) {
+                oTypesContract.setType(this.#mapDisplayFormatToChip(this.#oTargetControl.getDisplayFormat()));
+            }
+        }
+
+        /**
+         * Maps the display format to the CHIP type
+         *
+         * @param {DisplayFormat} sDisplayFormat The display format to be mapped
+         * @returns {string} The appropriate type
+         * @since 1.154.0
+         */
+        #mapDisplayFormatToChip (sDisplayFormat) {
+            const oDisplayFormatMapping = {};
+
+            oDisplayFormatMapping[DisplayFormat.Standard] = "tile";
+            oDisplayFormatMapping[DisplayFormat.StandardWide] = "tile";
+            const oTypesContract = this.#oChipInstance && !this.#oChipInstance.isStub() && this.#oChipInstance.getContract("types");
+            if (oTypesContract && oTypesContract.getAvailableTypes().includes("tilewide")) {
+                oDisplayFormatMapping[DisplayFormat.StandardWide] = "tilewide";
+            }
+            oDisplayFormatMapping[DisplayFormat.Compact] = "link";
+            oDisplayFormatMapping[DisplayFormat.Flat] = "flat";
+            oDisplayFormatMapping[DisplayFormat.FlatWide] = "flatwide";
+
+            return oDisplayFormatMapping[sDisplayFormat];
+        }
+
+        /**
+         * Updates the chip instance's visibility if the contract is active.
+         *
+         * @param {boolean} visible The visibility state to be set
+         * @since 1.154.0
+         */
+        setVisible (visible) {
+            const oVisibleContract = this.#oChipInstance && !this.#oChipInstance.isStub() && this.#oChipInstance.getContract("visible");
+
+            if (oVisibleContract) {
+                oVisibleContract.setVisible(visible);
+            }
+        }
+
+        /**
+         * Refreshes the chip instance's data
+         *
+         * @since 1.154.0
+         */
+        refresh () {
+            // The CHIP instance is only available after the VizInstance was loaded
+            if (this.#oChipInstance) {
+                // The refresh handler is provided directly on the CHIP instance and not as contract
+                this.#oChipInstance.refresh();
+            }
+        }
+
+        /**
+         * Returns whether the VizInstance is a standard tile type.
+         * @returns {boolean} Whether the VizInstance is standard.
+         *
+         * @since 1.154.0
+         * @private
+         */
+        isStandardType () {
+            // check whether the chip instance is a standard tile or a custom tile based on the base chip ID.
+            // simplified format -> chip.chipId, non-simplified (raw) format -> chip.baseChipId
+            if (!this.#oInstantiationData?.chip) {
+                Log.warning("VizInstanceAbap: No instantiation data available to determine whether the VizInstance is a standard tile or a custom tile.");
+                return false;
+            }
+            const sBaseChipId = this.#oInstantiationData.simplifiedChipFormat
+                ? this.#oInstantiationData.chip.chipId
+                : this.#oInstantiationData.chip.baseChipId;
+            return chipsUtils.isStandardTile(sBaseChipId);
+        }
+    }
+
+    return ChipInstanceWrapper;
+});

package/src/main/js/sap/ushell_abap/ui/VisualizationInstantiation/VizInstanceAbap.js

@@ -0,0 +1,134 @@
+// Copyright (c) 2009-2026 SAP SE, All Rights Reserved
+
+/**
+ * @fileOverview VizInstance implementation for the ABAP platform, backed by a CHIP instance.
+ * @version 1.154.0
+ */
+sap.ui.define([
+    "sap/ushell/ui/launchpad/VizInstance",
+    "sap/ushell_abap/ui/VisualizationInstantiation/ChipInstanceWrapper"
+], (
+    VizInstance,
+    ChipInstanceWrapper
+) => {
+    "use strict";
+
+    /**
+     * @alias sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbap
+     * @class
+     * @classdesc VizInstance for visualizations sourced from the ABAP platform.
+     * Delegates rendering and data loading to a {@link sap.ushell_abap.ui.VisualizationInstantiation.ChipInstanceWrapper}.
+     *
+     * @extends sap.ushell.ui.launchpad.VizInstance
+     *
+     * @since 1.77
+     * @private
+     */
+    const VizInstanceAbap = VizInstance.extend("sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbap", /** @lends sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbap.prototype */ {
+        metadata: {
+            library: "sap.ushell_abap"
+        },
+        renderer: VizInstance.getMetadata().getRenderer()
+    });
+
+    /**
+     * @override
+     * @since 1.77
+     * @private
+     */
+    VizInstanceAbap.prototype.init = function () {
+        VizInstance.prototype.init.apply(this, arguments);
+
+        this._oChipInstanceWrapper = new ChipInstanceWrapper(this);
+    };
+
+    /**
+     * Initializes the underlying CHIP instance with the provided instantiation data.
+     *
+     * @param {object} oInstantiationData The instantiation data for the CHIP.
+     * @returns {sap.ushell_abap.ui.VisualizationInstantiation.VizInstanceAbap} This instance, for chaining.
+     * @override
+     * @since 1.77
+     * @private
+     */
+    VizInstanceAbap.prototype.setInstantiationData = function (oInstantiationData) {
+        this._oChipInstanceWrapper.init(oInstantiationData);
+        this.setProperty("instantiationData", oInstantiationData);
+        return this;
+    };
+
+    /**
+     * A function which sets the content of the VizInstance to a UI5 view.
+     * @param {boolean} [isCustom] Whether this VizInstance is a standard tile or custom.
+     * @returns {Promise<undefined>} Resolves when the chip instance is loaded.
+     * @override
+     * @since 1.77
+     */
+    VizInstanceAbap.prototype.load = function (isCustom) {
+        return this._oChipInstanceWrapper.load();
+    };
+
+    /**
+     * @returns {Promise<undefined>} Resolves when the chip instance has finished loading.
+     * @override
+     * @since 1.77
+     * @private
+     */
+    VizInstanceAbap.prototype.loaded = function () {
+        return this._oChipInstanceWrapper.loaded();
+    };
+
+    /**
+     * Returns the transaction code from the inner CHIP instance
+     * Requires {@link #load} to be called first.
+     *
+     * @returns {Promise<string>} Resolves the transaction code to display.
+     *
+     * @since 1.154.0
+     * @private
+     */
+    VizInstanceAbap.prototype.getTransactionCode = async function () {
+        return this._oChipInstanceWrapper.getTransactionCode();
+    };
+
+    /**
+     * Refreshes the chip instance's data
+     *
+     * @since 1.78
+     */
+    VizInstanceAbap.prototype.refresh = function () {
+        this._oChipInstanceWrapper.refresh();
+    };
+
+    /**
+     * Updates the visualization's active state.
+     * E.g. inactive dynamic tiles do not send requests
+     *
+     * @param {boolean} active The visualization's active state
+     * @param {boolean} refresh Refresh the visualization immediately
+     * @returns {object} The VizInstance
+     * @since 1.78
+     */
+    VizInstanceAbap.prototype.setActive = function (active, refresh) {
+        this._oChipInstanceWrapper.setVisible(active);
+
+        if (refresh) {
+            this.refresh();
+        }
+
+        return this.setProperty("active", active, false);
+    };
+
+    /**
+     * Returns whether the VizInstance is a standard tile type.
+     * @returns {boolean} Whether the VizInstance is standard.
+     * @override
+     * @since 1.153
+     * @private
+     */
+    VizInstanceAbap.prototype.isStandardType = function () {
+        return this._oChipInstanceWrapper.isStandardType();
+    };
+
+    return VizInstanceAbap;
+});