@sap-ux/fiori-mcp-server 0.0.1

package/dist/page-editor-api/parser/model/AggregationValidator.d.ts

@@ -0,0 +1,64 @@
+import type { ObjectAggregation, AggregationVariant } from './ObjectAggregation';
+import type { PageData, PropertyPath } from './types';
+import { ValidationState } from './types';
+/**
+ * Represents validator for aggregations.
+ */
+export declare class AggregationValidator {
+    /**
+     * Method validates states of properties and aggregation. Following states are supported:
+     * 1. Valid.
+     * 2. Invalid - when value is set for property/aggregation, but it is not valid.
+     * 3. Skipped - when property/aggregation is not relevant in current value context and value does not set.
+     *
+     * @param aggregation ObjectAggregation which state should be validated.
+     * @param data Page data.
+     */
+    validate(aggregation: ObjectAggregation, data: PageData): void;
+    /**
+     * Method receives possible variants of variants received from schema and validates against current values.
+     *
+     * @param variants Array of variants.
+     * @param aggregation Aggregation to validate.
+     * @returns State of each property and aggregation.
+     */
+    validateVariants(variants: Array<AggregationVariant>, aggregation: ObjectAggregation): {
+        [k: string]: ValidationState;
+    };
+    /**
+     * Method receives single variants and validates received property against variant schema.
+     *
+     * @param variant Variant to use as validation rule.
+     * @param aggregation Aggregation to validate.
+     * @param property Name of inner property or aggregation, which should be validated.
+     * @param ignoreUnexisting Do not return skip state when ignore passed and variant property does not exist.
+     * @returns Validation result.
+     */
+    validateVariant(variant: AggregationVariant, aggregation: ObjectAggregation, property: string, ignoreUnexisting?: boolean): ValidationState;
+    /**
+     * Iterates over all aggregations contained in the given variants.
+     * Useful for replacing nested loops when traversing variant aggregations.
+     *
+     * @param variants List of variant aggregations to traverse.
+     * @yields A tuple containing:
+     *  - `name`: The aggregation key within the variant.
+     *  - `aggregation`: The aggregation within the variant.
+     */
+    private iterateVariantAggregations;
+    /**
+     * Method goes through passed variants and checks for unify aggregations.
+     * If there is any aggregation for unification, then method updates unify aggregation with latest valid context paths.
+     *
+     * @param aggregation Aggregation to validate.
+     * @param variants Valid aggeregation to use as context for properties and aggregations paths.
+     */
+    private unifyVariants;
+    /**
+     * Recursive method updates paths of all aggregations and properties using passed context path.
+     *
+     * @param aggregation Target aggregation.
+     * @param contextPath Context path.
+     */
+    applyContextPath(aggregation: ObjectAggregation, contextPath: PropertyPath): void;
+}
+//# sourceMappingURL=AggregationValidator.d.ts.map

package/dist/page-editor-api/parser/model/AggregationValidator.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationValidator = void 0;
+const types_1 = require("./types");
+const i18next_1 = __importDefault(require("i18next"));
+const utils_1 = require("./utils");
+/**
+ * Represents validator for aggregations.
+ */
+class AggregationValidator {
+    /**
+     * Method validates states of properties and aggregation. Following states are supported:
+     * 1. Valid.
+     * 2. Invalid - when value is set for property/aggregation, but it is not valid.
+     * 3. Skipped - when property/aggregation is not relevant in current value context and value does not set.
+     *
+     * @param aggregation ObjectAggregation which state should be validated.
+     * @param data Page data.
+     */
+    validate(aggregation, data) {
+        if (aggregation.state === types_1.ValidationState.Valid && aggregation.variants.length >= 1) {
+            const properties = this.validateVariants(aggregation.variants, aggregation);
+            for (const property in properties) {
+                const entry = aggregation.properties[property] || aggregation.aggregations[property];
+                if (entry) {
+                    entry.state = properties[property];
+                    if (entry.state === types_1.ValidationState.Invalid) {
+                        // Property is defined in source, but it is not allowed
+                        (0, utils_1.addValidationMessages)(entry, [
+                            {
+                                text: i18next_1.default.t('PAGE_EDITOR_PROPERTIES_PROPERTY_WARNING_PROPERTY_NOT_ALLOWED', {
+                                    name: property
+                                }),
+                                deletable: true
+                            }
+                        ]);
+                    }
+                }
+            }
+        }
+        // Go through standard aggregation with recursion
+        for (const name in aggregation.aggregations) {
+            this.validate(aggregation.aggregations[name], data ? data[name] : {});
+        }
+    }
+    /**
+     * Method receives possible variants of variants received from schema and validates against current values.
+     *
+     * @param variants Array of variants.
+     * @param aggregation Aggregation to validate.
+     * @returns State of each property and aggregation.
+     */
+    validateVariants(variants, aggregation) {
+        const valueProperties = {};
+        // Get properties with actual values
+        for (const property in aggregation.properties) {
+            if (aggregation.properties[property].value !== undefined) {
+                valueProperties[property] = aggregation.properties[property].value;
+            }
+        }
+        for (const property in aggregation.aggregations) {
+            if (aggregation.aggregations[property].value !== undefined) {
+                valueProperties[property] = aggregation.aggregations[property].value;
+            }
+        }
+        // Get valid variants
+        let validVariants = [...variants];
+        for (const property in valueProperties) {
+            validVariants = validVariants.filter((variant) => {
+                const result = this.validateVariant(variant, aggregation, property);
+                return result === types_1.ValidationState.Valid;
+            });
+        }
+        if (validVariants.length === 0) {
+            validVariants = [...variants];
+            for (const property in valueProperties) {
+                validVariants = validVariants.filter((variant) => {
+                    const result = this.validateVariant(variant, aggregation, property, true);
+                    return result === types_1.ValidationState.Valid;
+                });
+            }
+        }
+        // Unify aggregation and variants if 'unionName' is used in aggregation
+        this.unifyVariants(aggregation, validVariants);
+        // Populate property states
+        const propertyStates = {};
+        const properties = [...Object.keys(aggregation.properties), ...Object.keys(aggregation.aggregations)];
+        for (const property of properties) {
+            const valid = validVariants.some((variant) => {
+                return property in variant.properties || property in variant.aggregations;
+            });
+            if (valid) {
+                propertyStates[property] = types_1.ValidationState.Valid;
+            }
+            else if (property in valueProperties) {
+                propertyStates[property] = types_1.ValidationState.Invalid;
+            }
+            else {
+                propertyStates[property] = types_1.ValidationState.Skipped;
+            }
+        }
+        return propertyStates;
+    }
+    /**
+     * Method receives single variants and validates received property against variant schema.
+     *
+     * @param variant Variant to use as validation rule.
+     * @param aggregation Aggregation to validate.
+     * @param property Name of inner property or aggregation, which should be validated.
+     * @param ignoreUnexisting Do not return skip state when ignore passed and variant property does not exist.
+     * @returns Validation result.
+     */
+    validateVariant(variant, aggregation, property, ignoreUnexisting = false) {
+        const variantProperty = variant.aggregations[property] || variant.properties[property];
+        if (variantProperty === undefined) {
+            return ignoreUnexisting ? types_1.ValidationState.Valid : types_1.ValidationState.Skipped;
+        }
+        // Check enum value
+        const entity = aggregation.properties[property] || aggregation.aggregations[property] || {};
+        const value = entity.value;
+        if (variantProperty.schema) {
+            if (variantProperty.schema.pattern &&
+                !new RegExp(variantProperty.schema.pattern).exec(value.toString())) {
+                return types_1.ValidationState.Skipped;
+            }
+            if (variantProperty.schema.enum &&
+                !variantProperty.schema.enum.includes(value) &&
+                !variantProperty.freeText) {
+                return types_1.ValidationState.Skipped;
+            }
+        }
+        return types_1.ValidationState.Valid;
+    }
+    /**
+     * Iterates over all aggregations contained in the given variants.
+     * Useful for replacing nested loops when traversing variant aggregations.
+     *
+     * @param variants List of variant aggregations to traverse.
+     * @yields A tuple containing:
+     *  - `name`: The aggregation key within the variant.
+     *  - `aggregation`: The aggregation within the variant.
+     */
+    *iterateVariantAggregations(variants) {
+        for (const variant of variants) {
+            for (const [name, aggregation] of Object.entries(variant.aggregations)) {
+                yield [name, aggregation];
+            }
+        }
+    }
+    /**
+     * Method goes through passed variants and checks for unify aggregations.
+     * If there is any aggregation for unification, then method updates unify aggregation with latest valid context paths.
+     *
+     * @param aggregation Aggregation to validate.
+     * @param variants Valid aggeregation to use as context for properties and aggregations paths.
+     */
+    unifyVariants(aggregation, variants) {
+        const handledProperties = {};
+        for (const [name, variantAggregation] of this.iterateVariantAggregations(variants)) {
+            if (variantAggregation.union && !handledProperties[name]) {
+                this.applyContextPath(aggregation.aggregations[name], variantAggregation.path);
+                // Name correction to show context
+                aggregation.aggregations[name].name =
+                    variantAggregation.path[variantAggregation.path.length - 1].toString();
+                // Mark handled property
+                handledProperties[name] = true;
+            }
+        }
+        if (!Object.keys(handledProperties).length) {
+            return;
+        }
+        // update variant arrays
+        for (const name in handledProperties) {
+            aggregation.aggregations[name].variants = [];
+        }
+        for (const variant of variants) {
+            for (const name in handledProperties) {
+                const variantAggregation = variant.aggregations[name];
+                if (!variantAggregation) {
+                    continue;
+                }
+                aggregation.aggregations[name].variants = [
+                    ...aggregation.aggregations[name].variants,
+                    ...(variantAggregation.variants.length ? variantAggregation.variants : [variantAggregation])
+                ];
+            }
+        }
+    }
+    /**
+     * Recursive method updates paths of all aggregations and properties using passed context path.
+     *
+     * @param aggregation Target aggregation.
+     * @param contextPath Context path.
+     */
+    applyContextPath(aggregation, contextPath) {
+        aggregation.path = aggregation.path.slice();
+        for (let i = 0; i < contextPath.length; i++) {
+            aggregation.path[i] = contextPath[i];
+        }
+        for (const name in aggregation.aggregations) {
+            this.applyContextPath(aggregation.aggregations[name], contextPath);
+        }
+    }
+}
+exports.AggregationValidator = AggregationValidator;
+//# sourceMappingURL=AggregationValidator.js.map

package/dist/page-editor-api/parser/model/ArrayAggregation.d.ts

@@ -0,0 +1,49 @@
+import type { PageData, PropertyPath } from './types';
+import { AggregationType } from './types';
+import type { JSONSchema4 } from 'json-schema';
+import type { PageEditAggregationData } from './ObjectAggregation';
+import { ObjectAggregation } from './ObjectAggregation';
+import type { PageConfig, PageType } from '@sap/ux-specification/dist/types/src';
+/**
+ * Represents an aggregation for array object.
+ */
+export declare class ArrayAggregation extends ObjectAggregation {
+    readonly type = AggregationType.Array;
+    /**
+     * Creates an instance of `ArrayAggregation`.
+     *
+     * @param data Optional aggregation data object used to initialize properties.
+     * @param schema Optional JSON schema fragment associated with this aggregation.
+     */
+    constructor(data?: PageEditAggregationData, schema?: JSONSchema4);
+    /**
+     * Method adds aggregation object.
+     * Overwritten to modify array's children.
+     *
+     * @param name Name of aggregation.
+     * @param aggregation Aggregation to add.
+     * @param path Array of path to aggregation.
+     * @param order Order index.
+     * @returns Added aggregation.
+     */
+    addAggregation(name: string, aggregation: ObjectAggregation, path: PropertyPath, order?: number): ObjectAggregation;
+    /**
+     * Public method which recursively updates aggregation's properties with values from passed data object.
+     * Overwritten to update children aggregations depending on data.
+     *
+     * @param data Data which should be used for value population.
+     * @param page Page config data.
+     * @param pageType Page type.
+     * @param path Aggregation path.
+     */
+    updatePropertiesValues(data: PageData | undefined, page: PageConfig, pageType: PageType, path: PropertyPath): void;
+    /**
+     * Private method resolves primary property of aggregation.
+     * Logic is that we look for certain properties like 'id', 'key', etc. If those properties do not exist, then we take first string property.
+     *
+     * @param aggregation Aggregation to add.
+     * @returns Property name.
+     */
+    private getPrimaryKey;
+}
+//# sourceMappingURL=ArrayAggregation.d.ts.map

package/dist/page-editor-api/parser/model/ArrayAggregation.js

@@ -0,0 +1,122 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayAggregation = void 0;
+const types_1 = require("./types");
+const i18next_1 = __importDefault(require("i18next"));
+const ObjectAggregation_1 = require("./ObjectAggregation");
+/**
+ * Represents an aggregation for array object.
+ */
+class ArrayAggregation extends ObjectAggregation_1.ObjectAggregation {
+    type = types_1.AggregationType.Array;
+    /**
+     * Creates an instance of `ArrayAggregation`.
+     *
+     * @param data Optional aggregation data object used to initialize properties.
+     * @param schema Optional JSON schema fragment associated with this aggregation.
+     */
+    constructor(data, schema) {
+        super(data, schema);
+        this.schemaCreationForms = [
+            {
+                name: types_1.AggregationCreationForm.Generic,
+                kind: types_1.SCHEMA_CREATION_FORM,
+                title: 'PAGE_EDITOR_OUTLINE_ADD_GENERIC_TITLE',
+                disabled: false
+            }
+        ];
+    }
+    /**
+     * Method adds aggregation object.
+     * Overwritten to modify array's children.
+     *
+     * @param name Name of aggregation.
+     * @param aggregation Aggregation to add.
+     * @param path Array of path to aggregation.
+     * @param order Order index.
+     * @returns Added aggregation.
+     */
+    addAggregation(name, aggregation, path, order) {
+        super.addAggregation(name, aggregation, path, order);
+        // Array items are sortable and deletable
+        this.sortableList = true;
+        aggregation.sortableItem = types_1.SortingOptions.Enabled;
+        aggregation.actions = [types_1.AggregationActions.Delete];
+        // Set main title
+        if (aggregation.schema && !aggregation.schema.title) {
+            // Apply custom title as node label for array element
+            aggregation.schema.title = i18next_1.default.t('PAGE_EDITOR_OUTLINE_ARRAY_ITEM', {
+                name: parseInt(name, 10) + 1
+            });
+        }
+        aggregation.custom = true;
+        return aggregation;
+    }
+    /**
+     * Public method which recursively updates aggregation's properties with values from passed data object.
+     * Overwritten to update children aggregations depending on data.
+     *
+     * @param data Data which should be used for value population.
+     * @param page Page config data.
+     * @param pageType Page type.
+     * @param path Aggregation path.
+     */
+    updatePropertiesValues(data, page, pageType, path) {
+        // Base update
+        super.updatePropertiesValues(data, page, pageType, path);
+        if (!Array.isArray(data)) {
+            return;
+        }
+        // Update 'additionalText' property for child aggregations
+        for (let i = 0; i < data.length; i++) {
+            const aggregation = this.aggregations[i];
+            if (!aggregation) {
+                continue;
+            }
+            let additionalText;
+            if (this.isAtomic) {
+                additionalText = data[i];
+            }
+            else {
+                const primaryKey = this.getPrimaryKey(aggregation);
+                additionalText = primaryKey ? data[i][primaryKey] : undefined;
+            }
+            if (typeof additionalText !== 'object') {
+                aggregation.additionalText = additionalText;
+            }
+        }
+    }
+    /**
+     * Private method resolves primary property of aggregation.
+     * Logic is that we look for certain properties like 'id', 'key', etc. If those properties do not exist, then we take first string property.
+     *
+     * @param aggregation Aggregation to add.
+     * @returns Property name.
+     */
+    getPrimaryKey(aggregation) {
+        // Get additional text for item array
+        // Start with predefined most common properties
+        const primaryProperties = ['id', 'title', 'key', 'name'];
+        const schemaProperties = aggregation.schema ? aggregation.schema.properties || {} : {};
+        let primaryProperty;
+        for (const property of primaryProperties) {
+            if (property in schemaProperties) {
+                primaryProperty = property;
+                break;
+            }
+        }
+        // No match, then use very first string property
+        for (const property in schemaProperties) {
+            if (schemaProperties[property].type === 'string') {
+                primaryProperty = property;
+                break;
+            }
+        }
+        return primaryProperty;
+    }
+}
+exports.ArrayAggregation = ArrayAggregation;
+//# sourceMappingURL=ArrayAggregation.js.map