@sap/open.fe 1.94.0

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Chart.ts

@@ -0,0 +1,202 @@
+import {
+	ChartManifestConfiguration,
+	ChartPersonalizationManifestSettings,
+	VisualizationType,
+	ActionType,
+	TemplateType
+} from "../../ManifestSettings";
+import { ChartDefinitionTypeTypes, DataFieldAbstractTypes } from "@sap-ux/vocabularies-types";
+import { AnnotationAction, BaseAction, getActionsFromManifest } from "sap/fe/core/converters/controls/Common/Action";
+import { isDataFieldForActionAbstract } from "sap/fe/core/converters/annotations/DataField";
+import { ChartID, FilterBarID } from "../../helpers/ID";
+import { insertCustomElements } from "sap/fe/core/converters/helpers/ConfigurableObject";
+import { KeyHelper } from "sap/fe/core/converters/helpers/Key";
+import { getTargetObjectPath } from "sap/fe/core/templating/DataModelPathHelper";
+import { AggregationHelper } from "../../helpers/Aggregation";
+import ManifestWrapper from "../../ManifestWrapper";
+import ConverterContext from "../../ConverterContext";
+
+/**
+ * @typedef ChartVisualization
+ */
+export type ChartVisualization = {
+	type: VisualizationType.Chart;
+	id: string;
+	collection: string;
+	entityName: string;
+	personalization?: string;
+	navigationPath: string;
+	annotationPath: string;
+	filterId?: string;
+	vizProperties: string;
+	actions: BaseAction[];
+	title: string;
+	autoBindOnInit: boolean | undefined;
+	onSegmentedButtonPressed: string;
+	visible: string;
+};
+
+/**
+ * Method to retrieve all chart actions from annotations.
+ *
+ * @param chartAnnotation
+ * @param visualizationPath
+ * @param converterContext
+ * @returns {BaseAction[]} The table annotation actions
+ */
+function getChartActionsFromAnnotations(
+	chartAnnotation: ChartDefinitionTypeTypes,
+	visualizationPath: string,
+	converterContext: ConverterContext
+): BaseAction[] {
+	const chartActions: BaseAction[] = [];
+	if (chartAnnotation) {
+		const aActions = chartAnnotation.Actions || [];
+		aActions.forEach((dataField: DataFieldAbstractTypes) => {
+			let chartAction: AnnotationAction | undefined;
+			if (
+				isDataFieldForActionAbstract(dataField) &&
+				!(dataField.annotations?.UI?.Hidden?.valueOf() === true) &&
+				!dataField.Inline &&
+				!dataField.Determining
+			) {
+				const key = KeyHelper.generateKeyFromDataField(dataField);
+				switch (dataField.$Type) {
+					case "com.sap.vocabularies.UI.v1.DataFieldForAction":
+						chartAction = {
+							type: ActionType.DataFieldForAction,
+							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
+							key: key
+						};
+						break;
+
+					case "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation":
+						chartAction = {
+							type: ActionType.DataFieldForIntentBasedNavigation,
+							annotationPath: converterContext.getEntitySetBasedAnnotationPath(dataField.fullyQualifiedName),
+							key: key
+						};
+						break;
+				}
+			}
+			if (chartAction) {
+				chartActions.push(chartAction);
+			}
+		});
+	}
+	return chartActions;
+}
+
+export function getChartActions(
+	chartAnnotation: ChartDefinitionTypeTypes,
+	visualizationPath: string,
+	converterContext: ConverterContext
+): BaseAction[] {
+	const aAnnotationActions: BaseAction[] = getChartActionsFromAnnotations(chartAnnotation, visualizationPath, converterContext);
+
+	return insertCustomElements(
+		aAnnotationActions,
+		getActionsFromManifest(
+			converterContext.getManifestControlConfiguration(visualizationPath).actions,
+			converterContext,
+			aAnnotationActions
+		),
+		{ enableOnSelect: "overwrite", enabled: "overwrite" }
+	);
+}
+
+export function getP13nMode(visualizationPath: string, converterContext: ConverterContext): string | undefined {
+	const manifestWrapper: ManifestWrapper = converterContext.getManifestWrapper();
+	const chartManifestSettings: ChartManifestConfiguration = converterContext.getManifestControlConfiguration(visualizationPath);
+	const hasVariantManagement: boolean = ["Page", "Control"].indexOf(manifestWrapper.getVariantManagement()) > -1;
+	let personalization: ChartPersonalizationManifestSettings = true;
+	const aPersonalization: string[] = [];
+	if (chartManifestSettings?.chartSettings?.personalization !== undefined) {
+		personalization = chartManifestSettings.chartSettings.personalization;
+	}
+	if (hasVariantManagement && personalization) {
+		if (personalization === true) {
+			return "Sort,Type,Item";
+		} else if (typeof personalization === "object") {
+			if (personalization.type) {
+				aPersonalization.push("Type");
+			}
+			if (personalization.item) {
+				aPersonalization.push("Item");
+			}
+			if (personalization.sort) {
+				aPersonalization.push("Sort");
+			}
+			return aPersonalization.join(",");
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Create the ChartVisualization configuration that will be used to display a chart via Chart Macro.
+ *
+ * @param {ChartDefinitionTypeTypes} chartAnnotation The target chart annotation
+ * @param {string} visualizationPath The current visualization annotation path
+ * @param {ConverterContext} converterContext The converter context
+ * @param {boolean} doNotCheckApplySupported Flag that tells whether applysupported to be checked or not
+ * @returns {ChartVisualization} The chart visualization based on the annotation
+ */
+export function createChartVisualization(
+	chartAnnotation: ChartDefinitionTypeTypes,
+	visualizationPath: string,
+	converterContext: ConverterContext,
+	doNotCheckApplySupported?: boolean
+): ChartVisualization {
+	const aggregationHelper = new AggregationHelper(converterContext.getEntityType(), converterContext);
+	if (!doNotCheckApplySupported && !aggregationHelper.isAnalyticsSupported()) {
+		throw new Error("ApplySupported is not added to the annotations");
+	}
+	const chartActions = getChartActions(chartAnnotation, visualizationPath, converterContext);
+	let [navigationPropertyPath /*, annotationPath*/] = visualizationPath.split("@");
+	if (navigationPropertyPath.lastIndexOf("/") === navigationPropertyPath.length - 1) {
+		// Drop trailing slash
+		navigationPropertyPath = navigationPropertyPath.substr(0, navigationPropertyPath.length - 1);
+	}
+	const title: any = converterContext.getDataModelObjectPath().targetEntityType.annotations?.UI?.HeaderInfo?.TypeNamePlural;
+	const dataModelPath = converterContext.getDataModelObjectPath();
+	const isEntitySet: boolean = navigationPropertyPath.length === 0;
+	const entityName: string = dataModelPath.targetEntitySet ? dataModelPath.targetEntitySet.name : dataModelPath.startingEntitySet.name;
+	const sFilterbarId = isEntitySet ? FilterBarID(converterContext.getContextPath()) : undefined;
+	const oVizProperties = {
+		"legendGroup": {
+			"layout": {
+				"position": "bottom"
+			}
+		}
+	};
+	let autoBindOnInit: boolean | undefined;
+	if (converterContext.getTemplateType() === TemplateType.ObjectPage) {
+		autoBindOnInit = true;
+	} else if (
+		converterContext.getTemplateType() === TemplateType.ListReport ||
+		converterContext.getTemplateType() === TemplateType.AnalyticalListPage
+	) {
+		autoBindOnInit = false;
+	}
+	const hasMultipleVisualizations =
+		converterContext.getManifestWrapper().hasMultipleVisualizations() || converterContext.getTemplateType() === "AnalyticalListPage";
+	const onSegmentedButtonPressed = hasMultipleVisualizations ? ".handlers.onSegmentedButtonPressed" : "";
+	const visible = hasMultipleVisualizations ? "{= ${pageInternal>alpContentView} !== 'Table'}" : "true";
+	return {
+		type: VisualizationType.Chart,
+		id: ChartID(isEntitySet ? entityName : navigationPropertyPath, VisualizationType.Chart),
+		collection: getTargetObjectPath(converterContext.getDataModelObjectPath()),
+		entityName: entityName,
+		personalization: getP13nMode(visualizationPath, converterContext),
+		navigationPath: navigationPropertyPath,
+		annotationPath: converterContext.getAbsoluteAnnotationPath(visualizationPath),
+		filterId: sFilterbarId,
+		vizProperties: JSON.stringify(oVizProperties),
+		actions: chartActions,
+		title: title,
+		autoBindOnInit: autoBindOnInit,
+		onSegmentedButtonPressed: onSegmentedButtonPressed,
+		visible: visible
+	};
+}

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Criticality-dbg.js

@@ -0,0 +1,50 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"], function (TableFormatterTypes) {
+  "use strict";
+
+  var _exports = {};
+  var MessageType = TableFormatterTypes.MessageType;
+
+  /**
+   * Gets a MessageType enum value from a CriticalityType enum value.
+   *
+   * @param {CriticalityType} criticalityEnum The CriticalityType enum value
+   * @returns {MessageType} Returns the MessageType enum value
+   */
+  function getMessageTypeFromCriticalityType(criticalityEnum) {
+    var messageType;
+
+    switch (criticalityEnum) {
+      case "UI.CriticalityType/Negative":
+      case "UI.CriticalityType/VeryNegative":
+        messageType = MessageType.Error;
+        break;
+
+      case "UI.CriticalityType/Critical":
+        messageType = MessageType.Warning;
+        break;
+
+      case "UI.CriticalityType/Positive":
+      case "UI.CriticalityType/VeryPositive":
+        messageType = MessageType.Success;
+        break;
+
+      case "UI.CriticalityType/Information":
+        messageType = MessageType.Information;
+        break;
+
+      case "UI.CriticalityType/Neutral":
+      default:
+        messageType = MessageType.None;
+    }
+
+    return messageType;
+  }
+
+  _exports.getMessageTypeFromCriticalityType = getMessageTypeFromCriticalityType;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Criticality.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["sap/fe/core/formatters/TableFormatterTypes"],function(T){"use strict";var _={};var M=T.MessageType;function g(c){var m;switch(c){case"UI.CriticalityType/Negative":case"UI.CriticalityType/VeryNegative":m=M.Error;break;case"UI.CriticalityType/Critical":m=M.Warning;break;case"UI.CriticalityType/Positive":case"UI.CriticalityType/VeryPositive":m=M.Success;break;case"UI.CriticalityType/Information":m=M.Information;break;case"UI.CriticalityType/Neutral":default:m=M.None;}return m;}_.getMessageTypeFromCriticalityType=g;return _;},false);

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/Criticality.ts

@@ -0,0 +1,33 @@
+import { CriticalityType, EnumValue } from "@sap-ux/vocabularies-types";
+
+import { MessageType } from "sap/fe/core/formatters/TableFormatterTypes";
+
+/**
+ * Gets a MessageType enum value from a CriticalityType enum value.
+ *
+ * @param {CriticalityType} criticalityEnum The CriticalityType enum value
+ * @returns {MessageType} Returns the MessageType enum value
+ */
+export function getMessageTypeFromCriticalityType(criticalityEnum: EnumValue<CriticalityType>): MessageType {
+	let messageType: MessageType;
+	switch (criticalityEnum) {
+		case "UI.CriticalityType/Negative":
+		case "UI.CriticalityType/VeryNegative":
+			messageType = MessageType.Error;
+			break;
+		case "UI.CriticalityType/Critical":
+			messageType = MessageType.Warning;
+			break;
+		case "UI.CriticalityType/Positive":
+		case "UI.CriticalityType/VeryPositive":
+			messageType = MessageType.Success;
+			break;
+		case "UI.CriticalityType/Information":
+			messageType = MessageType.Information;
+			break;
+		case "UI.CriticalityType/Neutral":
+		default:
+			messageType = MessageType.None;
+	}
+	return messageType;
+}

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/DataVisualization-dbg.js

@@ -0,0 +1,276 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["./Table", "./Chart", "sap/fe/core/converters/helpers/IssueManager", "../../ManifestSettings"], function (Table, Chart, IssueManager, ManifestSettings) {
+  "use strict";
+
+  var _exports = {};
+  var TemplateType = ManifestSettings.TemplateType;
+  var IssueCategory = IssueManager.IssueCategory;
+  var IssueSeverity = IssueManager.IssueSeverity;
+  var IssueType = IssueManager.IssueType;
+  var createChartVisualization = Chart.createChartVisualization;
+  var createTableVisualization = Table.createTableVisualization;
+  var createDefaultTableVisualization = Table.createDefaultTableVisualization;
+
+  var getVisualizationsFromPresentationVariant = function (presentationVariantAnnotation, visualizationPath, converterContext, viewConfiguration) {
+    var visualizationAnnotations = [];
+    var visualizations = presentationVariantAnnotation.Visualizations || [];
+    var baseVisualizationPath = visualizationPath.split("@")[0];
+
+    if (visualizations) {
+      // Only allow one line item / chart
+      var hasLineItem = false;
+      var hasChart = false;
+      var hasVisualization = false; // used to allow only first visualization in OP
+
+      visualizations.forEach(function (visualization) {
+        switch (visualization.$target.term) {
+          case "com.sap.vocabularies.UI.v1.LineItem":
+            if (!hasLineItem) {
+              if (!(converterContext.getTemplateType() === TemplateType.ObjectPage && hasVisualization)) {
+                visualizationAnnotations.push({
+                  visualization: visualization.$target,
+                  annotationPath: "".concat(baseVisualizationPath).concat(visualization.value),
+                  converterContext: converterContext
+                });
+                hasLineItem = true;
+                hasVisualization = true;
+              }
+            }
+
+            break;
+
+          case "com.sap.vocabularies.UI.v1.Chart":
+            if (!hasChart && (viewConfiguration && converterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration) && converterContext.getTemplateType() === TemplateType.ListReport || converterContext.getTemplateType() === TemplateType.AnalyticalListPage && !converterContext.getManifestWrapper().getViewConfiguration() || converterContext.getTemplateType() === TemplateType.ObjectPage && !hasVisualization)) {
+              visualizationAnnotations.push({
+                visualization: visualization.$target,
+                annotationPath: "".concat(baseVisualizationPath).concat(visualization.value),
+                converterContext: converterContext
+              });
+              hasChart = true;
+              hasVisualization = true;
+            }
+
+            break;
+
+          default:
+            break;
+        }
+      });
+    }
+
+    return visualizationAnnotations;
+  };
+
+  function getSelectionPresentationVariant(entityType, annotationPath, converterContext) {
+    if (annotationPath) {
+      var resolvedTarget = converterContext.getEntityTypeAnnotation(annotationPath);
+      var selectionPresentationVariant = resolvedTarget.annotation;
+
+      if (selectionPresentationVariant) {
+        if (selectionPresentationVariant.term === "com.sap.vocabularies.UI.v1.SelectionPresentationVariant") {
+          return selectionPresentationVariant;
+        }
+      } else {
+        throw new Error("Annotation Path for the SPV mentioned in the manifest is not found, Please add the SPV in the annotation");
+      }
+    } else {
+      var _entityType$annotatio, _entityType$annotatio2;
+
+      return (_entityType$annotatio = entityType.annotations) === null || _entityType$annotatio === void 0 ? void 0 : (_entityType$annotatio2 = _entityType$annotatio.UI) === null || _entityType$annotatio2 === void 0 ? void 0 : _entityType$annotatio2.SelectionPresentationVariant;
+    }
+  }
+
+  _exports.getSelectionPresentationVariant = getSelectionPresentationVariant;
+
+  function isSelectionPresentationCompliant(SelectionPresentationVariant, bIsALP) {
+    var presentationVariant = SelectionPresentationVariant && SelectionPresentationVariant.PresentationVariant;
+
+    if (presentationVariant) {
+      return isPresentationCompliant(presentationVariant, bIsALP);
+    } else {
+      throw new Error("Presentation Variant is not present in the SPV annotation");
+    }
+  }
+
+  _exports.isSelectionPresentationCompliant = isSelectionPresentationCompliant;
+
+  function isPresentationCompliant(presentationVariant, bIsALP) {
+    var bHasTable = false,
+        bHasChart = false;
+
+    if (bIsALP) {
+      if (presentationVariant && presentationVariant.Visualizations) {
+        var aVisualizations = presentationVariant.Visualizations;
+        aVisualizations.map(function (oVisualization) {
+          if (oVisualization.$target.term === "com.sap.vocabularies.UI.v1.LineItem") {
+            bHasTable = true;
+          }
+
+          if (oVisualization.$target.term === "com.sap.vocabularies.UI.v1.Chart") {
+            bHasChart = true;
+          }
+        });
+      }
+
+      return bHasChart && bHasTable;
+    } else {
+      return presentationVariant && presentationVariant.Visualizations && !!presentationVariant.Visualizations.find(function (visualization) {
+        return visualization.$target.term === "com.sap.vocabularies.UI.v1.LineItem";
+      });
+    }
+  }
+
+  _exports.isPresentationCompliant = isPresentationCompliant;
+
+  function getDefaultLineItem(entityType) {
+    var _entityType$annotatio3;
+
+    return (_entityType$annotatio3 = entityType.annotations.UI) === null || _entityType$annotatio3 === void 0 ? void 0 : _entityType$annotatio3.LineItem;
+  }
+
+  _exports.getDefaultLineItem = getDefaultLineItem;
+
+  function getDefaultChart(entityType) {
+    var _entityType$annotatio4;
+
+    return (_entityType$annotatio4 = entityType.annotations.UI) === null || _entityType$annotatio4 === void 0 ? void 0 : _entityType$annotatio4.Chart;
+  }
+
+  _exports.getDefaultChart = getDefaultChart;
+
+  function getDefaultPresentationVariant(entityType) {
+    var _entityType$annotatio5, _entityType$annotatio6;
+
+    return (_entityType$annotatio5 = entityType.annotations) === null || _entityType$annotatio5 === void 0 ? void 0 : (_entityType$annotatio6 = _entityType$annotatio5.UI) === null || _entityType$annotatio6 === void 0 ? void 0 : _entityType$annotatio6.PresentationVariant;
+  }
+
+  _exports.getDefaultPresentationVariant = getDefaultPresentationVariant;
+
+  function getDefaultSelectionVariant(entityType) {
+    var _entityType$annotatio7, _entityType$annotatio8;
+
+    return (_entityType$annotatio7 = entityType.annotations) === null || _entityType$annotatio7 === void 0 ? void 0 : (_entityType$annotatio8 = _entityType$annotatio7.UI) === null || _entityType$annotatio8 === void 0 ? void 0 : _entityType$annotatio8.SelectionVariant;
+  }
+
+  _exports.getDefaultSelectionVariant = getDefaultSelectionVariant;
+
+  function getSelectionVariant(entityType, converterContext) {
+    var annotationPath = converterContext.getManifestWrapper().getDefaultTemplateAnnotationPath();
+    var selectionPresentationVariant = getSelectionPresentationVariant(entityType, annotationPath, converterContext);
+    var selectionVariant;
+
+    if (selectionPresentationVariant) {
+      var _selectionVariant = selectionPresentationVariant.SelectionVariant;
+
+      if (_selectionVariant) {
+        return _selectionVariant;
+      }
+    } else {
+      selectionVariant = getDefaultSelectionVariant(entityType);
+      return selectionVariant;
+    }
+  }
+
+  _exports.getSelectionVariant = getSelectionVariant;
+
+  function getDataVisualizationConfiguration(visualizationPath, isCondensedTableLayoutCompliant, converterContext, viewConfiguration, doNotCheckApplySupported) {
+    var resolvedTarget = converterContext.getEntityTypeAnnotation(visualizationPath);
+    var visualization = resolvedTarget.annotation;
+    converterContext = resolvedTarget.converterContext;
+    var visualizationAnnotations = [];
+    var presentationVariantAnnotation;
+    var presentationPath = "";
+    var chartVisualization, tableVisualization;
+    var sTerm = visualization === null || visualization === void 0 ? void 0 : visualization.term;
+
+    if (sTerm) {
+      switch (sTerm) {
+        case "com.sap.vocabularies.UI.v1.LineItem":
+        case "com.sap.vocabularies.UI.v1.Chart":
+          visualizationAnnotations.push({
+            visualization: visualization,
+            annotationPath: visualizationPath,
+            converterContext: converterContext
+          });
+          break;
+
+        case "com.sap.vocabularies.UI.v1.PresentationVariant":
+          presentationVariantAnnotation = visualization;
+          visualizationAnnotations = visualizationAnnotations.concat(getVisualizationsFromPresentationVariant(visualization, visualizationPath, converterContext, viewConfiguration));
+          break;
+
+        case "com.sap.vocabularies.UI.v1.SelectionPresentationVariant":
+          presentationVariantAnnotation = visualization.PresentationVariant; // Presentation can be inline or outside the SelectionPresentationVariant
+
+          presentationPath = presentationVariantAnnotation.fullyQualifiedName;
+
+          if (!isPresentationCompliant(presentationVariantAnnotation)) {
+            var entityType = converterContext.getEntityType();
+            var defaultLineItemAnnotation = getDefaultLineItem(entityType);
+
+            if (defaultLineItemAnnotation) {
+              visualizationAnnotations.push({
+                visualization: defaultLineItemAnnotation,
+                annotationPath: converterContext.getRelativeAnnotationPath(defaultLineItemAnnotation.fullyQualifiedName, entityType),
+                converterContext: converterContext
+              });
+            }
+          } else {
+            visualizationAnnotations = visualizationAnnotations.concat(getVisualizationsFromPresentationVariant(presentationVariantAnnotation, visualizationPath, converterContext, viewConfiguration));
+          }
+
+          break;
+
+        default:
+          break;
+      }
+
+      visualizationAnnotations.map(function (visualizationAnnotation) {
+        var visualization = visualizationAnnotation.visualization,
+            annotationPath = visualizationAnnotation.annotationPath,
+            converterContext = visualizationAnnotation.converterContext;
+
+        switch (visualization.term) {
+          case "com.sap.vocabularies.UI.v1.Chart":
+            chartVisualization = createChartVisualization(visualization, annotationPath, converterContext, doNotCheckApplySupported);
+            break;
+
+          case "com.sap.vocabularies.UI.v1.LineItem":
+          default:
+            tableVisualization = createTableVisualization(visualization, annotationPath, converterContext, presentationVariantAnnotation, isCondensedTableLayoutCompliant, viewConfiguration);
+            break;
+        }
+      });
+    } else {
+      tableVisualization = createDefaultTableVisualization(converterContext);
+      converterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.MISSING_LINEITEM);
+    }
+
+    var aVisualizations = [];
+    var sPath = sTerm === "com.sap.vocabularies.UI.v1.SelectionPresentationVariant" ? presentationPath : visualization && visualization.fullyQualifiedName;
+
+    if (sPath === undefined) {
+      sPath = "/";
+    }
+
+    if (chartVisualization) {
+      aVisualizations.push(chartVisualization);
+    }
+
+    if (tableVisualization) {
+      aVisualizations.push(tableVisualization);
+    }
+
+    return {
+      visualizations: aVisualizations,
+      annotationPath: converterContext.getEntitySetBasedAnnotationPath(sPath)
+    };
+  }
+
+  _exports.getDataVisualizationConfiguration = getDataVisualizationConfiguration;
+  return _exports;
+}, false);
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["DataVisualization.ts"],"names":["getVisualizationsFromPresentationVariant","presentationVariantAnnotation","visualizationPath","converterContext","viewConfiguration","visualizationAnnotations","visualizations","Visualizations","baseVisualizationPath","split","hasLineItem","hasChart","hasVisualization","forEach","visualization","$target","term","getTemplateType","TemplateType","ObjectPage","push","annotationPath","value","getManifestWrapper","hasMultipleVisualizations","ListReport","AnalyticalListPage","getViewConfiguration","getSelectionPresentationVariant","entityType","resolvedTarget","getEntityTypeAnnotation","selectionPresentationVariant","annotation","Error","annotations","UI","SelectionPresentationVariant","isSelectionPresentationCompliant","bIsALP","presentationVariant","PresentationVariant","isPresentationCompliant","bHasTable","bHasChart","aVisualizations","map","oVisualization","find","getDefaultLineItem","LineItem","getDefaultChart","Chart","getDefaultPresentationVariant","getDefaultSelectionVariant","SelectionVariant","getSelectionVariant","getDefaultTemplateAnnotationPath","selectionVariant","getDataVisualizationConfiguration","isCondensedTableLayoutCompliant","doNotCheckApplySupported","presentationPath","chartVisualization","tableVisualization","sTerm","concat","fullyQualifiedName","getEntityType","defaultLineItemAnnotation","getRelativeAnnotationPath","visualizationAnnotation","createChartVisualization","createTableVisualization","createDefaultTableVisualization","getDiagnostics","addIssue","IssueCategory","Annotation","IssueSeverity","Medium","IssueType","MISSING_LINEITEM","sPath","undefined","getEntitySetBasedAnnotationPath"],"mappings":";AAAA;AACA;AACA;;;;;;;;;;;;;AAqCA,MAAMA,wCAAwC,GAAG,UAChDC,6BADgD,EAEhDC,iBAFgD,EAGhDC,gBAHgD,EAIhDC,iBAJgD,EAKvB;AACzB,QAAMC,wBAAgD,GAAG,EAAzD;AACA,QAAMC,cAAc,GAAGL,6BAA6B,CAACM,cAA9B,IAAgD,EAAvE;AACA,QAAMC,qBAAqB,GAAGN,iBAAiB,CAACO,KAAlB,CAAwB,GAAxB,EAA6B,CAA7B,CAA9B;;AACA,QAAIH,cAAJ,EAAoB;AACnB;AACA,UAAII,WAAW,GAAG,KAAlB;AACA,UAAIC,QAAQ,GAAG,KAAf;AACA,UAAIC,gBAAgB,GAAG,KAAvB,CAJmB,CAIW;;AAC9BN,MAAAA,cAAc,CAACO,OAAf,CAAuB,UAAAC,aAAa,EAAI;AACvC,gBAAQA,aAAa,CAACC,OAAd,CAAsBC,IAA9B;AACC;AACC,gBAAI,CAACN,WAAL,EAAkB;AACjB,kBAAI,EAAEP,gBAAgB,CAACc,eAAjB,OAAuCC,YAAY,CAACC,UAApD,IAAkEP,gBAApE,CAAJ,EAA2F;AAC1FP,gBAAAA,wBAAwB,CAACe,IAAzB,CAA8B;AAC7BN,kBAAAA,aAAa,EAAEA,aAAa,CAACC,OADA;AAE7BM,kBAAAA,cAAc,YAAKb,qBAAL,SAA6BM,aAAa,CAACQ,KAA3C,CAFe;AAG7BnB,kBAAAA,gBAAgB,EAAEA;AAHW,iBAA9B;AAKAO,gBAAAA,WAAW,GAAG,IAAd;AACAE,gBAAAA,gBAAgB,GAAG,IAAnB;AACA;AACD;;AACD;;AACD;AACC,gBACC,CAACD,QAAD,KACEP,iBAAiB,IAClBD,gBAAgB,CAACoB,kBAAjB,GAAsCC,yBAAtC,CAAgEpB,iBAAhE,CADC,IAEDD,gBAAgB,CAACc,eAAjB,OAAuCC,YAAY,CAACO,UAFpD,IAGCtB,gBAAgB,CAACc,eAAjB,OAAuCC,YAAY,CAACQ,kBAApD,IACA,CAACvB,gBAAgB,CAACoB,kBAAjB,GAAsCI,oBAAtC,EAJF,IAKCxB,gBAAgB,CAACc,eAAjB,OAAuCC,YAAY,CAACC,UAApD,IAAkE,CAACP,gBANrE,CADD,EAQE;AACDP,cAAAA,wBAAwB,CAACe,IAAzB,CAA8B;AAC7BN,gBAAAA,aAAa,EAAEA,aAAa,CAACC,OADA;AAE7BM,gBAAAA,cAAc,YAAKb,qBAAL,SAA6BM,aAAa,CAACQ,KAA3C,CAFe;AAG7BnB,gBAAAA,gBAAgB,EAAEA;AAHW,eAA9B;AAKAQ,cAAAA,QAAQ,GAAG,IAAX;AACAC,cAAAA,gBAAgB,GAAG,IAAnB;AACA;;AACD;;AACD;AACC;AAlCF;AAoCA,OArCD;AAsCA;;AACD,WAAOP,wBAAP;AACA,GAtDD;;AAwDO,WAASuB,+BAAT,CACNC,UADM,EAENR,cAFM,EAGNlB,gBAHM,EAIA;AACN,QAAIkB,cAAJ,EAAoB;AACnB,UAAMS,cAAc,GAAG3B,gBAAgB,CAAC4B,uBAAjB,CAAyCV,cAAzC,CAAvB;AACA,UAAMW,4BAA4B,GAAGF,cAAc,CAACG,UAApD;;AACA,UAAID,4BAAJ,EAAkC;AACjC,YAAIA,4BAA4B,CAAChB,IAA7B,8DAAJ,EAA0F;AACzF,iBAAOgB,4BAAP;AACA;AACD,OAJD,MAIO;AACN,cAAM,IAAIE,KAAJ,CAAU,0GAAV,CAAN;AACA;AACD,KAVD,MAUO;AAAA;;AACN,sCAAOL,UAAU,CAACM,WAAlB,oFAAO,sBAAwBC,EAA/B,2DAAO,uBAA4BC,4BAAnC;AACA;AACD;;;;AAEM,WAASC,gCAAT,CACND,4BADM,EAENE,MAFM,EAGgB;AACtB,QAAMC,mBAAmB,GAAGH,4BAA4B,IAAIA,4BAA4B,CAACI,mBAAzF;;AACA,QAAID,mBAAJ,EAAyB;AACxB,aAAOE,uBAAuB,CAACF,mBAAD,EAAsBD,MAAtB,CAA9B;AACA,KAFD,MAEO;AACN,YAAM,IAAIL,KAAJ,CAAU,2DAAV,CAAN;AACA;AACD;;;;AAEM,WAASQ,uBAAT,CAAiCF,mBAAjC,EAAoFD,MAApF,EAA+G;AACrH,QAAII,SAAS,GAAG,KAAhB;AAAA,QACCC,SAAS,GAAG,KADb;;AAEA,QAAIL,MAAJ,EAAY;AACX,UAAIC,mBAAmB,IAAIA,mBAAmB,CAACjC,cAA/C,EAA+D;AAC9D,YAAMsC,eAAe,GAAGL,mBAAmB,CAACjC,cAA5C;AACAsC,QAAAA,eAAe,CAACC,GAAhB,CAAoB,UAAAC,cAAc,EAAI;AACrC,cAAIA,cAAc,CAAChC,OAAf,CAAuBC,IAAvB,0CAAJ,EAAgE;AAC/D2B,YAAAA,SAAS,GAAG,IAAZ;AACA;;AACD,cAAII,cAAc,CAAChC,OAAf,CAAuBC,IAAvB,uCAAJ,EAA6D;AAC5D4B,YAAAA,SAAS,GAAG,IAAZ;AACA;AACD,SAPD;AAQA;;AACD,aAAOA,SAAS,IAAID,SAApB;AACA,KAbD,MAaO;AACN,aACCH,mBAAmB,IACnBA,mBAAmB,CAACjC,cADpB,IAEA,CAAC,CAACiC,mBAAmB,CAACjC,cAApB,CAAmCyC,IAAnC,CAAwC,UAAAlC,aAAa,EAAI;AAC1D,eAAOA,aAAa,CAACC,OAAd,CAAsBC,IAAtB,0CAAP;AACA,OAFC,CAHH;AAOA;AACD;;;;AAEM,WAASiC,kBAAT,CAA4BpB,UAA5B,EAA0E;AAAA;;AAChF,qCAAOA,UAAU,CAACM,WAAX,CAAuBC,EAA9B,2DAAO,uBAA2Bc,QAAlC;AACA;;;;AACM,WAASC,eAAT,CAAyBtB,UAAzB,EAAoE;AAAA;;AAC1E,qCAAOA,UAAU,CAACM,WAAX,CAAuBC,EAA9B,2DAAO,uBAA2BgB,KAAlC;AACA;;;;AACM,WAASC,6BAAT,CAAuCxB,UAAvC,EAAyG;AAAA;;AAC/G,qCAAOA,UAAU,CAACM,WAAlB,qFAAO,uBAAwBC,EAA/B,2DAAO,uBAA4BK,mBAAnC;AACA;;;;AAEM,WAASa,0BAAT,CAAoCzB,UAApC,EAAmG;AAAA;;AACzG,qCAAOA,UAAU,CAACM,WAAlB,qFAAO,uBAAwBC,EAA/B,2DAAO,uBAA4BmB,gBAAnC;AACA;;;;AAEM,WAASC,mBAAT,CAA6B3B,UAA7B,EAAqD1B,gBAArD,EAAgI;AACtI,QAAMkB,cAAc,GAAGlB,gBAAgB,CAACoB,kBAAjB,GAAsCkC,gCAAtC,EAAvB;AACA,QAAMzB,4BAA4B,GAAGJ,+BAA+B,CAACC,UAAD,EAAaR,cAAb,EAA6BlB,gBAA7B,CAApE;AACA,QAAIuD,gBAAJ;;AACA,QAAI1B,4BAAJ,EAAkC;AACjC,UAAM0B,iBAAgB,GAAG1B,4BAA4B,CAACuB,gBAAtD;;AACA,UAAIG,iBAAJ,EAAsB;AACrB,eAAOA,iBAAP;AACA;AACD,KALD,MAKO;AACNA,MAAAA,gBAAgB,GAAGJ,0BAA0B,CAACzB,UAAD,CAA7C;AACA,aAAO6B,gBAAP;AACA;AACD;;;;AAEM,WAASC,iCAAT,CACNzD,iBADM,EAEN0D,+BAFM,EAGNzD,gBAHM,EAINC,iBAJM,EAKNyD,wBALM,EAMwB;AAC9B,QAAM/B,cAAc,GAAG3B,gBAAgB,CAAC4B,uBAAjB,CAAyC7B,iBAAzC,CAAvB;AACA,QAAMY,aAAa,GAAGgB,cAAc,CAACG,UAArC;AACA9B,IAAAA,gBAAgB,GAAG2B,cAAc,CAAC3B,gBAAlC;AACA,QAAIE,wBAAgD,GAAG,EAAvD;AACA,QAAIJ,6BAAJ;AACA,QAAI6D,gBAAwB,GAAG,EAA/B;AACA,QAAIC,kBAAJ,EAAwBC,kBAAxB;AACA,QAAMC,KAAK,GAAGnD,aAAH,aAAGA,aAAH,uBAAGA,aAAa,CAAEE,IAA7B;;AACA,QAAIiD,KAAJ,EAAW;AACV,cAAQA,KAAR;AACC;AACA;AACC5D,UAAAA,wBAAwB,CAACe,IAAzB,CAA8B;AAC7BN,YAAAA,aAAa,EAAEA,aADc;AAE7BO,YAAAA,cAAc,EAAEnB,iBAFa;AAG7BC,YAAAA,gBAAgB,EAAEA;AAHW,WAA9B;AAKA;;AACD;AACCF,UAAAA,6BAA6B,GAAGa,aAAhC;AACAT,UAAAA,wBAAwB,GAAGA,wBAAwB,CAAC6D,MAAzB,CAC1BlE,wCAAwC,CACvCc,aADuC,EAEvCZ,iBAFuC,EAGvCC,gBAHuC,EAIvCC,iBAJuC,CADd,CAA3B;AAQA;;AACD;AACCH,UAAAA,6BAA6B,GAAIa,aAAD,CAAyD2B,mBAAzF,CADD,CAEC;;AACAqB,UAAAA,gBAAgB,GAAG7D,6BAA6B,CAACkE,kBAAjD;;AAEA,cAAI,CAACzB,uBAAuB,CAACzC,6BAAD,CAA5B,EAA6D;AAC5D,gBAAM4B,UAAU,GAAG1B,gBAAgB,CAACiE,aAAjB,EAAnB;AACA,gBAAMC,yBAAyB,GAAGpB,kBAAkB,CAACpB,UAAD,CAApD;;AACA,gBAAIwC,yBAAJ,EAA+B;AAC9BhE,cAAAA,wBAAwB,CAACe,IAAzB,CAA8B;AAC7BN,gBAAAA,aAAa,EAAEuD,yBADc;AAE7BhD,gBAAAA,cAAc,EAAElB,gBAAgB,CAACmE,yBAAjB,CACfD,yBAAyB,CAACF,kBADX,EAEftC,UAFe,CAFa;AAM7B1B,gBAAAA,gBAAgB,EAAEA;AANW,eAA9B;AAQA;AACD,WAbD,MAaO;AACNE,YAAAA,wBAAwB,GAAGA,wBAAwB,CAAC6D,MAAzB,CAC1BlE,wCAAwC,CACvCC,6BADuC,EAEvCC,iBAFuC,EAGvCC,gBAHuC,EAIvCC,iBAJuC,CADd,CAA3B;AAQA;;AACD;;AACD;AACC;AAlDF;;AAoDAC,MAAAA,wBAAwB,CAACyC,GAAzB,CAA6B,UAAAyB,uBAAuB,EAAI;AACvD,YAAQzD,aAAR,GAA4DyD,uBAA5D,CAAQzD,aAAR;AAAA,YAAuBO,cAAvB,GAA4DkD,uBAA5D,CAAuBlD,cAAvB;AAAA,YAAuClB,gBAAvC,GAA4DoE,uBAA5D,CAAuCpE,gBAAvC;;AACA,gBAAQW,aAAa,CAACE,IAAtB;AACC;AACC+C,YAAAA,kBAAkB,GAAGS,wBAAwB,CAC5C1D,aAD4C,EAE5CO,cAF4C,EAG5ClB,gBAH4C,EAI5C0D,wBAJ4C,CAA7C;AAMA;;AACD;AACA;AACCG,YAAAA,kBAAkB,GAAGS,wBAAwB,CAC5C3D,aAD4C,EAE5CO,cAF4C,EAG5ClB,gBAH4C,EAI5CF,6BAJ4C,EAK5C2D,+BAL4C,EAM5CxD,iBAN4C,CAA7C;AAQA;AAnBF;AAqBA,OAvBD;AAwBA,KA7ED,MA6EO;AACN4D,MAAAA,kBAAkB,GAAGU,+BAA+B,CAACvE,gBAAD,CAApD;AACAA,MAAAA,gBAAgB,CAACwE,cAAjB,GAAkCC,QAAlC,CAA2CC,aAAa,CAACC,UAAzD,EAAqEC,aAAa,CAACC,MAAnF,EAA2FC,SAAS,CAACC,gBAArG;AACA;;AACD,QAAMrC,eAAoB,GAAG,EAA7B;AACA,QAAIsC,KAAK,GACRlB,KAAK,8DAAL,GAA2DH,gBAA3D,GAA8EhD,aAAa,IAAIA,aAAa,CAACqD,kBAD9G;;AAEA,QAAIgB,KAAK,KAAKC,SAAd,EAAyB;AACxBD,MAAAA,KAAK,GAAG,GAAR;AACA;;AACD,QAAIpB,kBAAJ,EAAwB;AACvBlB,MAAAA,eAAe,CAACzB,IAAhB,CAAqB2C,kBAArB;AACA;;AACD,QAAIC,kBAAJ,EAAwB;AACvBnB,MAAAA,eAAe,CAACzB,IAAhB,CAAqB4C,kBAArB;AACA;;AACD,WAAO;AACN1D,MAAAA,cAAc,EAAEuC,eADV;AAENxB,MAAAA,cAAc,EAAElB,gBAAgB,CAACkF,+BAAjB,CAAiDF,KAAjD;AAFV,KAAP;AAIA","sourceRoot":".","sourcesContent":["import {\n\tChart,\n\tChartDefinitionTypeTypes,\n\tEntityType,\n\tLineItem,\n\tPresentationVariantTypeTypes,\n\tSelectionPresentationVariantTypeTypes,\n\tSelectionVariantTypeTypes,\n\tUIAnnotationTerms\n} from \"@sap-ux/vocabularies-types\";\n\nimport { createDefaultTableVisualization, createTableVisualization, TableVisualization } from \"./Table\";\nimport { ChartVisualization, createChartVisualization } from \"./Chart\";\nimport { IssueType, IssueSeverity, IssueCategory } from \"sap/fe/core/converters/helpers/IssueManager\";\nimport ConverterContext from \"../../ConverterContext\";\nimport { TemplateType, ViewPathConfiguration } from \"../../ManifestSettings\";\n\nexport type DataVisualizationAnnotations =\n\t| LineItem\n\t| Chart\n\t| PresentationVariantTypeTypes\n\t| SelectionVariantTypeTypes\n\t| SelectionPresentationVariantTypeTypes;\n// | ChartDefinitionTypeTypes;\n\nexport type ActualVisualizationAnnotations = LineItem | ChartDefinitionTypeTypes;\n\ntype VisualizationAndPath = {\n\tvisualization: ActualVisualizationAnnotations;\n\tannotationPath: string;\n\tselectionVariantPath?: string;\n\tconverterContext: ConverterContext;\n};\n\nexport type DataVisualizationDefinition = {\n\tvisualizations: (TableVisualization | ChartVisualization)[];\n\tannotationPath: string;\n};\n\nconst getVisualizationsFromPresentationVariant = function(\n\tpresentationVariantAnnotation: PresentationVariantTypeTypes,\n\tvisualizationPath: string,\n\tconverterContext: ConverterContext,\n\tviewConfiguration?: ViewPathConfiguration\n): VisualizationAndPath[] {\n\tconst visualizationAnnotations: VisualizationAndPath[] = [];\n\tconst visualizations = presentationVariantAnnotation.Visualizations || [];\n\tconst baseVisualizationPath = visualizationPath.split(\"@\")[0];\n\tif (visualizations) {\n\t\t// Only allow one line item / chart\n\t\tlet hasLineItem = false;\n\t\tlet hasChart = false;\n\t\tlet hasVisualization = false; // used to allow only first visualization in OP\n\t\tvisualizations.forEach(visualization => {\n\t\t\tswitch (visualization.$target.term) {\n\t\t\t\tcase UIAnnotationTerms.LineItem:\n\t\t\t\t\tif (!hasLineItem) {\n\t\t\t\t\t\tif (!(converterContext.getTemplateType() === TemplateType.ObjectPage && hasVisualization)) {\n\t\t\t\t\t\t\tvisualizationAnnotations.push({\n\t\t\t\t\t\t\t\tvisualization: visualization.$target as ActualVisualizationAnnotations,\n\t\t\t\t\t\t\t\tannotationPath: `${baseVisualizationPath}${visualization.value}`,\n\t\t\t\t\t\t\t\tconverterContext: converterContext\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\thasLineItem = true;\n\t\t\t\t\t\t\thasVisualization = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase UIAnnotationTerms.Chart:\n\t\t\t\t\tif (\n\t\t\t\t\t\t!hasChart &&\n\t\t\t\t\t\t((viewConfiguration &&\n\t\t\t\t\t\t\tconverterContext.getManifestWrapper().hasMultipleVisualizations(viewConfiguration) &&\n\t\t\t\t\t\t\tconverterContext.getTemplateType() === TemplateType.ListReport) ||\n\t\t\t\t\t\t\t(converterContext.getTemplateType() === TemplateType.AnalyticalListPage &&\n\t\t\t\t\t\t\t\t!converterContext.getManifestWrapper().getViewConfiguration()) ||\n\t\t\t\t\t\t\t(converterContext.getTemplateType() === TemplateType.ObjectPage && !hasVisualization))\n\t\t\t\t\t) {\n\t\t\t\t\t\tvisualizationAnnotations.push({\n\t\t\t\t\t\t\tvisualization: visualization.$target as ActualVisualizationAnnotations,\n\t\t\t\t\t\t\tannotationPath: `${baseVisualizationPath}${visualization.value}`,\n\t\t\t\t\t\t\tconverterContext: converterContext\n\t\t\t\t\t\t});\n\t\t\t\t\t\thasChart = true;\n\t\t\t\t\t\thasVisualization = true;\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t});\n\t}\n\treturn visualizationAnnotations;\n};\n\nexport function getSelectionPresentationVariant(\n\tentityType: EntityType,\n\tannotationPath: string | undefined,\n\tconverterContext: ConverterContext\n): any {\n\tif (annotationPath) {\n\t\tconst resolvedTarget = converterContext.getEntityTypeAnnotation(annotationPath);\n\t\tconst selectionPresentationVariant = resolvedTarget.annotation as SelectionPresentationVariantTypeTypes;\n\t\tif (selectionPresentationVariant) {\n\t\t\tif (selectionPresentationVariant.term === UIAnnotationTerms.SelectionPresentationVariant) {\n\t\t\t\treturn selectionPresentationVariant;\n\t\t\t}\n\t\t} else {\n\t\t\tthrow new Error(\"Annotation Path for the SPV mentioned in the manifest is not found, Please add the SPV in the annotation\");\n\t\t}\n\t} else {\n\t\treturn entityType.annotations?.UI?.SelectionPresentationVariant;\n\t}\n}\n\nexport function isSelectionPresentationCompliant(\n\tSelectionPresentationVariant: SelectionPresentationVariantTypeTypes,\n\tbIsALP: Boolean\n): Boolean | undefined {\n\tconst presentationVariant = SelectionPresentationVariant && SelectionPresentationVariant.PresentationVariant;\n\tif (presentationVariant) {\n\t\treturn isPresentationCompliant(presentationVariant, bIsALP);\n\t} else {\n\t\tthrow new Error(\"Presentation Variant is not present in the SPV annotation\");\n\t}\n}\n\nexport function isPresentationCompliant(presentationVariant: PresentationVariantTypeTypes, bIsALP?: Boolean): Boolean {\n\tlet bHasTable = false,\n\t\tbHasChart = false;\n\tif (bIsALP) {\n\t\tif (presentationVariant && presentationVariant.Visualizations) {\n\t\t\tconst aVisualizations = presentationVariant.Visualizations;\n\t\t\taVisualizations.map(oVisualization => {\n\t\t\t\tif (oVisualization.$target.term === UIAnnotationTerms.LineItem) {\n\t\t\t\t\tbHasTable = true;\n\t\t\t\t}\n\t\t\t\tif (oVisualization.$target.term === UIAnnotationTerms.Chart) {\n\t\t\t\t\tbHasChart = true;\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn bHasChart && bHasTable;\n\t} else {\n\t\treturn (\n\t\t\tpresentationVariant &&\n\t\t\tpresentationVariant.Visualizations &&\n\t\t\t!!presentationVariant.Visualizations.find(visualization => {\n\t\t\t\treturn visualization.$target.term === UIAnnotationTerms.LineItem;\n\t\t\t})\n\t\t);\n\t}\n}\n\nexport function getDefaultLineItem(entityType: EntityType): LineItem | undefined {\n\treturn entityType.annotations.UI?.LineItem;\n}\nexport function getDefaultChart(entityType: EntityType): Chart | undefined {\n\treturn entityType.annotations.UI?.Chart;\n}\nexport function getDefaultPresentationVariant(entityType: EntityType): PresentationVariantTypeTypes | undefined {\n\treturn entityType.annotations?.UI?.PresentationVariant;\n}\n\nexport function getDefaultSelectionVariant(entityType: EntityType): SelectionVariantTypeTypes | undefined {\n\treturn entityType.annotations?.UI?.SelectionVariant;\n}\n\nexport function getSelectionVariant(entityType: EntityType, converterContext: ConverterContext): SelectionVariantTypeTypes | undefined {\n\tconst annotationPath = converterContext.getManifestWrapper().getDefaultTemplateAnnotationPath();\n\tconst selectionPresentationVariant = getSelectionPresentationVariant(entityType, annotationPath, converterContext);\n\tlet selectionVariant;\n\tif (selectionPresentationVariant) {\n\t\tconst selectionVariant = selectionPresentationVariant.SelectionVariant;\n\t\tif (selectionVariant) {\n\t\t\treturn selectionVariant;\n\t\t}\n\t} else {\n\t\tselectionVariant = getDefaultSelectionVariant(entityType);\n\t\treturn selectionVariant;\n\t}\n}\n\nexport function getDataVisualizationConfiguration(\n\tvisualizationPath: string,\n\tisCondensedTableLayoutCompliant: boolean,\n\tconverterContext: ConverterContext,\n\tviewConfiguration?: ViewPathConfiguration,\n\tdoNotCheckApplySupported?: boolean\n): DataVisualizationDefinition {\n\tconst resolvedTarget = converterContext.getEntityTypeAnnotation(visualizationPath);\n\tconst visualization = resolvedTarget.annotation as DataVisualizationAnnotations;\n\tconverterContext = resolvedTarget.converterContext;\n\tlet visualizationAnnotations: VisualizationAndPath[] = [];\n\tlet presentationVariantAnnotation: PresentationVariantTypeTypes;\n\tlet presentationPath: string = \"\";\n\tlet chartVisualization, tableVisualization;\n\tconst sTerm = visualization?.term;\n\tif (sTerm) {\n\t\tswitch (sTerm) {\n\t\t\tcase UIAnnotationTerms.LineItem:\n\t\t\tcase UIAnnotationTerms.Chart:\n\t\t\t\tvisualizationAnnotations.push({\n\t\t\t\t\tvisualization: visualization as ActualVisualizationAnnotations,\n\t\t\t\t\tannotationPath: visualizationPath,\n\t\t\t\t\tconverterContext: converterContext\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase UIAnnotationTerms.PresentationVariant:\n\t\t\t\tpresentationVariantAnnotation = visualization as PresentationVariantTypeTypes;\n\t\t\t\tvisualizationAnnotations = visualizationAnnotations.concat(\n\t\t\t\t\tgetVisualizationsFromPresentationVariant(\n\t\t\t\t\t\tvisualization as PresentationVariantTypeTypes,\n\t\t\t\t\t\tvisualizationPath,\n\t\t\t\t\t\tconverterContext,\n\t\t\t\t\t\tviewConfiguration\n\t\t\t\t\t)\n\t\t\t\t);\n\t\t\t\tbreak;\n\t\t\tcase UIAnnotationTerms.SelectionPresentationVariant:\n\t\t\t\tpresentationVariantAnnotation = (visualization as SelectionPresentationVariantTypeTypes).PresentationVariant;\n\t\t\t\t// Presentation can be inline or outside the SelectionPresentationVariant\n\t\t\t\tpresentationPath = presentationVariantAnnotation.fullyQualifiedName;\n\n\t\t\t\tif (!isPresentationCompliant(presentationVariantAnnotation)) {\n\t\t\t\t\tconst entityType = converterContext.getEntityType();\n\t\t\t\t\tconst defaultLineItemAnnotation = getDefaultLineItem(entityType) as LineItem;\n\t\t\t\t\tif (defaultLineItemAnnotation) {\n\t\t\t\t\t\tvisualizationAnnotations.push({\n\t\t\t\t\t\t\tvisualization: defaultLineItemAnnotation,\n\t\t\t\t\t\t\tannotationPath: converterContext.getRelativeAnnotationPath(\n\t\t\t\t\t\t\t\tdefaultLineItemAnnotation.fullyQualifiedName,\n\t\t\t\t\t\t\t\tentityType\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tconverterContext: converterContext\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tvisualizationAnnotations = visualizationAnnotations.concat(\n\t\t\t\t\t\tgetVisualizationsFromPresentationVariant(\n\t\t\t\t\t\t\tpresentationVariantAnnotation,\n\t\t\t\t\t\t\tvisualizationPath,\n\t\t\t\t\t\t\tconverterContext,\n\t\t\t\t\t\t\tviewConfiguration\n\t\t\t\t\t\t)\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t\tvisualizationAnnotations.map(visualizationAnnotation => {\n\t\t\tconst { visualization, annotationPath, converterContext } = visualizationAnnotation;\n\t\t\tswitch (visualization.term) {\n\t\t\t\tcase UIAnnotationTerms.Chart:\n\t\t\t\t\tchartVisualization = createChartVisualization(\n\t\t\t\t\t\tvisualization as ChartDefinitionTypeTypes,\n\t\t\t\t\t\tannotationPath,\n\t\t\t\t\t\tconverterContext,\n\t\t\t\t\t\tdoNotCheckApplySupported\n\t\t\t\t\t);\n\t\t\t\t\tbreak;\n\t\t\t\tcase UIAnnotationTerms.LineItem:\n\t\t\t\tdefault:\n\t\t\t\t\ttableVisualization = createTableVisualization(\n\t\t\t\t\t\tvisualization as LineItem,\n\t\t\t\t\t\tannotationPath,\n\t\t\t\t\t\tconverterContext,\n\t\t\t\t\t\tpresentationVariantAnnotation,\n\t\t\t\t\t\tisCondensedTableLayoutCompliant,\n\t\t\t\t\t\tviewConfiguration\n\t\t\t\t\t);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t});\n\t} else {\n\t\ttableVisualization = createDefaultTableVisualization(converterContext);\n\t\tconverterContext.getDiagnostics().addIssue(IssueCategory.Annotation, IssueSeverity.Medium, IssueType.MISSING_LINEITEM);\n\t}\n\tconst aVisualizations: any = [];\n\tlet sPath =\n\t\tsTerm === UIAnnotationTerms.SelectionPresentationVariant ? presentationPath : visualization && visualization.fullyQualifiedName;\n\tif (sPath === undefined) {\n\t\tsPath = \"/\";\n\t}\n\tif (chartVisualization) {\n\t\taVisualizations.push(chartVisualization);\n\t}\n\tif (tableVisualization) {\n\t\taVisualizations.push(tableVisualization);\n\t}\n\treturn {\n\t\tvisualizations: aVisualizations,\n\t\tannotationPath: converterContext.getEntitySetBasedAnnotationPath(sPath)\n\t};\n}\n"]}

package/packages/sap.fe.core/src/sap/fe/core/converters/controls/Common/DataVisualization.js

@@ -0,0 +1,5 @@
+/*!
+ * SAP UI development toolkit for HTML5 (SAPUI5)
+ *      (c) Copyright 2009-2021 SAP SE. All rights reserved
+ */
+sap.ui.define(["./Table","./Chart","sap/fe/core/converters/helpers/IssueManager","../../ManifestSettings"],function(T,C,I,M){"use strict";var _={};var a=M.TemplateType;var b=I.IssueCategory;var c=I.IssueSeverity;var d=I.IssueType;var e=C.createChartVisualization;var f=T.createTableVisualization;var g=T.createDefaultTableVisualization;var h=function(r,v,s,t){var u=[];var w=r.Visualizations||[];var x=v.split("@")[0];if(w){var y=false;var z=false;var A=false;w.forEach(function(B){switch(B.$target.term){case"com.sap.vocabularies.UI.v1.LineItem":if(!y){if(!(s.getTemplateType()===a.ObjectPage&&A)){u.push({visualization:B.$target,annotationPath:"".concat(x).concat(B.value),converterContext:s});y=true;A=true;}}break;case"com.sap.vocabularies.UI.v1.Chart":if(!z&&(t&&s.getManifestWrapper().hasMultipleVisualizations(t)&&s.getTemplateType()===a.ListReport||s.getTemplateType()===a.AnalyticalListPage&&!s.getManifestWrapper().getViewConfiguration()||s.getTemplateType()===a.ObjectPage&&!A)){u.push({visualization:B.$target,annotationPath:"".concat(x).concat(B.value),converterContext:s});z=true;A=true;}break;default:break;}});}return u;};function i(r,s,t){if(s){var u=t.getEntityTypeAnnotation(s);var v=u.annotation;if(v){if(v.term==="com.sap.vocabularies.UI.v1.SelectionPresentationVariant"){return v;}}else{throw new Error("Annotation Path for the SPV mentioned in the manifest is not found, Please add the SPV in the annotation");}}else{var w,x;return(w=r.annotations)===null||w===void 0?void 0:(x=w.UI)===null||x===void 0?void 0:x.SelectionPresentationVariant;}}_.getSelectionPresentationVariant=i;function j(S,r){var s=S&&S.PresentationVariant;if(s){return k(s,r);}else{throw new Error("Presentation Variant is not present in the SPV annotation");}}_.isSelectionPresentationCompliant=j;function k(r,s){var H=false,t=false;if(s){if(r&&r.Visualizations){var v=r.Visualizations;v.map(function(V){if(V.$target.term==="com.sap.vocabularies.UI.v1.LineItem"){H=true;}if(V.$target.term==="com.sap.vocabularies.UI.v1.Chart"){t=true;}});}return t&&H;}else{return r&&r.Visualizations&&!!r.Visualizations.find(function(u){return u.$target.term==="com.sap.vocabularies.UI.v1.LineItem";});}}_.isPresentationCompliant=k;function l(r){var s;return(s=r.annotations.UI)===null||s===void 0?void 0:s.LineItem;}_.getDefaultLineItem=l;function m(r){var s;return(s=r.annotations.UI)===null||s===void 0?void 0:s.Chart;}_.getDefaultChart=m;function n(r){var s,t;return(s=r.annotations)===null||s===void 0?void 0:(t=s.UI)===null||t===void 0?void 0:t.PresentationVariant;}_.getDefaultPresentationVariant=n;function o(r){var s,t;return(s=r.annotations)===null||s===void 0?void 0:(t=s.UI)===null||t===void 0?void 0:t.SelectionVariant;}_.getDefaultSelectionVariant=o;function p(r,s){var t=s.getManifestWrapper().getDefaultTemplateAnnotationPath();var u=i(r,t,s);var v;if(u){var w=u.SelectionVariant;if(w){return w;}}else{v=o(r);return v;}}_.getSelectionVariant=p;function q(v,r,s,t,u){var w=s.getEntityTypeAnnotation(v);var x=w.annotation;s=w.converterContext;var y=[];var z;var A="";var B,D;var E=x===null||x===void 0?void 0:x.term;if(E){switch(E){case"com.sap.vocabularies.UI.v1.LineItem":case"com.sap.vocabularies.UI.v1.Chart":y.push({visualization:x,annotationPath:v,converterContext:s});break;case"com.sap.vocabularies.UI.v1.PresentationVariant":z=x;y=y.concat(h(x,v,s,t));break;case"com.sap.vocabularies.UI.v1.SelectionPresentationVariant":z=x.PresentationVariant;A=z.fullyQualifiedName;if(!k(z)){var F=s.getEntityType();var G=l(F);if(G){y.push({visualization:G,annotationPath:s.getRelativeAnnotationPath(G.fullyQualifiedName,F),converterContext:s});}}else{y=y.concat(h(z,v,s,t));}break;default:break;}y.map(function(H){var x=H.visualization,J=H.annotationPath,s=H.converterContext;switch(x.term){case"com.sap.vocabularies.UI.v1.Chart":B=e(x,J,s,u);break;case"com.sap.vocabularies.UI.v1.LineItem":default:D=f(x,J,s,z,r,t);break;}});}else{D=g(s);s.getDiagnostics().addIssue(b.Annotation,c.Medium,d.MISSING_LINEITEM);}var V=[];var P=E==="com.sap.vocabularies.UI.v1.SelectionPresentationVariant"?A:x&&x.fullyQualifiedName;if(P===undefined){P="/";}if(B){V.push(B);}if(D){V.push(D);}return{visualizations:V,annotationPath:s.getEntitySetBasedAnnotationPath(P)};}_.getDataVisualizationConfiguration=q;return _;},false);