@sap/ux-specification 1.120.9 → 1.120.11

package/dist/specification/src/sync/v2/generate/utils.js

@@ -0,0 +1,719 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasPropertyTypeError = exports.getUIAnnotationForEntitySet = exports.addStandardFooterActionsOP = exports.addStandardHeaderActions = exports.isEntityUpdatable = exports.isEntityDeletable = exports.isDraftEnabled = exports.addEntityPropertiesToEnum = exports.addSelectionFields = exports.removeElementsFromEnum = exports.processMetadata = exports.addTableColumnExtensions = exports.addFragmentEnum = exports.addTabkeyEnum = exports.addListReportLeadingProperties = exports.addLineItemsType = exports.retrieveNameWithoutVocabularyFromVisualization = exports.handleActionRecord = void 0;
+const ux_specification_types_1 = require("@sap/ux-specification-types");
+const common_1 = require("../../common");
+const decorators_1 = require("../../common/decoration/decorators");
+const path_1 = require("path");
+const xml_js_1 = require("xml-js");
+const types_1 = require("../types");
+const extensionLogger_1 = require("../../../extensionLogger");
+const i18next_1 = __importDefault(require("i18next"));
+/**
+ * Common function for enhancing the LineItems definiton of app schema by custom columns
+ * @param appSchema - app-specific JSON schema
+ * @param customColumnsDefinitionName - custom column definition name (plural)
+ * @param customColumnDefinitionName - custom column definition name (singular)
+ */
+function addCustomColumnDefinition(appSchema, customColumnsDefinitionName, customColumnDefinitionName) {
+    if (appSchema.definitions[ux_specification_types_1.DefinitionName.LineItems]) {
+        appSchema.definitions[ux_specification_types_1.DefinitionName.LineItems].properties['custom'] = {
+            $ref: `${common_1.DEFINITION_LINK_PREFIX}${customColumnsDefinitionName}`
+        };
+    }
+    appSchema.definitions[customColumnsDefinitionName] = {
+        type: 'array',
+        items: {
+            $ref: `${common_1.DEFINITION_LINK_PREFIX}${customColumnDefinitionName}`
+        },
+        description: 'Custom Columns'
+    };
+    appSchema.definitions[customColumnsDefinitionName][ux_specification_types_1.SchemaTag.isViewNode] = true;
+    const extensionType = appSchema.definitions[customColumnDefinitionName].properties['extensionType'];
+    if (extensionType) {
+        extensionType[ux_specification_types_1.SchemaTag.artifactType] = ux_specification_types_1.ArtifactType.Manifest;
+    }
+}
+/**
+ * Prepares and returns id of action for further use and reference
+ * @param actionType - type of action
+ * @param lineItemProperties - properties of the line item collection: lineItemPath, lineItemRecord, lineItemId
+ * @returns {string} actionId
+ */
+function getActionId(actionType, lineItemProperties) {
+    let actionId;
+    if (actionType === types_1.ActionTypeV2.ColumnIntentBased) {
+        actionId = (0, common_1.getSchemaKeyOfLineItemRecord)(lineItemProperties.lineItemRecord);
+    }
+    else if (actionType === types_1.ActionTypeV2.ToolBarIntentBased || actionType === types_1.ActionTypeV2.FooterIntentBased) {
+        actionId = (0, common_1.prepareRef)(`${lineItemProperties.lineItemRecord.SemanticObject}::${lineItemProperties.lineItemRecord.Action}`);
+    }
+    else if (actionType === types_1.ActionTypeV2.Column &&
+        lineItemProperties.lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */) {
+        actionId = (0, common_1.prepareRef)(`DataFieldForAction:::sAction::${lineItemProperties.lineItemRecord.Action}`);
+    }
+    else {
+        actionId = (0, common_1.prepareRef)(lineItemProperties.lineItemRecord.Action);
+    }
+    if (lineItemProperties.lineItemId && lineItemProperties.lineItemId !== 'LineItems') {
+        return `${lineItemProperties.lineItemId}??${actionId}`;
+    }
+    else {
+        return actionId;
+    }
+}
+/**
+ * Processes a LineItem record of type DataFieldForAction and DataFieldForIntentBasedNavigation during app schema generation
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param entityType - the entity type as part of the AVT ConvertedMetadata
+ * @param actions - actions definition in schema, parent object
+ * @param lineItemProperties - properties of the line item collection: lineItemPath, lineItemRecord, lineItemId
+ * @param actionType - type of action
+ * @param recordIndex - record index in the collection
+ */
+function handleActionRecord(appSchema, actions, lineItemProps, actionType, recordIndex) {
+    let actionReferenceType;
+    const actionTemplate = lineItemProps.lineItemId === ux_specification_types_1.DefinitionName.LineItems ? '' : 'ObjectPage';
+    const actionId = getActionId(actionType, lineItemProps);
+    if (actionType === types_1.ActionTypeV2.Footer || actionType === types_1.ActionTypeV2.FooterIntentBased) {
+        actionReferenceType = `Action`;
+        actionType = types_1.ActionTypeV2.Footer;
+    }
+    else if (actionType === types_1.ActionTypeV2.Column || actionType === types_1.ActionTypeV2.ColumnIntentBased) {
+        actionReferenceType = `TableColumnAction`;
+    }
+    else {
+        actionReferenceType = actionTemplate !== '' ? `${actionTemplate}${actionType}` : `Action`;
+        actionType = types_1.ActionTypeV2.ToolBar;
+    }
+    const actionDefinition = `${actionTemplate}${actionType}<${actionId}>`;
+    const description = (0, common_1.getDataFieldDescription)(lineItemProps.lineItemRecord, lineItemProps.entityType);
+    actions.properties[actionId] = {
+        $ref: common_1.DEFINITION_LINK_PREFIX + actionDefinition
+    };
+    actions.properties[actionId][ux_specification_types_1.SchemaTag.propertyIndex] = recordIndex;
+    const { key, ns } = (0, common_1.getActionKey)(lineItemProps.lineItemRecord.Action, true);
+    if (appSchema.definitions[actionReferenceType]) {
+        appSchema.definitions[actionDefinition] = {
+            ...JSON.parse(JSON.stringify(appSchema.definitions[actionReferenceType])),
+            description,
+            keys: [{ name: 'Action', value: key }],
+            annotationPath: `${lineItemProps.lineItemPath}/${recordIndex}`
+        };
+        if (ns) {
+            appSchema.definitions[actionDefinition][ux_specification_types_1.SchemaTag.target] = ns;
+        }
+    }
+    else {
+        appSchema.definitions[actionDefinition] = {
+            type: 'object',
+            properties: {},
+            description,
+            additionalProperties: false
+        };
+        appSchema.definitions[actionDefinition][ux_specification_types_1.SchemaTag.isViewNode] = true;
+        appSchema.definitions[actionDefinition][ux_specification_types_1.SchemaTag.keys] = [{ name: ux_specification_types_1.SchemaKeyName.action, value: key }];
+        if (ns) {
+            appSchema.definitions[actionDefinition][ux_specification_types_1.SchemaTag.target] = ns;
+        }
+        appSchema.definitions[actionDefinition][ux_specification_types_1.SchemaTag.annotationPath] =
+            `${lineItemProps.lineItemPath}/${recordIndex}`;
+    }
+}
+exports.handleActionRecord = handleActionRecord;
+/**
+ * Returns the type of a column lineItem action
+ * @param lineItemId - optional: in case of OP the parameter must be passed to distinguish the OP tables;
+ * @param {object} lineItemRecord - actual record of the line item collection
+ * @param actionTypes - array of action types to be filled
+ */
+function getColumnActionType(lineItemId, lineItemRecord, actionTypes) {
+    if (lineItemId !== ux_specification_types_1.DefinitionName.LineItems &&
+        lineItemRecord.Inline === true &&
+        (lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */ ||
+            lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" /* UIAnnotationTypes.DataFieldForIntentBasedNavigation */)) {
+        actionTypes.push(types_1.ActionTypeV2.OPColumn);
+    }
+    else if (lineItemRecord.Inline === true && lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */) {
+        actionTypes.push(types_1.ActionTypeV2.Column);
+    }
+    else if (lineItemRecord.Inline === true &&
+        lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" /* UIAnnotationTypes.DataFieldForIntentBasedNavigation */) {
+        actionTypes.push(types_1.ActionTypeV2.ColumnIntentBased);
+    }
+}
+/**
+ * Returns the type of a lineItem action
+ * @param {object} lineItemRecord - actual record of the line item collection
+ * @returns {string[] | undefined } ActionTypeV2[] - action type(s) of the lineItem
+ */
+function getActionType(lineItemRecord, lineItemId) {
+    const actionTypes = [];
+    if (lineItemRecord.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */ &&
+        lineItemRecord.$Type !== "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" /* UIAnnotationTypes.DataFieldForIntentBasedNavigation */) {
+        return undefined;
+    }
+    if (lineItemRecord.Inline !== true &&
+        lineItemRecord.Determining !== true &&
+        lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */) {
+        actionTypes.push(types_1.ActionTypeV2.ToolBar);
+    }
+    else if (lineItemRecord.Inline !== true &&
+        lineItemRecord.Determining !== true &&
+        lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" /* UIAnnotationTypes.DataFieldForIntentBasedNavigation */) {
+        actionTypes.push(types_1.ActionTypeV2.ToolBarIntentBased);
+    }
+    else if (lineItemRecord.Determining === true && lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForAction" /* UIAnnotationTypes.DataFieldForAction */) {
+        actionTypes.push(types_1.ActionTypeV2.Footer);
+    }
+    else if (lineItemRecord.Determining === true &&
+        lineItemRecord.$Type === "com.sap.vocabularies.UI.v1.DataFieldForIntentBasedNavigation" /* UIAnnotationTypes.DataFieldForIntentBasedNavigation */) {
+        actionTypes.push(types_1.ActionTypeV2.FooterIntentBased);
+    }
+    getColumnActionType(lineItemId, lineItemRecord, actionTypes);
+    return actionTypes;
+}
+function generateGenericColumn(lineItemProperties, appSchema, recordIndex) {
+    const schemaKey = (0, common_1.getSchemaKeyOfLineItemRecord)(lineItemProperties.lineItemRecord);
+    if (schemaKey) {
+        const lineItemDefinition = appSchema.definitions[lineItemProperties.lineItemId];
+        lineItemDefinition.properties[schemaKey] = {
+            $ref: common_1.DEFINITION_LINK_PREFIX + ux_specification_types_1.DefinitionName.TableColumn,
+            description: (0, common_1.getDataFieldDescription)(lineItemProperties.lineItemRecord, lineItemProperties.entityType)
+            // Custom property in schema - for object properties ordering purpose
+        };
+        lineItemDefinition.properties[schemaKey][ux_specification_types_1.SchemaTag.propertyIndex] = recordIndex;
+        lineItemDefinition.properties[schemaKey][ux_specification_types_1.SchemaTag.annotationPath] =
+            `${lineItemProperties.lineItemPath}/${recordIndex}`;
+        (0, common_1.addDataTypeToDefinition)(lineItemDefinition.properties[schemaKey], lineItemProperties.lineItemRecord);
+        (0, common_1.addKeyToDefinition)(lineItemProperties.lineItemRecord, lineItemDefinition.properties, schemaKey);
+    }
+}
+function handleAnyAction(actionType, appSchema, actions, lineItemProperties, recordIndex, footerActions, lineItemId) {
+    switch (actionType) {
+        case types_1.ActionTypeV2.ToolBar:
+        case types_1.ActionTypeV2.ToolBarIntentBased: {
+            handleActionRecord(appSchema, actions, lineItemProperties, actionType, recordIndex);
+            break;
+        }
+        case types_1.ActionTypeV2.Footer:
+        case types_1.ActionTypeV2.FooterIntentBased: {
+            if (footerActions) {
+                handleActionRecord(appSchema, footerActions, lineItemProperties, actionType, recordIndex);
+            }
+            break;
+        }
+        case types_1.ActionTypeV2.Column:
+        case types_1.ActionTypeV2.ColumnIntentBased: {
+            handleActionRecord(appSchema, appSchema.definitions[lineItemId], lineItemProperties, actionType, recordIndex);
+            break;
+        }
+        case types_1.ActionTypeV2.OPColumn: {
+            generateGenericColumn(lineItemProperties, appSchema, recordIndex);
+        }
+    }
+}
+/**
+ *
+ * @param annotationTerm "unqualified" annotation term that can be specified whithin a visualization (i.e. "LineItem" or "Chart")
+ * @param visualization one visualization of a PresentationVariant
+ * @returns empty string if the visualization does not match the annotationTerm. Otherwise the value of the visualization stripped by the reference to the ui vocabulary
+ */
+function retrieveNameWithoutVocabularyFromVisualization(annotationTerm, visualization) {
+    // check whether the value of the visualization specifies the fully qualified annotation term if yes, return the value without the vocabulary prefix, otherwise the empty string
+    const visualizationValue = visualization.value;
+    return visualizationValue.includes(ux_specification_types_1.UIVOCABULARYALPHADOT + annotationTerm) // replace includes with startsWith?
+        ? visualizationValue.replace(ux_specification_types_1.UIVOCABULARYALPHADOT, '')
+        : '';
+}
+exports.retrieveNameWithoutVocabularyFromVisualization = retrieveNameWithoutVocabularyFromVisualization;
+/**
+ * Adds the line item records to the app schema (for the list report or an object page section comprising a table)
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param lineItemAnnotation - the UI.LineItem annotation, comprising all records
+ * @param entityType - the entity type as part of the AVT ConvertedMetadata
+ * @param lineItemId - optional: in case of OP the parameter must be passed to distinguish the OP tables;
+ *                      in case of LR or ALP no ID is passed, 'LineItems' is taken then.
+ * @param customColumnRef - schema reference to custom column definition.
+ */
+function addLineItemsType(appSchema, lineItemAnnotation, entityType, lineItemId, customColumnRef) {
+    // Add the correct lineItem definition
+    lineItemId = lineItemId || ux_specification_types_1.DefinitionName.LineItems;
+    const { actions, footerActions, lineItemPath } = (0, common_1.addCommonLineItemDefinitions)(appSchema, lineItemAnnotation, entityType, lineItemId);
+    if (lineItemAnnotation) {
+        let recordIndex = 0;
+        lineItemAnnotation.forEach((lineItemRecord) => {
+            const lineItemProperties = { lineItemPath, lineItemRecord, lineItemId, entityType };
+            const actionTypes = getActionType(lineItemRecord, lineItemId);
+            if (actionTypes) {
+                actionTypes.forEach((actionType) => {
+                    handleAnyAction(actionType, appSchema, actions, lineItemProperties, recordIndex, footerActions, lineItemId);
+                });
+            }
+            else {
+                generateGenericColumn(lineItemProperties, appSchema, recordIndex);
+            }
+            recordIndex++;
+        });
+    }
+    if (customColumnRef) {
+        appSchema.definitions[lineItemId].properties['custom'] = {
+            $ref: `${common_1.DEFINITION_LINK_PREFIX}${customColumnRef}`
+        };
+    }
+}
+exports.addLineItemsType = addLineItemsType;
+/**
+ * Adds enum entries of possible leading properties for 'leadingProperty' property in TableCustomColumn properties.
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param entityType - the entity type as part of the AVT ConvertedMetadata
+ * @param definitionName - definition name of CustomColumn definition
+ */
+function addListReportLeadingProperties(appSchema, entityType, definitionName) {
+    // Leading Property
+    const leadingPropertySchema = appSchema.definitions[definitionName]?.['properties']?.['leadingProperty'];
+    if (leadingPropertySchema) {
+        const properties = [
+            //  Entity properties
+            ...(entityType?.entityProperties || []),
+            // Navigation Properties
+            ...(entityType?.navigationProperties || [])
+        ];
+        leadingPropertySchema['enum'] = properties?.reduce((result, property) => {
+            if (!result.includes(property.name)) {
+                result.push(property.name);
+            }
+            return result;
+        }, []);
+    }
+}
+exports.addListReportLeadingProperties = addListReportLeadingProperties;
+/**
+ * Adds enum entries of posible tabKey properties for 'leadingProperty' property in TableCustomColumn properties.
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param definitionName - definition name of CustomColumn definition
+ * @param page - sapui5 page object
+ * @param {string} facet ID -  The facet ID
+ */
+function addTabkeyEnum(appSchema, definitionName, page, facetID) {
+    const tabkeyPropertySchema = appSchema.definitions[definitionName]?.['properties']?.['tabKey'];
+    if (!page) {
+        if (facetID) {
+            tabkeyPropertySchema.description =
+                'In case of Object Page, the tabkey in manifest is equivalent to the facet ID.';
+            tabkeyPropertySchema['enum'] = [facetID];
+        }
+        return;
+    }
+    const quickVariantsX = page.component?.settings?.quickVariantSelectionX?.['variants'];
+    if (quickVariantsX) {
+        const enumEntries = [];
+        for (const index in quickVariantsX) {
+            const key = quickVariantsX[index]?.key;
+            if (key !== undefined && !enumEntries.includes(key)) {
+                enumEntries.push(key);
+            }
+        }
+        (0, common_1.addEnumToSchema)(enumEntries, tabkeyPropertySchema);
+    }
+}
+exports.addTabkeyEnum = addTabkeyEnum;
+/**
+ * Adds enum entries of posible fragment entries.
+ * @param {object} appSchema The app specific schema that shall get enhanced.
+ * @param {FileData[]} fragments Array of fragments.
+ * @param {string[]} appId Application id.
+ * @param {string} property Property name.
+ * @param {string} definitionName Definition name of CustomColumn definition.
+ */
+function addFragmentEnum(appSchema, fragments, appId, property, definitionName) {
+    if (!fragments || !appId || appId.startsWith('${')) {
+        return;
+    }
+    const enumEntries = [];
+    fragments.forEach((fragment) => {
+        let relPath = fragment.dataSourceUri.split('webapp')[1];
+        if (relPath && relPath.indexOf('.fragment.xml') > 0) {
+            const fragmentJson = JSON.parse((0, xml_js_1.xml2json)(fragment.fileContent, { compact: true }))['core:FragmentDefinition'];
+            if ((property === 'fragmentName' &&
+                (!fragmentJson ||
+                    fragmentJson.Column ||
+                    fragmentJson['table:Column'] ||
+                    fragmentJson['table:AnalyticalColumn'])) ||
+                (property === 'cellsFragmentName' &&
+                    (!fragmentJson ||
+                        (!fragmentJson.Column &&
+                            !fragmentJson['table:Column'] &&
+                            !fragmentJson['table:AnalyticalColumn'] &&
+                            !fragmentJson['smartfilterbar:ControlConfiguration'])))) {
+                relPath = relPath.replace(new RegExp('\\' + path_1.sep, 'g'), '/');
+                const fragmentName = appId + relPath.split('.fragment.xml')[0].replace(/\//g, '.');
+                enumEntries.push(fragmentName);
+            }
+        }
+    });
+    (0, common_1.addEnumToSchema)(enumEntries, appSchema.definitions[definitionName]?.['properties']?.[property]);
+}
+exports.addFragmentEnum = addFragmentEnum;
+/**
+ * Adds the custom columns to the line item records of the app schema (for the list report comprising a table).
+ * @param {object} appSchema The app specific schema that shall get enhanced.
+ * @param {EntityType} entityType The entity type as part of the AVT ConvertedMetadata.
+ * @param {SapUiAppPageV2} page Sapui5 page object.
+ * @param {object} manifest Application manifest.
+ * @param {FileData[]} [fragments] Array of fragments.
+ * @param {string} [customColumnsDefinitionName=DefinitionName.CustomColumns] Definition name of Custom Columns definition.
+ * @param {string} [customColumnDefinitionName=DefinitionName.CustomColumn] Definition name of Custom Column definition.
+ * @param {string} facetID -  Facet ID
+ */
+function addTableColumnExtensions(appSchema, entityType, page, manifest, fragments, customColumnsDefinitionName = ux_specification_types_1.DefinitionName.CustomColumns, customColumnDefinitionName = ux_specification_types_1.DefinitionName.CustomColumn, facetID) {
+    addCustomColumnDefinition(appSchema, customColumnsDefinitionName, customColumnDefinitionName);
+    // Leading Property
+    addListReportLeadingProperties(appSchema, entityType, customColumnDefinitionName);
+    // Tab key property
+    addTabkeyEnum(appSchema, customColumnDefinitionName, page, facetID);
+    // Fragment property
+    const appId = manifest && manifest['sap.app'] && manifest['sap.app']['id'];
+    addFragmentEnum(appSchema, fragments, appId, 'fragmentName', customColumnDefinitionName);
+    //tools-suite does not distinguish by section ID, looks at the generic entry
+    addFragmentEnum(appSchema, fragments, appId, 'fragmentName', ux_specification_types_1.DefinitionName.CustomColumn);
+    addFragmentEnum(appSchema, fragments, appId, 'cellsFragmentName', customColumnDefinitionName);
+    addFragmentEnum(appSchema, fragments, appId, 'cellsFragmentName', ux_specification_types_1.DefinitionName.CustomColumn);
+}
+exports.addTableColumnExtensions = addTableColumnExtensions;
+/**
+ * Processes an anyOf definition of the generic schema
+ * @param propertyDefinition - current definition in the generic schema
+ * @param schema - the app-specific schema
+ * @param propertyKey - key of the single property
+ * @param factory - factory for creating metadata instances
+ * @param pageType - page type
+ * @param processedRefs - array of already processed refs which used to avoid cycling recursion
+ */
+function processAnyOf(propertyDefinition, schema, propertyKey, factory, pageType, processedRefs) {
+    propertyDefinition['anyOf'].forEach((element) => {
+        const nextDefinition = (0, common_1.getNextTargetDefinition)(schema, '', {}, element, propertyKey, factory, pageType);
+        if (nextDefinition) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            processMetadata(schema, nextDefinition.targetDefinition, nextDefinition.configObject, pageType, factory, processedRefs, element.$ref);
+        }
+    });
+}
+/**
+ * Processes an object reference of the generic schema
+ * @param schema
+ * @param propertyDefinition - current definition in the generic schema
+ * @param propertyKey - key of the single property
+ * @param factory - factory for creating metadata instances
+ * @param pageType - page type
+ * @param processedRefs - array of already processed refs which used to avoid cycling recursion
+ */
+function processObject(schema, propertyDefinition, propertyKey, factory, pageType, processedRefs) {
+    const nextDefinition = (0, common_1.getNextTargetDefinition)(schema, '', {}, propertyDefinition, propertyKey, factory, pageType);
+    if (nextDefinition) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        processMetadata(schema, nextDefinition.targetDefinition, nextDefinition.configObject, pageType, factory, processedRefs, propertyDefinition.$ref);
+    }
+}
+/**
+ * Determines the artifact type of a property and adds it to the property definition in schema
+ * @param syncRule - sync rule of the current property
+ * @param propertyDefinition - current definition in the generic schema
+ */
+function addArtifactType(syncRule, propertyDefinition) {
+    if (syncRule.manifest !== undefined) {
+        propertyDefinition.artifactType = ux_specification_types_1.ArtifactType.Manifest;
+    }
+    else if (syncRule.flex !== undefined) {
+        propertyDefinition.artifactType = ux_specification_types_1.ArtifactType.FlexChange;
+        //Add control type
+        if (syncRule.flex.controlType) {
+            propertyDefinition.controlType = syncRule.flex.controlType();
+        }
+    }
+    else {
+        propertyDefinition.artifactType = ux_specification_types_1.ArtifactType.Annotation;
+    }
+}
+/**
+ * After the generation of a generic schema, apply post-generation rule to a single property
+ * @param metaDataDefinition
+ * @param schema - given app schema, to be adapted
+ * @param pageType - page type
+ * @param factory - factory for creating metadata instances
+ * @param propertyDefinition - definition of the single property
+ * @param propertyKey - key of the single property
+ * @param schemaDefinition - the current entry point or definition in the app schema
+ * @param processedRefs - array of already processed refs which used to avoid cycling recursion
+ */
+function processSingleProperty(metaDataDefinition, schema, pageType, factory, propertyDefinition, propertyKey, schemaDefinition, processedRefs) {
+    if (metaDataDefinition) {
+        //get sync rule from reflect metadata
+        const syncRule = (0, decorators_1.getReflectMetadata)(metaDataDefinition, propertyKey);
+        if (syncRule) {
+            if (typeof syncRule.generate === 'function') {
+                syncRule.generate(schema, schemaDefinition, propertyKey);
+                propertyDefinition = schemaDefinition['properties'][propertyKey];
+            }
+            //Add artifact type
+            addArtifactType(syncRule, propertyDefinition);
+        }
+        //get getDescriptionSrcURL from reflect metadata
+        const descriptionSrcURL = (0, decorators_1.getDescriptionSrcURL)(metaDataDefinition, propertyKey);
+        if (descriptionSrcURL) {
+            propertyDefinition[ux_specification_types_1.SchemaTag.descriptionSrcURL] = descriptionSrcURL;
+        }
+        if (propertyDefinition.type === 'object' || propertyDefinition.$ref) {
+            processObject(schema, propertyDefinition, propertyKey, factory, pageType, processedRefs);
+        }
+        else if (propertyDefinition['anyOf']) {
+            processAnyOf(propertyDefinition, schema, propertyKey, factory, pageType, processedRefs);
+        }
+    }
+}
+/**
+ * After the generation of a generic schema, apply rules to a list of properties of the given schema section
+ * @param schema - given app schema, to be adapted
+ * @param schemaDefinition - the current entry point or definition in the app schema
+ * @param pageType - page type
+ * @param factory - factory for creating metadata instances
+ * @param processedRefs - array of already processed refs which used to avoid cycling recursion
+ */
+function processProperties(schema, schemaDefinition, metaDataDefinition, propertiesSection, pageType, factory, processedRefs) {
+    if (schemaDefinition[propertiesSection]) {
+        for (const propertyKey in schemaDefinition[propertiesSection]) {
+            if (propertyKey === 'anyOf') {
+                processAnyOf(schemaDefinition[propertiesSection], schema, propertyKey, factory, pageType, processedRefs);
+            }
+            else {
+                const propertyDefinition = schemaDefinition[propertiesSection][propertyKey];
+                if (propertyDefinition['anyOf']) {
+                    processAnyOf(propertyDefinition, schema, propertyKey, factory, pageType, processedRefs);
+                }
+                else if (propertyKey === '$ref') {
+                    processObject(schema, schemaDefinition[propertiesSection], propertyKey, factory, pageType, processedRefs);
+                }
+                else {
+                    processSingleProperty(metaDataDefinition, schema, pageType, factory, propertyDefinition, propertyKey, schemaDefinition, processedRefs);
+                }
+            }
+        }
+    }
+}
+/**
+ * Apply post-processing rules as specified in form of "generate" at the syncRule
+ * @param schema - given app schema, to be adapted
+ * @param schemaDefinition - the current entry point or definition in the app schema
+ * @param pageType - page type
+ * @param factory - factory for creating metadata instances
+ * @param processedRefs - array of already processed refs which used to avoid cycling recursion
+ * @param ref - currently processed schema definition reference name
+ */
+function processMetadata(schema, schemaDefinition, metaDataDefinition, pageType, factory, processedRefs, ref) {
+    if (ref) {
+        if (processedRefs.includes(ref)) {
+            return;
+        }
+        processedRefs.push(ref);
+    }
+    processProperties(schema, schemaDefinition, metaDataDefinition, 'properties', pageType, factory, processedRefs);
+    processProperties(schema, schemaDefinition, metaDataDefinition, 'additionalProperties', pageType, factory, processedRefs);
+    processProperties(schema, schemaDefinition, metaDataDefinition, 'patternProperties', pageType, factory, processedRefs);
+}
+exports.processMetadata = processMetadata;
+/**
+ * Method updates passed 'enum' array by removing passed matching entries.
+ * @param {Array<unknown>} values Array of values.
+ * @param {Array<unknown>} valuesToRemove Array of values to remove.
+ */
+function removeElementsFromEnum(values, valuesToRemove) {
+    for (const value of valuesToRemove) {
+        const index = values.indexOf(value);
+        if (index !== -1) {
+            // Value exists - remove it
+            values.splice(index, 1);
+        }
+    }
+}
+exports.removeElementsFromEnum = removeElementsFromEnum;
+/**
+ * Adds the selection fields to the app schema, as properties of the Filterbar
+ * @param entityType - the entity type as part of the AVT ConvertedMetadata
+ * @param appSchema - the app specific schema that shall get enhanced
+ * @param selectionFieldsAnnotation - the UI.SelectionField annotation
+ */
+function addSelectionFields(appSchema, selectionFieldsAnnotation, entityType) {
+    appSchema.definitions.SelectionFields = {
+        ...appSchema.definitions.SelectionFields,
+        properties: {},
+        additionalProperties: false
+    };
+    const selectionFieldsDefinition = appSchema.definitions.SelectionFields;
+    const annotationPath = (0, common_1.createAnnotationPath)(entityType?.fullyQualifiedName, "com.sap.vocabularies.UI.v1.SelectionFields" /* UIAnnotationTerms.SelectionFields */);
+    if (annotationPath) {
+        selectionFieldsDefinition[ux_specification_types_1.SchemaTag.annotationPath] = annotationPath;
+    }
+    if (!selectionFieldsAnnotation) {
+        return;
+    }
+    let i = 0;
+    selectionFieldsAnnotation.forEach((selectionField) => {
+        let description = selectionField.value;
+        const fieldDefinition = `SelectionField<${(0, common_1.prepareRef)(selectionField.value)}>`;
+        const dataType = (0, common_1.determineDataType)(selectionField);
+        if (selectionField.type === 'PropertyPath') {
+            description = (0, common_1.getLabelForPropertyPath)(selectionField, entityType);
+        }
+        selectionFieldsDefinition.properties[selectionField.value] = {
+            $ref: common_1.DEFINITION_LINK_PREFIX + fieldDefinition
+        };
+        selectionFieldsDefinition.properties[selectionField.value][ux_specification_types_1.SchemaTag.propertyIndex] = i;
+        appSchema.definitions[fieldDefinition] = {
+            type: 'object',
+            description,
+            additionalProperties: false
+        };
+        appSchema.definitions[fieldDefinition][ux_specification_types_1.SchemaTag.isViewNode] = true;
+        appSchema.definitions[fieldDefinition][ux_specification_types_1.SchemaTag.annotationType] = selectionField?.type;
+        appSchema.definitions[fieldDefinition][ux_specification_types_1.SchemaTag.dataType] = dataType;
+        appSchema.definitions[fieldDefinition][ux_specification_types_1.SchemaTag.keys] = [
+            { name: ux_specification_types_1.SchemaKeyName.value, value: `${selectionField.value}` }
+        ];
+        appSchema.definitions[fieldDefinition][ux_specification_types_1.SchemaTag.annotationPath] = `${selectionFieldsDefinition[ux_specification_types_1.SchemaTag.annotationPath]}/${i}`;
+        if (['Date', 'DateTime', 'DateTimeOffset'].includes(dataType)) {
+            appSchema.definitions[fieldDefinition]['$ref'] = `${common_1.DEFINITION_LINK_PREFIX}SelectionFieldDateSettings`;
+        }
+        else {
+            appSchema.definitions[fieldDefinition]['properties'] = {};
+        }
+        i++;
+    });
+}
+exports.addSelectionFields = addSelectionFields;
+/**
+ * Add entityProperties to passed a passed enum entry
+ * @param {string[]} appSchemaEnum - Enum to be enhanced
+ * @param {EntityType} entityType - Given entity type for which entries shall get generated
+ */
+function addEntityPropertiesToEnum(appSchemaEnum, entityType) {
+    for (const key of entityType.entityProperties) {
+        appSchemaEnum.push(key.name);
+    }
+}
+exports.addEntityPropertiesToEnum = addEntityPropertiesToEnum;
+/**
+ * Checks if an entity supports draft capabilities
+ * @param {EntitySet} entitySet Entity Set
+ * @returns true if the entity supports draft
+ */
+function isDraftEnabled(entitySet) {
+    return !!entitySet.annotations?.Common?.DraftRoot || !!entitySet.annotations?.Common?.DraftNode;
+}
+exports.isDraftEnabled = isDraftEnabled;
+/**
+ * Function to determine if the entity is deletable.
+ * @param {EntitySet} entitySet - current entity set
+ * returns {boolean} return true if the Entity is deletable
+ */
+function isEntityDeletable(entitySet) {
+    return entitySet.annotations?.Capabilities?.DeleteRestrictions?.Deletable !== false;
+}
+exports.isEntityDeletable = isEntityDeletable;
+/**
+ * Function to determine if the entity is updatable.
+ * @param {EntitySet} entitySet - current entity set
+ * @returns returns true if the Entity is updatable
+ */
+function isEntityUpdatable(entitySet) {
+    return entitySet.annotations?.Capabilities?.UpdateRestrictions?.Updatable !== false;
+}
+exports.isEntityUpdatable = isEntityUpdatable;
+/**
+ * Adds standard header actions to schema (LR, ALP or OP)
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param {boolean} isOP - flag to add to either LR/ALP or OP definition
+ * @param {Definition} actions - optional standard actions definition
+ */
+function addStandardHeaderActions(appSchema, isOP = false, actions) {
+    // add standard header actions definitions
+    let headerActionsKey = ux_specification_types_1.DefinitionName.HeaderActionsStandard;
+    let actionDefinition = ux_specification_types_1.DefinitionName.HeaderActionStandard;
+    if (isOP) {
+        headerActionsKey = ux_specification_types_1.DefinitionName.ObjectPageHeaderActions;
+        actionDefinition = ux_specification_types_1.DefinitionName.ObjectPageHeaderActionStandard;
+    }
+    const headerActions = appSchema.definitions[headerActionsKey];
+    headerActions[ux_specification_types_1.SchemaTag.isViewNode] = true;
+    headerActions.description = 'Actions';
+    const standardActions = actions || headerActions;
+    Object.entries(standardActions.properties).forEach(([name, definition]) => {
+        const actionRef = definition['$ref'].split(common_1.DEFINITION_LINK_PREFIX)[1];
+        const actionKey = `${actionDefinition}<${actionRef}>`;
+        headerActions.properties[name] = { $ref: `${common_1.DEFINITION_LINK_PREFIX}${actionKey}` };
+        appSchema.definitions[actionKey] = appSchema.definitions[actionRef];
+        appSchema.definitions[actionRef][ux_specification_types_1.SchemaTag.actionType] = ux_specification_types_1.ActionType.Standard;
+    });
+}
+exports.addStandardHeaderActions = addStandardHeaderActions;
+/**
+ * Adds standard footer actions to schema of Object Page
+ * @param {Definition} appSchema - app-specific JSON schema
+ * @param {EntityType} entityType Entity Type of the page
+ * @param {Definition} actions - optional standard actions definition
+ */
+function addStandardFooterActionsOP(appSchema, actions) {
+    const standardActions = appSchema.definitions[ux_specification_types_1.DefinitionName.ObjectPageFooterActions];
+    for (const action in standardActions.properties) {
+        const actionRef = standardActions.properties[action]['$ref'].split(common_1.DEFINITION_LINK_PREFIX)[1];
+        const actionKey = `${ux_specification_types_1.DefinitionName.ObjectPageFooterActionStandard}<${actionRef}>`;
+        actions.properties[action] = { $ref: `${common_1.DEFINITION_LINK_PREFIX}${actionKey}` };
+        appSchema.definitions[actionKey] = appSchema.definitions[actionRef];
+        appSchema.definitions[actionRef][ux_specification_types_1.SchemaTag.actionType] = ux_specification_types_1.ActionType.Standard;
+    }
+}
+exports.addStandardFooterActionsOP = addStandardFooterActionsOP;
+/**
+ * Extract entity type and ui annotations for a entity set and log an error in case that either of these objects does not exist
+ * @param {GenerateAppSchemaParameters} generateParameters list of API input parameters
+ * @returns the entity type and the ui annotations for the given entity set
+ */
+function getUIAnnotationForEntitySet(generateParameters) {
+    const entityType = generateParameters.entitySet?.entityType;
+    const uIAnnotations = entityType?.annotations?.UI;
+    if (typeof uIAnnotations !== 'object' || Object.keys(uIAnnotations).length === 0) {
+        const message = entityType
+            ? i18next_1.default.t('NOUIANNOTATIONS', { entityType: entityType.name })
+            : i18next_1.default.t('NOENTITYTYPE4SET', { entitySetName: generateParameters.entitySet?.name });
+        (0, extensionLogger_1.log)(generateParameters.logger, {
+            severity: "error" /* LogSeverity.Error */,
+            message: message
+        });
+    }
+    return { entityType, uIAnnotations };
+}
+exports.getUIAnnotationForEntitySet = getUIAnnotationForEntitySet;
+/**
+ * Type check for properties coming from the manifest
+ * @param parent - the parent object in manifest which may contain the property
+ * @param {string} propertyName name of the property name to be checked
+ * @param {ExtensionLogger} logger - a logger which may receive the error message in case a type error is detected
+ * @param {string} expectedType - the expected type of the value of the property (if it is not undefined)
+ * @returns {boolean} the information whether a type error was detected. Note that no error is assumed when either parent or parent[propertyName] is undefined
+ */
+function hasPropertyTypeError(parent, propertyName, logger, expectedType = 'string') {
+    const hasTypeError = parent !== undefined &&
+        (typeof parent !== 'object' ||
+            (parent[propertyName] !== undefined && typeof parent[propertyName] !== expectedType));
+    if (hasTypeError) {
+        (0, extensionLogger_1.log)(logger, {
+            severity: "error" /* LogSeverity.Error */,
+            message: i18next_1.default.t('TYPEERROR', { propertyName: propertyName, expectedType: expectedType })
+        });
+    }
+    return hasTypeError;
+}
+exports.hasPropertyTypeError = hasPropertyTypeError;
+//# sourceMappingURL=utils.js.map