@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/converters/ConverterContext.ts

@@ -0,0 +1,460 @@
+import { AnnotationTerm } from "@sap-ux/vocabularies-types";
+import {
+	AnyAnnotation,
+	ConverterOutput,
+	EntitySet,
+	EntityType,
+	EntityContainer,
+	NavigationProperty,
+	ServiceObject,
+	Singleton,
+	ResolutionTarget,
+	ServiceObjectAndAnnotation
+} from "@sap-ux/annotation-converter";
+import { BaseManifestSettings, TemplateType } from "sap/fe/core/converters/ManifestSettings";
+import { Context, ODataMetaModel } from "sap/ui/model/odata/v4";
+import { convertTypes, ResolvedTarget } from "sap/fe/core/converters/MetaModelConverter";
+import { IDiagnostics } from "sap/fe/core/converters/TemplateConverter";
+import {
+	DataModelObjectPath,
+	enhanceDataModelPath,
+	getContextRelativeTargetObjectPath,
+	getTargetObjectPath
+} from "sap/fe/core/templating/DataModelPathHelper";
+import { EntityTypeAnnotations } from "@sap-ux/vocabularies-types/types/generated/Edm_Types";
+import ManifestWrapper from "sap/fe/core/converters/ManifestWrapper";
+
+export type ResolvedAnnotationContext = {
+	annotation: AnyAnnotation;
+	converterContext: ConverterContext;
+};
+
+/**
+ * Checks whether an object is an annotation term.
+ *
+ * @param {string|AnnotationTerm<object>} vAnnotationPath
+ * @returns {boolean}
+ */
+const isAnnotationTerm = function(vAnnotationPath: string | AnnotationTerm<any>): vAnnotationPath is AnnotationTerm<any> {
+	return typeof vAnnotationPath === "object";
+};
+
+function isServiceObject(objectPart: ServiceObjectAndAnnotation): objectPart is ServiceObject {
+	return objectPart && objectPart.hasOwnProperty("_type");
+}
+
+const getDataModelPathForEntitySet = function(resolvedMetaPath: ResolutionTarget<any>): DataModelObjectPath {
+	let rootEntitySet: EntitySet | undefined;
+	let currentEntitySet: EntitySet | undefined;
+	let previousEntitySet: EntitySet | undefined;
+	let currentEntityType: EntityType | undefined;
+	let navigatedPaths: string[] = [];
+	const navigationProperties: NavigationProperty[] = [];
+	resolvedMetaPath.objectPath.forEach((objectPart: ServiceObjectAndAnnotation) => {
+		if (isServiceObject(objectPart)) {
+			switch (objectPart._type) {
+				case "NavigationProperty":
+					navigatedPaths.push(objectPart.name);
+					navigationProperties.push(objectPart);
+					currentEntityType = objectPart.targetType;
+					if (previousEntitySet && previousEntitySet.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
+						currentEntitySet = previousEntitySet.navigationPropertyBinding[navigatedPaths.join("/")];
+						previousEntitySet = currentEntitySet;
+						navigatedPaths = [];
+					} else {
+						currentEntitySet = undefined;
+					}
+					break;
+				case "EntitySet":
+					if (rootEntitySet === undefined) {
+						rootEntitySet = objectPart;
+					}
+					currentEntitySet = objectPart;
+					previousEntitySet = currentEntitySet;
+					currentEntityType = currentEntitySet?.entityType;
+					break;
+				default:
+					break;
+			}
+		}
+	});
+	const dataModelPath: DataModelObjectPath = {
+		startingEntitySet: rootEntitySet as EntitySet,
+		targetEntityType: currentEntityType as EntityType,
+		targetEntitySet: currentEntitySet,
+		navigationProperties: navigationProperties,
+		contextLocation: undefined,
+		targetObject: resolvedMetaPath.target
+	};
+	dataModelPath.contextLocation = dataModelPath;
+	return dataModelPath;
+};
+
+/**
+ * Create a ConverterContext object that will be used within the converters.
+ *
+ * @param {ConverterOutput} oConvertedTypes The converted annotation and service types
+ * @param {BaseManifestSettings} oManifestSettings The manifestSettings that applies to this page
+ * @param {TemplateType} templateType The type of template we're looking at right now
+ * @param {IShellServicesProxy} shellServices The current instance of the shellservice
+ * @param {IDiagnostics} diagnostics The diagnostics shim
+ * @param {Function} mergeFn The function to be used to perfom some deep merges between object
+ * @param {DataModelObjectPath} targetDataModelPath The global path to reach the entitySet
+ *
+ * @returns {ConverterContext} A converter context for the converters
+ */
+class ConverterContext {
+	private manifestWrapper: ManifestWrapper;
+	private baseContextPath: string;
+
+	constructor(
+		private convertedTypes: ConverterOutput,
+		private manifestSettings: BaseManifestSettings,
+		private diagnostics: IDiagnostics,
+		private mergeFn: Function,
+		private targetDataModelPath: DataModelObjectPath
+	) {
+		this.manifestWrapper = new ManifestWrapper(this.manifestSettings, mergeFn);
+		this.baseContextPath = getTargetObjectPath(this.targetDataModelPath);
+	}
+
+	/**
+	 * Retrieve the property based on the path.
+	 *
+	 * @param fullyQualifiedName The fully qualified name
+	 * @returns {Property} The property EntityType based
+	 */
+	private _getEntityTypeFromFullyQualifiedName(fullyQualifiedName: string): EntityType | undefined {
+		const targetEntityType = this.convertedTypes.entityTypes.find(entityType => {
+			if (fullyQualifiedName.startsWith(entityType.fullyQualifiedName)) {
+				const replaceAnnotation = fullyQualifiedName.replace(entityType.fullyQualifiedName, "");
+				return replaceAnnotation.startsWith("/") || replaceAnnotation.startsWith("@");
+			}
+			return false;
+		});
+		return targetEntityType;
+	}
+
+	/**
+	 * Retrieve the entityType associated with an annotation object.
+	 *
+	 * @param annotation The annotation object for which we want to find the entityType
+	 * @returns {EntityType} The EntityType the annotation refers to
+	 */
+	getAnnotationEntityType(annotation?: AnnotationTerm<any>): EntityType {
+		if (annotation) {
+			const annotationPath = annotation.fullyQualifiedName;
+			const targetEntityType = this._getEntityTypeFromFullyQualifiedName(annotationPath);
+			if (!targetEntityType) {
+				throw new Error("Cannot find Entity Type for " + annotation.fullyQualifiedName);
+			}
+			return targetEntityType;
+		} else {
+			return this.targetDataModelPath.targetEntityType;
+		}
+	}
+
+	/**
+	 * Retrieve the manifest settings defined for a specific control within controlConfiguration.
+	 *
+	 * @param vAnnotationPath The annotation path or object to evaluate
+	 * @returns The control configuration for that specific anntoation path if it exists
+	 */
+	getManifestControlConfiguration(vAnnotationPath: string | AnnotationTerm<any>): any {
+		if (isAnnotationTerm(vAnnotationPath)) {
+			return this.manifestWrapper.getControlConfiguration(
+				vAnnotationPath.fullyQualifiedName.replace(this.targetDataModelPath.targetEntityType.fullyQualifiedName, "")
+			);
+		}
+		return this.manifestWrapper.getControlConfiguration(vAnnotationPath);
+	}
+
+	/**
+	 * Create an absolute annotation path based on the current meta model context.
+	 *
+	 * @param sAnnotationPath The relative annotation path
+	 * @returns The correct annotation path based on the current context
+	 */
+	getAbsoluteAnnotationPath(sAnnotationPath: string): string {
+		if (!sAnnotationPath) {
+			return sAnnotationPath;
+		}
+		if (sAnnotationPath[0] === "/") {
+			return sAnnotationPath;
+		}
+		return this.baseContextPath + "/" + sAnnotationPath;
+	}
+
+	/**
+	 * Retrieve the current entitySet.
+	 *
+	 * @returns The current EntitySet if it exists.
+	 */
+	getEntitySet(): EntitySet | undefined {
+		return this.targetDataModelPath.targetEntitySet;
+	}
+
+	/**
+	 * Retrieve the context path.
+	 *
+	 * @returns The context path of the converter.
+	 */
+	getContextPath(): string {
+		return this.baseContextPath;
+	}
+
+	/**
+	 * Retrieve the current data model object path.
+	 *
+	 * @returns The current data model object path
+	 */
+	getDataModelObjectPath(): DataModelObjectPath {
+		return this.targetDataModelPath;
+	}
+
+	/**
+	 * Get the EntityContainer.
+	 *
+	 * @returns The current service EntityContainer
+	 */
+	getEntityContainer(): EntityContainer {
+		return this.convertedTypes.entityContainer;
+	}
+
+	/**
+	 * Get the EntityType based on the fully qualified name.
+	 *
+	 * @returns The current EntityType.
+	 */
+	getEntityType(): EntityType {
+		return this.targetDataModelPath.targetEntityType;
+	}
+
+	/**
+	 * Get a singleton based on fully qualified name.
+	 *
+	 * @param {string} fullyQualifiedName The fully qualified name of the singleton
+	 * @returns {Singleton | undefined} The singleton instance.
+	 */
+	getSingleton(fullyQualifiedName: string): Singleton | undefined {
+		return this.convertedTypes.singletons.find(singleton => singleton.fullyQualifiedName === fullyQualifiedName);
+	}
+
+	/**
+	 * Retrieve an annotation from an EntityType based on an annotation path.
+	 *
+	 * @param annotationPath The annotation path to evaluate
+	 * @returns The target annotation path as well as a converter context to go with it
+	 */
+	getEntityTypeAnnotation(annotationPath: string): ResolvedAnnotationContext {
+		if (annotationPath.indexOf("@") === -1) {
+			annotationPath = "@" + annotationPath;
+		}
+		const targetObject: ResolvedTarget = this.targetDataModelPath.targetEntityType.resolvePath(annotationPath, true);
+
+		let rootEntitySet = this.targetDataModelPath.targetEntitySet;
+		let currentEntityType = this.targetDataModelPath.targetEntityType;
+		const startingEntityType = this.targetDataModelPath.startingEntitySet.entityType;
+		const navigationProperties = this.targetDataModelPath.navigationProperties.concat();
+		let i = 1;
+		let currentObject;
+		let navigatedPaths = [];
+		const visitedObjects = targetObject.visitedObjects;
+		// In case of parameterized service
+		if (!rootEntitySet && startingEntityType.annotations.Common?.ResultContext) {
+			rootEntitySet = this.targetDataModelPath.startingEntitySet;
+			this.targetDataModelPath.navigationProperties.forEach(function(navObject) {
+				navigatedPaths.push(navObject.name);
+			});
+		}
+		while (i < visitedObjects.length) {
+			currentObject = visitedObjects[i++];
+			if (currentObject._type === "NavigationProperty") {
+				navigatedPaths.push(currentObject.name);
+				navigationProperties.push(currentObject as NavigationProperty);
+				currentEntityType = (currentObject as NavigationProperty).targetType;
+				if (rootEntitySet && rootEntitySet.navigationPropertyBinding.hasOwnProperty(navigatedPaths.join("/"))) {
+					const navPath = navigatedPaths.join("/");
+					rootEntitySet =
+						rootEntitySet.navigationPropertyBinding[currentObject.name] || rootEntitySet.navigationPropertyBinding[navPath];
+					navigatedPaths = [];
+				} else {
+					rootEntitySet = undefined;
+				}
+			}
+			if (currentObject._type === "EntitySet") {
+				rootEntitySet = currentObject as EntitySet;
+				currentEntityType = rootEntitySet.entityType;
+			}
+		}
+		const outDataModelPath = {
+			startingEntitySet: this.targetDataModelPath.startingEntitySet,
+			targetEntitySet: rootEntitySet,
+			targetEntityType: currentEntityType,
+			targetObject: navigationProperties[navigationProperties.length - 1],
+			navigationProperties,
+			contextLocation: this.targetDataModelPath.contextLocation
+		};
+		return {
+			annotation: targetObject.target as AnyAnnotation,
+			converterContext: new ConverterContext(
+				this.convertedTypes,
+				this.manifestSettings,
+				this.diagnostics,
+				this.mergeFn,
+				outDataModelPath
+			)
+		};
+	}
+
+	/**
+	 * Retrieve the type of template we're working on (e.g. ListReport / ObjectPage / ...).
+	 *
+	 * @returns The current tenplate type
+	 */
+	getTemplateType(): TemplateType {
+		return this.manifestWrapper.getTemplateType();
+	}
+
+	/**
+	 * Retrieve a relative annotation path between an annotation path and an entity type.
+	 *
+	 * @param annotationPath
+	 * @param entityType
+	 * @returns The relative anntotation path.
+	 */
+	getRelativeAnnotationPath(annotationPath: string, entityType: EntityType): string {
+		return annotationPath.replace(entityType.fullyQualifiedName, "");
+	}
+
+	/**
+	 * Transform an entityType based path to an entitySet based one (ui5 templating generally expect an entitySetBasedPath).
+	 *
+	 * @param annotationPath
+	 * @returns The EntitySet based annotation path
+	 */
+	getEntitySetBasedAnnotationPath(annotationPath: string): string {
+		if (!annotationPath) {
+			return annotationPath;
+		}
+		const entityTypeFQN = this.targetDataModelPath.targetEntityType.fullyQualifiedName;
+		if (
+			this.targetDataModelPath.targetEntitySet ||
+			((this.baseContextPath.startsWith("/") && this.baseContextPath.match(/\//g)) || []).length > 1
+		) {
+			let replacedAnnotationPath = annotationPath.replace(entityTypeFQN, "/");
+			if (replacedAnnotationPath.length > 2 && replacedAnnotationPath[0] === "/" && replacedAnnotationPath[1] === "/") {
+				replacedAnnotationPath = replacedAnnotationPath.substr(1);
+			}
+			return this.baseContextPath + replacedAnnotationPath;
+		} else {
+			return "/" + annotationPath;
+		}
+	}
+
+	/**
+	 * Retrieve the manifest wrapper for the current context.
+	 *
+	 * @returns The current manifest wrapper
+	 */
+	getManifestWrapper(): ManifestWrapper {
+		return this.manifestWrapper;
+	}
+
+	getDiagnostics(): IDiagnostics {
+		return this.diagnostics;
+	}
+
+	/**
+	 * Retrieve a new converter context, scoped for a different context path.
+	 *
+	 * @param {string} contextPath The path we want to orchestrate the converter context around
+	 * @returns {ConverterContext}
+	 */
+	getConverterContextFor<T>(contextPath: string): ConverterContext {
+		const resolvedMetaPath: ResolutionTarget<T> = this.convertedTypes.resolvePath(contextPath);
+		const targetPath = getDataModelPathForEntitySet(resolvedMetaPath);
+		return new ConverterContext(this.convertedTypes, this.manifestSettings, this.diagnostics, this.mergeFn, targetPath);
+	}
+
+	/**
+	 * Get all annotations of a given term and vocabulary on an entity type
+	 * (or on the current entity type if entityType isn't specified).
+	 *
+	 * @param vocabularyName
+	 * @param annotationTerm
+	 * @param [annotationSources]
+	 * @returns All the annotation for a specific term and vocabulary from an entity type
+	 */
+	getAnnotationsByTerm(
+		vocabularyName: keyof EntityTypeAnnotations,
+		annotationTerm: string,
+		annotationSources: (ServiceObject | undefined)[] = [this.getEntityType()]
+	): AnnotationTerm<any>[] {
+		let outAnnotations: AnnotationTerm<any>[] = [];
+		annotationSources.forEach(annotationSource => {
+			if (annotationSource) {
+				const annotations: Record<string, AnnotationTerm<any>> = annotationSource?.annotations[vocabularyName] || {};
+				if (annotations) {
+					outAnnotations = Object.keys(annotations)
+						.filter(annotation => annotations[annotation].term === annotationTerm)
+						.reduce((previousValue: AnnotationTerm<any>[], key: string) => {
+							previousValue.push(annotations[key]);
+							return previousValue;
+						}, outAnnotations);
+				}
+			}
+		});
+		return outAnnotations;
+	}
+
+	/**
+	 * Retrieves the relative model path based on the current context path.
+	 *
+	 * @returns {string|undefined} The relative model path or undefined if the path is not resolveable
+	 */
+	getRelativeModelPathFunction(): Function {
+		const targetDataModelPath = this.targetDataModelPath;
+		return function(sPath: string) {
+			const enhancedPath = enhanceDataModelPath(targetDataModelPath, sPath);
+			return getContextRelativeTargetObjectPath(enhancedPath, true);
+		};
+	}
+
+	/**
+	 * Create the converter context necessary for a macro based on a metamodel context.
+	 * @param sEntitySetName
+	 * @param oMetaModelContext
+	 * @param diagnostics
+	 * @param mergeFn
+	 * @param targetDataModelPath
+	 * @param manifestSettings
+	 * @returns {ConverterContext} The current converter context
+	 */
+	static createConverterContextForMacro(
+		sEntitySetName: string,
+		oMetaModelContext: Context | ODataMetaModel,
+		diagnostics: IDiagnostics,
+		mergeFn: Function,
+		targetDataModelPath: DataModelObjectPath | undefined,
+		manifestSettings: BaseManifestSettings = {} as BaseManifestSettings
+	): ConverterContext {
+		const oMetaModel: ODataMetaModel = oMetaModelContext.isA("sap.ui.model.odata.v4.ODataMetaModel")
+			? (oMetaModelContext as ODataMetaModel)
+			: (((oMetaModelContext as Context).getModel() as unknown) as ODataMetaModel);
+		const oConverterOutput = convertTypes(oMetaModel);
+		const targetEntitySet = oConverterOutput.entitySets.find(entitySet => entitySet.name === sEntitySetName) as EntitySet;
+		if (!targetDataModelPath) {
+			targetDataModelPath = {
+				startingEntitySet: targetEntitySet,
+				navigationProperties: [],
+				targetEntitySet: targetEntitySet,
+				targetEntityType: targetEntitySet.entityType,
+				targetObject: targetEntitySet
+			};
+		}
+		return new ConverterContext(oConverterOutput, manifestSettings, diagnostics, mergeFn, targetDataModelPath);
+	}
+}
+
+export default ConverterContext;

package/packages/sap.fe.core/src/sap/fe/core/converters/ManifestSettings-dbg.js

@@ -0,0 +1,90 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([], function () {
+  "use strict";
+
+  var _exports = {};
+
+  var TemplateType;
+
+  (function (TemplateType) {
+    TemplateType["ListReport"] = "ListReport";
+    TemplateType["ObjectPage"] = "ObjectPage";
+    TemplateType["AnalyticalListPage"] = "AnalyticalListPage";
+  })(TemplateType || (TemplateType = {}));
+
+  _exports.TemplateType = TemplateType;
+  var ActionType;
+
+  (function (ActionType) {
+    ActionType["DataFieldForAction"] = "ForAction";
+    ActionType["DataFieldForIntentBasedNavigation"] = "ForNavigation";
+    ActionType["Default"] = "Default";
+    ActionType["Primary"] = "Primary";
+    ActionType["Secondary"] = "Secondary";
+    ActionType["SwitchToActiveObject"] = "SwitchToActiveObject";
+    ActionType["SwitchToDraftObject"] = "SwitchToDraftObject";
+    ActionType["DefaultApply"] = "DefaultApply";
+    ActionType["Menu"] = "Menu";
+  })(ActionType || (ActionType = {}));
+
+  _exports.ActionType = ActionType;
+  var VisualizationType;
+
+  (function (VisualizationType) {
+    VisualizationType["Table"] = "Table";
+    VisualizationType["Chart"] = "Chart";
+  })(VisualizationType || (VisualizationType = {}));
+
+  _exports.VisualizationType = VisualizationType;
+  var VariantManagementType;
+
+  (function (VariantManagementType) {
+    VariantManagementType["Page"] = "Page";
+    VariantManagementType["Control"] = "Control";
+    VariantManagementType["None"] = "None";
+  })(VariantManagementType || (VariantManagementType = {}));
+
+  _exports.VariantManagementType = VariantManagementType;
+  var CreationMode;
+
+  (function (CreationMode) {
+    CreationMode["NewPage"] = "NewPage";
+    CreationMode["Inline"] = "Inline";
+    CreationMode["CreationRow"] = "CreationRow";
+  })(CreationMode || (CreationMode = {}));
+
+  _exports.CreationMode = CreationMode;
+  var AvailabilityType;
+
+  (function (AvailabilityType) {
+    AvailabilityType["Default"] = "Default";
+    AvailabilityType["Adaptation"] = "Adaptation";
+    AvailabilityType["Hidden"] = "Hidden";
+  })(AvailabilityType || (AvailabilityType = {}));
+
+  _exports.AvailabilityType = AvailabilityType;
+  var HorizontalAlign;
+
+  (function (HorizontalAlign) {
+    HorizontalAlign["End"] = "End";
+    HorizontalAlign["Begin"] = "Begin";
+    HorizontalAlign["Center"] = "Center";
+  })(HorizontalAlign || (HorizontalAlign = {}));
+
+  _exports.HorizontalAlign = HorizontalAlign;
+  var SelectionMode;
+
+  (function (SelectionMode) {
+    SelectionMode["Auto"] = "Auto";
+    SelectionMode["None"] = "None";
+    SelectionMode["Multi"] = "Multi";
+    SelectionMode["Single"] = "Single";
+  })(SelectionMode || (SelectionMode = {}));
+
+  _exports.SelectionMode = SelectionMode;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["ManifestSettings.ts"],"names":["TemplateType","ActionType","VisualizationType","VariantManagementType","CreationMode","AvailabilityType","HorizontalAlign","SelectionMode"],"mappings":";AAAA;AACA;AACA;;;;;;MAGYA,Y;;aAAAA,Y;AAAAA,IAAAA,Y;AAAAA,IAAAA,Y;AAAAA,IAAAA,Y;KAAAA,Y,KAAAA,Y;;;MAMAC,U;;aAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;AAAAA,IAAAA,U;KAAAA,U,KAAAA,U;;;MAiBAC,iB;;aAAAA,iB;AAAAA,IAAAA,iB;AAAAA,IAAAA,iB;KAAAA,iB,KAAAA,iB;;;MAKAC,qB;;aAAAA,qB;AAAAA,IAAAA,qB;AAAAA,IAAAA,qB;AAAAA,IAAAA,qB;KAAAA,qB,KAAAA,qB;;;MAWAC,Y;;aAAAA,Y;AAAAA,IAAAA,Y;AAAAA,IAAAA,Y;AAAAA,IAAAA,Y;KAAAA,Y,KAAAA,Y;;;MAMAC,gB;;aAAAA,gB;AAAAA,IAAAA,gB;AAAAA,IAAAA,gB;AAAAA,IAAAA,gB;KAAAA,gB,KAAAA,gB;;;MAMAC,e;;aAAAA,e;AAAAA,IAAAA,e;AAAAA,IAAAA,e;AAAAA,IAAAA,e;KAAAA,e,KAAAA,e;;;MAoUAC,a;;aAAAA,a;AAAAA,IAAAA,a;AAAAA,IAAAA,a;AAAAA,IAAAA,a;AAAAA,IAAAA,a;KAAAA,a,KAAAA,a","sourceRoot":".","sourcesContent":["import { ConfigurableRecord, Position, Positionable } from \"./helpers/ConfigurableObject\";\nimport { FlexSettings, HeaderFacetType } from \"sap/fe/core/converters/controls/ObjectPage/HeaderFacet\";\nimport { BindingExpression } from \"sap/fe/core/helpers/BindingExpression\";\nimport { TableType } from \"./controls/Common/Table\";\n\nexport enum TemplateType {\n\tListReport = \"ListReport\",\n\tObjectPage = \"ObjectPage\",\n\tAnalyticalListPage = \"AnalyticalListPage\"\n}\n\nexport enum ActionType {\n\tDataFieldForAction = \"ForAction\",\n\tDataFieldForIntentBasedNavigation = \"ForNavigation\",\n\tDefault = \"Default\",\n\tPrimary = \"Primary\",\n\tSecondary = \"Secondary\",\n\tSwitchToActiveObject = \"SwitchToActiveObject\",\n\tSwitchToDraftObject = \"SwitchToDraftObject\",\n\tDefaultApply = \"DefaultApply\",\n\tMenu = \"Menu\"\n}\n\nexport type ManifestSideContent = {\n\ttemplate: string;\n\tequalSplit?: boolean;\n};\n\nexport enum VisualizationType {\n\tTable = \"Table\",\n\tChart = \"Chart\"\n}\n\nexport enum VariantManagementType {\n\tPage = \"Page\",\n\tControl = \"Control\",\n\tNone = \"None\"\n}\n\nexport type ContentDensitiesType = {\n\tcompact?: boolean;\n\tcozy?: boolean;\n};\n\nexport enum CreationMode {\n\tNewPage = \"NewPage\",\n\tInline = \"Inline\",\n\tCreationRow = \"CreationRow\"\n}\n\nexport enum AvailabilityType {\n\tDefault = \"Default\",\n\tAdaptation = \"Adaptation\",\n\tHidden = \"Hidden\"\n}\n\nexport enum HorizontalAlign {\n\tEnd = \"End\",\n\tBegin = \"Begin\",\n\tCenter = \"Center\"\n}\n\nexport type TableColumnSettings = {\n\tmicroChartSize?: string;\n\tshowMicroChartLabel?: boolean;\n};\n\n/**\n * Collection of format options for multiline text fields on a form or in a table\n */\nexport type FormatOptionsType = {\n\ttextLinesEdit: number;\n\ttextMaxCharactersDisplay?: number;\n\ttextExpandBehaviorDisplay?: string;\n};\n\n/**\n * Configuration of a KPI in the manifest\n */\nexport type KPIConfiguration = {\n\tmodel?: string;\n\tentitySet: string;\n\tqualifier: string;\n};\n\n/**\n * @typedef BaseManifestSettings\n */\nexport type BaseManifestSettings = {\n\tcontent?: {\n\t\theader?: {\n\t\t\tfacets?: ConfigurableRecord<ManifestHeaderFacet>;\n\t\t\tactions?: ConfigurableRecord<ManifestAction>;\n\t\t};\n\t\tfooter?: {\n\t\t\tactions?: ConfigurableRecord<ManifestAction>;\n\t\t};\n\t};\n\tcontrolConfiguration?: {\n\t\t[annotationPath: string]: ControlManifestConfiguration;\n\t} & {\n\t\t\"@com.sap.vocabularies.UI.v1.LineItem\"?: TableManifestConfiguration;\n\t\t\"@com.sap.vocabularies.UI.v1.Facets\"?: FacetsControlConfiguration;\n\t\t\"@com.sap.vocabularies.UI.v1.HeaderFacets\"?: HeaderFacetsControlConfiguration;\n\t\t\"@com.sap.vocabularies.UI.v1.SelectionFields\"?: FilterManifestConfiguration;\n\t};\n\tconverterType: TemplateType;\n\tentitySet: string;\n\tnavigation?: {\n\t\t[navigationPath: string]: NavigationSettingsConfiguration;\n\t};\n\tviewLevel?: number;\n\tfclEnabled?: boolean;\n\tcontextPath?: string;\n\tvariantManagement?: VariantManagementType;\n\tdefaultTemplateAnnotationPath?: string;\n\tcontentDensities?: ContentDensitiesType;\n\tshellContentDensity?: string;\n\tisDesktop?: boolean;\n};\n\nexport type NavigationTargetConfiguration = {\n\toutbound?: string;\n\toutboundDetail?: {\n\t\tsemanticObject: string;\n\t\taction: string;\n\t\tparameters?: any;\n\t};\n\troute?: string;\n};\n\n/**\n * @typedef NavigationSettingsConfiguration\n */\nexport type NavigationSettingsConfiguration = {\n\tcreate?: NavigationTargetConfiguration;\n\tdetail?: NavigationTargetConfiguration;\n\tdisplay?: {\n\t\toutbound?: string;\n\t\ttarget?: string; // for compatibility\n\t\troute?: string;\n\t};\n};\n\ntype HeaderFacetsControlConfiguration = {\n\tfacets: ConfigurableRecord<ManifestHeaderFacet>;\n};\n\ntype FacetsControlConfiguration = {\n\tsections: ConfigurableRecord<ManifestSection>;\n};\n\ntype ManifestFormElement = Positionable & {\n\ttemplate: string;\n\tlabel?: string;\n\tformatOptions?: FormatOptionsType;\n};\n\nexport type FormManifestConfiguration = {\n\tfields: ConfigurableRecord<ManifestFormElement>;\n};\n\nexport type ControlManifestConfiguration =\n\t| TableManifestConfiguration\n\t| ChartManifestConfiguration\n\t| FacetsControlConfiguration\n\t| HeaderFacetsControlConfiguration\n\t| FormManifestConfiguration\n\t| FilterManifestConfiguration;\n\n/** Object Page **/\n\nexport type ObjectPageManifestSettings = BaseManifestSettings & {\n\tcontent?: {\n\t\theader?: {\n\t\t\tvisible?: boolean;\n\t\t\tanchorBarVisible?: boolean;\n\t\t\tfacets?: ConfigurableRecord<ManifestHeaderFacet>;\n\t\t};\n\t\tbody?: {\n\t\t\tsections?: ConfigurableRecord<ManifestSection>;\n\t\t};\n\t};\n\teditableHeaderContent: boolean;\n\tsectionLayout: \"Tabs\" | \"Page\";\n};\n\n/**\n * @typedef ManifestHeaderFacet\n */\nexport type ManifestHeaderFacet = {\n\ttype?: HeaderFacetType;\n\tname?: string;\n\ttemplate?: string;\n\tposition?: Position;\n\tvisible?: BindingExpression<boolean>;\n\ttitle?: string;\n\tsubTitle?: string;\n\tstashed?: boolean;\n\tflexSettings?: FlexSettings;\n\trequestGroupId?: string;\n\ttemplateEdit?: string;\n};\n\n/**\n * @typedef ManifestSection\n */\nexport type ManifestSection = {\n\ttitle?: string;\n\tid?: string;\n\tname?: string;\n\tvisible?: BindingExpression<boolean>;\n\tposition?: Position;\n\ttemplate?: string;\n\tsubSections?: Record<string, ManifestSubSection>;\n\tactions?: Record<string, ManifestAction>;\n};\n\nexport type ManifestSubSection = {\n\tid?: string;\n\tname?: string;\n\ttemplate?: string;\n\ttitle?: string;\n\tposition?: Position;\n\tvisible?: BindingExpression<boolean>;\n\tactions?: Record<string, ManifestAction>;\n\tsideContent?: ManifestSideContent;\n};\n\n/** List Report **/\n\nexport type ListReportManifestSettings = BaseManifestSettings & {\n\tinitialLoad?: boolean;\n\tviews?: MultipleViewsConfiguration;\n\tkeyPerformanceIndicators?: {\n\t\t[kpiName: string]: KPIConfiguration;\n\t};\n};\n\nexport type ViewPathConfiguration = SingleViewPathConfiguration | CombinedViewPathConfiguration;\n\nexport type ViewConfiguration = ViewPathConfiguration | CustomViewTemplateConfiguration;\n\nexport type CustomViewTemplateConfiguration = {\n\tkey?: string;\n\tlabel: string;\n\ttemplate: string;\n};\n\nexport type SingleViewPathConfiguration = {\n\tkeepPreviousPresonalization?: boolean;\n\tkey?: string;\n\tentitySet?: string;\n\tannotationPath: string;\n\tcontextPath?: string;\n};\n\nexport type CombinedViewPathConfiguration = {\n\tprimary: SingleViewPathConfiguration[];\n\tsecondary: SingleViewPathConfiguration[];\n\tdefaultPath?: \"both\" | \"primary\" | \"secondary\";\n\tkey?: string;\n};\n\n/**\n * @typedef MultipleViewsConfiguration\n */\nexport type MultipleViewsConfiguration = {\n\tpaths: ViewConfiguration[];\n\tshowCounts?: boolean;\n};\n\n/** Filter Configuration **/\n\n/** @typedef FilterManifestConfiguration **/\nexport type FilterManifestConfiguration = {\n\tfilterFields?: Record<string, FilterFieldManifestConfiguration>;\n\tnavigationProperties?: string[];\n\tuseSemanticDateRange?: boolean;\n\tinitialLayout?: string;\n\tlayout?: string;\n};\n\nexport type FilterFieldManifestConfiguration = Positionable & {\n\tlabel?: string;\n\ttemplate?: string;\n\tavailability?: AvailabilityType;\n\tsettings?: FilterSettings;\n\tvisualFilter?: visualFilterConfiguration;\n};\n\nexport type visualFilterConfiguration = {\n\tvalueList?: string;\n};\n\nexport type OperatorConfiguration = {\n\tpath: string;\n\tequals?: string;\n\tcontains?: string;\n\texclude: boolean;\n};\n\nexport type DefaultOperator = {\n\toperator: string;\n};\n\nexport type FilterSettings = {\n\toperatorConfiguration?: OperatorConfiguration[];\n\tdefaultValues?: DefaultOperator[];\n};\n\n/** Chart Configuration **/\n\nexport type ChartPersonalizationManifestSettings =\n\t| boolean\n\t| {\n\t\t\tsort: boolean;\n\t\t\ttype: boolean;\n\t\t\titem: boolean;\n\t  };\n\nexport type ChartManifestConfiguration = {\n\tchartSettings: {\n\t\tpersonalization: ChartPersonalizationManifestSettings;\n\t};\n};\n\nexport type ActionAfterExecutionConfiguration = {\n\tnavigateToInstance?: boolean;\n\tenableAutoScroll?: boolean;\n};\n\n/** Table Configuration **/\n\n/**\n * @typedef ManifestAction\n */\nexport type ManifestAction = {\n\tmenu?: string[];\n\tvisible?: string;\n\tenabled?: string;\n\tposition?: Position;\n\tpress?: string;\n\ttext?: string;\n\t__noWrap?: boolean;\n\tenableOnSelect?: string;\n\tdefaultValuesFunction?: string;\n\trequiresSelection?: boolean;\n\tafterExecution?: ActionAfterExecutionConfiguration;\n\tinline?: boolean;\n\tdetermining?: boolean;\n};\n\nexport type ManifestTableColumnOverride = Positionable & {\n\twidth?: string;\n\thorizontalAlign?: HorizontalAlign;\n\tafterExecution?: ActionAfterExecutionConfiguration;\n\tsettings?: TableColumnSettings;\n\tformatOptions?: FormatOptionsType;\n};\n\nexport type ManifestTableColumn = Positionable & {\n\theader: string;\n\twidth?: string;\n\ttype?: string;\n\thorizontalAlign?: HorizontalAlign;\n\ttemplate: string;\n\tafterExecution?: ActionAfterExecutionConfiguration;\n\tavailability?: AvailabilityType;\n\tsettings?: TableColumnSettings;\n\tformatOptions?: FormatOptionsType;\n\tproperties?: string[];\n};\n\nexport type TableManifestConfiguration = {\n\ttableSettings?: TableManifestSettingsConfiguration;\n\tactions?: Record<string, ManifestAction>;\n\tcolumns?: Record<string, ManifestTableColumn | ManifestTableColumnOverride>;\n};\n\nexport enum SelectionMode {\n\tAuto = \"Auto\",\n\tNone = \"None\",\n\tMulti = \"Multi\",\n\tSingle = \"Single\"\n}\n\nexport type TablePersonalizationConfiguration =\n\t| boolean\n\t| {\n\t\t\tsort: boolean;\n\t\t\tcolumn: boolean;\n\t\t\tfilter: boolean;\n\t\t\tgroup: boolean;\n\t\t\taggregate: boolean;\n\t  };\n\nexport type TableManifestSettingsConfiguration = {\n\tcreationMode?: {\n\t\tdisableAddRowButtonForEmptyData?: boolean;\n\t\tcustomValidationFunction?: string;\n\t\tcreateAtEnd?: boolean;\n\t\tname?: CreationMode;\n\t};\n\tenableExport?: boolean;\n\tquickVariantSelection?: {\n\t\tpaths: [\n\t\t\t{\n\t\t\t\tannotationPath: string;\n\t\t\t}\n\t\t];\n\t\thideTableTitle?: boolean;\n\t\tshowCounts?: boolean;\n\t};\n\tpersonalization?: TablePersonalizationConfiguration;\n\t/**\n\t * Defines how many items in a table can be selected. You have the following options:\n\t * => by defining 'None' you can fully disable the list selection\n\t * => by defining 'Single' you allow only one item to be selected\n\t * => by defining 'Multi' you allow several items to be selected\n\t * => by using 'Auto' you leave the default definition 'None', except if there is an action that requires a selection (such as deleting, or IBN)\n\t */\n\tselectionMode?: SelectionMode;\n\ttype?: TableType;\n\tcondensedTableLayout?: boolean;\n\tselectAll?: boolean;\n\tselectionLimit?: number;\n\tenablePaste?: boolean;\n\tenableFullScreen?: boolean;\n\tenableMassEdit?: boolean;\n};\n"]}

package/packages/sap.fe.core/src/sap/fe/core/converters/ManifestSettings.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define([],function(){"use strict";var _={};var T;(function(T){T["ListReport"]="ListReport";T["ObjectPage"]="ObjectPage";T["AnalyticalListPage"]="AnalyticalListPage";})(T||(T={}));_.TemplateType=T;var A;(function(A){A["DataFieldForAction"]="ForAction";A["DataFieldForIntentBasedNavigation"]="ForNavigation";A["Default"]="Default";A["Primary"]="Primary";A["Secondary"]="Secondary";A["SwitchToActiveObject"]="SwitchToActiveObject";A["SwitchToDraftObject"]="SwitchToDraftObject";A["DefaultApply"]="DefaultApply";A["Menu"]="Menu";})(A||(A={}));_.ActionType=A;var V;(function(V){V["Table"]="Table";V["Chart"]="Chart";})(V||(V={}));_.VisualizationType=V;var a;(function(a){a["Page"]="Page";a["Control"]="Control";a["None"]="None";})(a||(a={}));_.VariantManagementType=a;var C;(function(C){C["NewPage"]="NewPage";C["Inline"]="Inline";C["CreationRow"]="CreationRow";})(C||(C={}));_.CreationMode=C;var b;(function(b){b["Default"]="Default";b["Adaptation"]="Adaptation";b["Hidden"]="Hidden";})(b||(b={}));_.AvailabilityType=b;var H;(function(H){H["End"]="End";H["Begin"]="Begin";H["Center"]="Center";})(H||(H={}));_.HorizontalAlign=H;var S;(function(S){S["Auto"]="Auto";S["None"]="None";S["Multi"]="Multi";S["Single"]="Single";})(S||(S={}));_.SelectionMode=S;return _;},false);