@sapui5/sap.suite.ui.generic.template 1.129.0 → 1.130.1

package/src/sap/suite/ui/generic/template/designtime/controls/SmartTable.designtime.js

@@ -0,0 +1,379 @@
+/*!
+* SAP UI development toolkit for HTML5 (SAPUI5)
+
+		(c) Copyright 2009-2015 SAP SE. All rights reserved
+	
+*/
+sap.ui.define([
+	"sap/base/util/deepClone",
+	"sap/base/util/merge",
+	"sap/suite/ui/generic/template/designtime/utils/designtimeUtils",
+	"sap/suite/ui/generic/template/genericUtilities/testableHelper"
+],
+	function (deepClone, merge, designtimeUtils, testableHelper) {
+		"use strict";
+
+		const sObjectPageComponentName = "sap.suite.ui.generic.template.ObjectPage";
+		const { SettingScope } = designtimeUtils;
+
+		/**
+		 * @typedef {Object} DesigntimeSetting
+		 * @property {string} id - The ID of the designtime setting.
+		 * @property {string} name - The name of the designtime setting.
+		 * @property {string} description - The description of the designtime setting.
+		 * @property {PropertyValue} value - The default value of the designtime setting.
+		 * @property {string} type - The type of the designtime setting.
+		 * @property {Array.<Enum>=} enums - The array of possible enum values for the designtime setting.
+		 * @property {(mSmartTableDetails: SmartTableInfo) => string=} getPath - The path to the designtime setting in the manifest.
+		 * @property {boolean=} bSupportsGlobalScope - Indicates if the setting supports global scope. (Default: false)
+		 * @property {string[]=} restrictedTo - The array of components for which the setting is restricted.
+		 */
+
+		/**
+		 * @typedef {Object} ChangeParameters - Descriptor change parameters.
+		 * @property {string=} sScope - The scope of the manifest setting.
+		 * @property {string=} sChangeType - Desciptor change type.
+		 */
+
+		/**
+		 * @typedef {Object} SmartTableInfo
+		 * @property {string} sParentComponentName - The name of the parent component.
+		 * @property {string} sSectionKey - The ID of the facet.
+		 * @property {string|null} sSelectedVariantKey - The selected tab key.
+		 * @extends ChangeParameters
+		 */
+
+		/**
+		 * @typedef {ChangeParameters & SmartTableInfo} SmartTableChangeParams
+		 */
+
+		/**
+		 * @typedef {string | boolean | string[] } PropertyValue
+		 */
+
+		/**
+		 * @typedef {Object} Enum
+		 * @property {string} id - The ID of the enum value.
+		 * @property {string} name - The name of the enum value.
+		 */
+
+		function getSelectedTabKey(oSmartTable) {
+			// traverse the parent until the control is IconTabBar
+			const sSmartTableLocalId = designtimeUtils.getLocalId(oSmartTable);
+			return sSmartTableLocalId.split("-")[1];
+		}
+
+		/**
+		 * Retrieves the variant info for the selected tab.
+		 *
+		 * @param {*} oComponent - The component.
+		 * @param {string} sSelectedTabKey - The selected tab key.
+		 * @returns {[string, *]} - The variant info for the selected tab.
+		 */
+		function getVariantInfo(oComponent, sSelectedTabKey) {
+			const oQuickVariantSelectionX = oComponent.getQuickVariantSelectionX();
+			const oVariants = oQuickVariantSelectionX?.variants || {};
+			const aVariantInfo = Object.entries(oVariants).find(([_, oVariant]) => oVariant.key === sSelectedTabKey);
+			if (!aVariantInfo?.length) {
+				throw new Error("Error while retrieving the variant info for the selected tab");
+			}
+			return aVariantInfo;
+		}
+
+		function getManifestTableSettings(oSmartTable) {
+			const oComponent = designtimeUtils.getComponent(oSmartTable);
+			const oAppComponent = oComponent.getAppComponent();
+			const oSupportedGlobalTableSettings = designtimeUtils.getSupportedGlobalManifestSettings(oAppComponent)?.["tableSettings"] || {};
+
+			let oEffectiveTableSettings;
+			if (oComponent.getMetadata().getComponentName() === sObjectPageComponentName) {
+				const oSections = oComponent.getSections();
+				const sSectionKey = getSectionKey(oSmartTable);
+				const oSectionTableSettings = oSections?.[sSectionKey]?.tableSettings || {};
+				oEffectiveTableSettings = merge(oSupportedGlobalTableSettings, oSectionTableSettings);
+			} else {
+				const oComponentTableSettings = oComponent.getTableSettings() || {};
+				let oSelectedVariantTableSettings = {};
+				if (oComponent.getQuickVariantSelectionX?.()) {
+					const sSelectedTabKey = getSelectedTabKey(oSmartTable);
+					const aVariantInfo = getVariantInfo(oComponent, sSelectedTabKey);
+					const [, oVariant] = aVariantInfo;
+					oSelectedVariantTableSettings = oVariant.tableSettings || {};
+				}
+				oEffectiveTableSettings = merge(oSupportedGlobalTableSettings, oComponentTableSettings, oSelectedVariantTableSettings);
+			}
+			return oEffectiveTableSettings;
+		}
+
+		function getSectionKey(oSmartTable) {
+			const sSmartTableId = designtimeUtils.getLocalId(oSmartTable.getId());
+			// ID must not be of the inner table
+			return sSmartTableId.split("::Table")[0];
+		}
+
+		/**
+		 * Retrieves the adaptation properties for the SmartTable.
+		 *
+		 * Property values are retrieved from the manifest.
+		 *
+		 * @param {DesigntimeSetting[]} aDesigntimeSettings - The array of designtime settings.
+		 * @param {object} oTableSettings - The table settings from the manifest.
+		 * @returns {Object} - The adaptation properties for the SmartTable.
+		 */
+		function getRuntimeAdapationProperties(aDesigntimeSettings, oTableSettings) {
+			const mPropertyValues = {};
+			// Handle the multiple ways of defining the table type?
+			aDesigntimeSettings.forEach(oSetting => {
+				const sProperty = oSetting.id;
+				switch (sProperty) {
+					case "type":
+						mPropertyValues[sProperty] = oTableSettings.type || oSetting.value;
+						break;
+					case "multiSelect":
+						mPropertyValues[sProperty] = oTableSettings.multiSelect || oSetting.value;
+						break;
+					case "createMode":
+						mPropertyValues[sProperty] = oTableSettings.createMode || oSetting.value;
+						break;
+					case "selectAll":
+						mPropertyValues[sProperty] = oTableSettings.selectAll || oSetting.value;
+						break;
+					default:
+						break;
+				}
+			});
+			return mPropertyValues;
+		}
+
+		async function fnOpenTableConfigurationDialog(oSmartTable, mPropertyBag) {
+			const oComponent = designtimeUtils.getComponent(oSmartTable);
+			const sComponentName = oComponent.getMetadata().getComponentName();
+			// Get the allowed designtime settings for the SmartTable
+			const aAllowedDesigntimeSettings = getAllowedDesigntimeSettings(oSmartTable);
+
+			// Get the table settings from the manifest
+			const oTableSettings = getManifestTableSettings(oSmartTable);
+
+			// Get the current values of the properties
+			const mRuntimeAdaptationPropertyValues = getRuntimeAdapationProperties(aAllowedDesigntimeSettings, oTableSettings);
+			// Save the unchanged data to compare later
+			const mUnchangedData = deepClone(mRuntimeAdaptationPropertyValues);
+			// Get the settings of the dialog from the designtime settings using which the dialog will be created
+			const aItems = designtimeUtils.getSettings(mRuntimeAdaptationPropertyValues, aAllowedDesigntimeSettings);
+			// Add the scope of the changes
+			const oScopeControlData = {
+				type: "string",
+				"enum": [
+					{ id: SettingScope.Page, name: SettingScope.Page }
+				],
+				value: SettingScope.Page,
+				id: "scope",
+				disabled: false
+			};
+			const aChangeScopeOption = [
+				{
+					label: "Scope of the changes",
+					tooltip: "Scope of the changes",
+					control: [
+						oScopeControlData
+					]
+				}
+			];
+
+			// if the component has quickVariantSelectionX then add the control scope
+			const bHasQuickVariantSelectionX = oComponent.getQuickVariantSelectionX?.();
+			if (bHasQuickVariantSelectionX) {
+				oScopeControlData.enum.push({ id: SettingScope.Control, name: SettingScope.Control });
+			}
+
+			// if the allowed designtime settings contain a setting that supports global scope
+			// then add the global scope option
+			const bSupportsGlobalScope = aAllowedDesigntimeSettings.some(oSetting => oSetting.bSupportsGlobalScope);
+			if (bSupportsGlobalScope) {
+				oScopeControlData.enum.push({ id: SettingScope.Application, name: SettingScope.Application });
+			}
+			// disable the scope control if there is only one option
+			oScopeControlData.disabled = oScopeControlData.enum.length <= 1;
+
+			const mPropertyValuesEntered = await designtimeUtils.openAdaptionDialog([...aChangeScopeOption, ...aItems], mRuntimeAdaptationPropertyValues, mUnchangedData, "Change Table Configuration", { width: "650px", height: "800px" });
+
+			const sSelectedTabKey = getSelectedTabKey(oSmartTable);
+			const sSelectedVariantKey = sSelectedTabKey ? getVariantInfo(oComponent, sSelectedTabKey)[0] : null;
+
+			// if the scope is not set, set it to the default is "Page Scope"
+			mPropertyValuesEntered["scope"] = mPropertyValuesEntered["scope"] || SettingScope.Page;
+			mUnchangedData["scope"] = mUnchangedData["scope"] || SettingScope.Page;
+
+			/**
+			 * @type {SmartTableChangeParams}
+			 */
+			const mPathParameters = {
+				sChangeType: designtimeUtils.ChangeType.ChangePageConfiguration,
+				sParentComponentName: sComponentName,
+				// used in case of ObjectPage only
+				sSectionKey: sComponentName === sObjectPageComponentName ? getSectionKey(oSmartTable) : null,
+				// used in case of multiple views only
+				sSelectedVariantKey,
+				sScope: mPropertyValuesEntered["scope"]
+			};
+			return designtimeUtils.extractChanges(mPropertyValuesEntered, mUnchangedData, aAllowedDesigntimeSettings, oComponent, mPathParameters);
+
+		}
+
+		/**
+		 * Retrieves the path to the setting in the `tableSettings` section of the manifest.
+		 *
+		 * @param {string} sSettingId - The ID of the setting.
+		 * @param {boolean} bSupportsGlobalScope - Indicates if the setting supports global scope.
+		 * @returns {(mSmartTableInfo: SmartTableInfo) => string} - The path to the setting in the manifest.
+		 *
+		 * @example
+		 * // Example manifest structure
+		 * {
+		 *   "component": {
+		 *     "settings": {
+		 *       "sections": {
+		 *         "section1": {
+		 *           "tableSettings": {
+		 *             "type": "ResponsiveTable"
+		 *           }
+		 *         }
+		 *       }
+		 *     }
+		 *   }
+		 * }
+		 */
+
+		let getPathForTableSettings = function getPathForTableSettings(sSettingId, bSupportsGlobalScope = false) {
+			/**
+			 * @param {SmartTableChangeParams} mSmartTableInfo - The SmartTable details.
+			 * @returns {string} - The path to the setting in the manifest.
+			 */
+			return function (mSmartTableInfo) {
+				if (mSmartTableInfo.sParentComponentName === sObjectPageComponentName) {
+					return `component/settings/sections/${mSmartTableInfo.sSectionKey}/tableSettings/${sSettingId}`;
+				} else {
+					// Path defaults to page scope
+					let path = `component/settings/tableSettings/${sSettingId}`;
+					if (mSmartTableInfo.sScope === SettingScope.Application && bSupportsGlobalScope) {
+						path = `settings/tableSettings/${sSettingId}`;
+					}
+					if (mSmartTableInfo.sScope === SettingScope.Control && mSmartTableInfo.sSelectedVariantKey) {
+						path = `component/settings/quickVariantSelectionX/variants/${mSmartTableInfo.sSelectedVariantKey}/tableSettings/${sSettingId}`;
+					}
+					return path;
+				}
+			};
+		};
+
+		/**
+		 * Retrieves the designtime settings for the SmartTable.
+		 * @param {object} oSmartTable - The SmartTable object.
+		 * @returns {DesigntimeSetting[]} - The designtime settings for the SmartTable.
+		 */
+		let getAllowedDesigntimeSettings = function getAllowedDesigntimeSettings(oSmartTable) {
+			/**
+			 * @type {DesigntimeSetting}
+			 */
+			const tableType = {
+				id: "type",
+				name: "Table Type",
+				description: "Define which table type should be used",
+				value: "ResponsiveTable",
+				type: "string",
+				getPath: getPathForTableSettings("type"),
+				enums: [
+					{ id: "ResponsiveTable", name: "Responsive Table" },
+					{ id: "GridTable", name: "Grid Table" },
+					{ id: "TreeTable", name: "Tree Table" },
+					{ id: "AnalyticalTable", name: "Analytical Table" }
+				],
+				bSupportsGlobalScope: false
+			};
+
+			/**
+			 * @type {DesigntimeSetting}
+			 */
+			const multiSelect = {
+				id: "multiSelect",
+				name: "Multi Select",
+				description: "Define if the table should support multi selection",
+				value: false,
+				type: "boolean",
+				getPath: getPathForTableSettings("multiSelect"),
+				bSupportsGlobalScope: false
+			};
+
+			/**
+			 * @type {DesigntimeSetting}
+			 */
+			const selectAll = {
+				id: "selectAll",
+				name: "Select All",
+				description: "Define if the table should support select all",
+				value: false,
+				type: "boolean",
+				getPath: getPathForTableSettings("selectAll"),
+				bSupportsGlobalScope: false
+			};
+
+
+			/**
+			 * @type {DesigntimeSetting}
+			 */
+			const createMode = {
+				id: "createMode",
+				name: "Create Mode",
+				description: "Define the create mode",
+				value: "creationRows",
+				type: "string",
+				getPath: getPathForTableSettings("createMode", true),
+				enums: [
+					{ id: "creationRows", name: "creationRows" },
+					{ id: "NewPage", name: "NewPage" },
+					{ id: "Inline", name: "Inline" }
+				],
+				bSupportsGlobalScope: true,
+				restrictedTo: [sObjectPageComponentName]
+			};
+
+			const designtimeSettings = [
+				tableType,
+				multiSelect,
+				selectAll,
+				createMode
+			];
+			return designtimeSettings.filter(oSetting => {
+				const sComponentName = designtimeUtils.getComponent(oSmartTable).getMetadata().getComponentName();
+				return !oSetting.restrictedTo || oSetting.restrictedTo.includes(sComponentName);
+			});
+		};
+
+		// Expose the functions for QUnit tests
+		getAllowedDesigntimeSettings = testableHelper.testableStatic(getAllowedDesigntimeSettings, "getAllowedDesigntimeSettings");
+		getPathForTableSettings = testableHelper.testableStatic(getPathForTableSettings, "getPathForTableSettings");
+		testableHelper.testableStatic(getRuntimeAdapationProperties, "getRuntimeAdapationProperties");
+		testableHelper.testableStatic(getManifestTableSettings, "getManifestTableSettings");
+		testableHelper.testableStatic(getSelectedTabKey, "getSelectedTabKey");
+		testableHelper.testableStatic(getVariantInfo, "getVariantInfo");
+		testableHelper.testableStatic(fnOpenTableConfigurationDialog, "fnOpenTableConfigurationDialog");
+
+
+		const oHelper = {
+			getDesigntime: function (oSmartTable) {
+				return {
+					actions: {
+						settings: {
+							fe: {
+								name: "Configuration",
+								icon: "sap-icon://developer-settings",
+								handler: fnOpenTableConfigurationDialog
+							}
+						}
+					}
+				};
+			}
+		};
+		return oHelper;
+	}
+);

package/src/sap/suite/ui/generic/template/designtime/{AnalyticalListPage.designtime.js → floorplans/AnalyticalListPage.designtime.js}

@@ -119,9 +119,9 @@ sap.ui.define(["sap/suite/ui/generic/template/designtime/utils/designtimeHelper"
 		// - property changes are possible only in designtime adaptation
 		// - for any other changes (using change handlers), we anyway need to be prepared for the change if it is allowed in one mode, so it shouldn't matter if it's also possible in the other mode
 		return designtimeHelper.getRtaModeValue()
-			.then(function (bRtaModeValue) {
-				var mAllow = bRtaModeValue ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
-				return designtimeHelper.getViewDesignTime(mAllow);
+			.then(function (sRtaModeValue) {
+				var mAllow = sRtaModeValue === designtimeHelper.FioriToolsRtaMode.True ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
+				return designtimeHelper.getViewDesignTime(mAllow, sRtaModeValue);
 			});
 });
 		

package/src/sap/suite/ui/generic/template/designtime/{ListReport.designtime.js → floorplans/ListReport.designtime.js}

@@ -181,9 +181,9 @@ sap.ui.define(["sap/suite/ui/generic/template/designtime/utils/designtimeHelper"
 		// - property changes are possible only in designtime adaptation
 		// - for any other changes (using change handlers), we anyway need to be prepared for the change if it is allowed in one mode, so it shouldn't matter if it's also possible in the other mode
 		return designtimeHelper.getRtaModeValue()
-			.then(function (bRtaModeValue) {
-				var mAllow = bRtaModeValue ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
-				return designtimeHelper.getViewDesignTime(mAllow);
+			.then(function (sRtaModeValue) {
+				var mAllow = sRtaModeValue === designtimeHelper.FioriToolsRtaMode.True ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
+				return designtimeHelper.getViewDesignTime(mAllow, sRtaModeValue);
 			});
 });
 		

package/src/sap/suite/ui/generic/template/designtime/{ObjectPage.designtime.js → floorplans/ObjectPage.designtime.js}

@@ -266,9 +266,8 @@ sap.ui.define(["sap/suite/ui/generic/template/designtime/utils/designtimeHelper"
 		// - property changes are possible only in designtime adaptation
 		// - for any other changes (using change handlers), we anyway need to be prepared for the change if it is allowed in one mode, so it shouldn't matter if it's also possible in the other mode
 		return designtimeHelper.getRtaModeValue()
-			.then(function (bRtaModeValue) {
-				var mAllow = bRtaModeValue ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
-				return designtimeHelper.getViewDesignTime(mAllow);
+			.then(function (sRtaModeValue) {
+				var mAllow = sRtaModeValue === designtimeHelper.FioriToolsRtaMode.True ? mAllowVariantManagement : designtimeHelper.getMergedAllowList([mAllowLevel0, mGreyLevel0, mAllowKeyUser]);
+				return designtimeHelper.getViewDesignTime(mAllow, sRtaModeValue);
 			});
-});
-
+});