@sap/ux-specification 1.139.8 → 1.139.10

package/dist/specification/src/sync/v4/sync-rules/DecoratorClass.js

@@ -1,756 +1,3 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decorator = exports.BaseClass = exports.BaseConstruct = void 0;
-const ux_specification_types_1 = require("@sap/ux-specification-types");
-const decoration_1 = require("../../common/decoration");
-const i18next_1 = __importDefault(require("i18next"));
-const jsonpath_plus_1 = require("jsonpath-plus");
-const utils_1 = require("./utils");
-/**
- * Adds a message to a schema element.
- * Inlined to avoid circular dependency issues.
- *
- * @param element - The schema element to add the message to
- * @param message - The message parameters
- * @param message.text - The message text
- * @param message.deletable - Whether the message is deletable (default: false)
- */
-function addMessageToSchema(element, { text, deletable = false }) {
-    if (!element[ux_specification_types_1.SchemaTag.messages]) {
-        element[ux_specification_types_1.SchemaTag.messages] = [];
-    }
-    element[ux_specification_types_1.SchemaTag.messages].push({ text, deletable });
-}
-class BaseConstruct {
-    /**
-     * Constructor for BaseConstruct.
-     *
-     * @param settings - General settings including appSchema, app, page, and logger
-     */
-    constructor(settings) {
-        const { app, appSchema, page, logger } = settings || {};
-        // Define properties as non-enumerable to hide them from serialization and Object.keys()
-        Object.defineProperty(this, 'appSchema', {
-            value: appSchema,
-            writable: false,
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(this, 'app', {
-            value: app,
-            writable: false,
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(this, 'page', {
-            value: page,
-            writable: false,
-            enumerable: false,
-            configurable: true
-        });
-        Object.defineProperty(this, 'logger', {
-            value: logger,
-            writable: false,
-            enumerable: false,
-            configurable: true
-        });
-    }
-    /**
-     * Gets the general settings.
-     *
-     * @returns The general settings object
-     */
-    getSettings() {
-        return {
-            appSchema: this.appSchema,
-            app: this.app,
-            page: this.page,
-            logger: this.logger
-        };
-    }
-}
-exports.BaseConstruct = BaseConstruct;
-class BaseClass extends BaseConstruct {
-    /**
-     * Creates an instance of BaseClass.
-     *
-     * @param settings - General settings including appSchema, app, page, and logger
-     */
-    constructor(settings) {
-        super(settings);
-        const name = this.getClassName();
-        // Define base as non-enumerable to hide it from serialization and Object.keys()
-        Object.defineProperty(this, 'base', {
-            value: { name, definition: this.appSchema?.get().definitions?.[name] },
-            writable: true,
-            enumerable: false,
-            configurable: true
-        });
-    }
-    /**
-     * Gets the class name.
-     *
-     * @returns The name of the class
-     */
-    getClassName() {
-        return this.constructor.name;
-    }
-    /**
-     * Gets the base name.
-     *
-     * @returns The base name
-     */
-    getBaseName() {
-        return this.base.name;
-    }
-    /**
-     * Gets the base definition.
-     *
-     * @returns The base definition
-     */
-    getBase() {
-        return this.base.definition;
-    }
-    /**
-     * Creates an annotation path for schema based on entity type, term, and qualifier.
-     *
-     * @param entityTypeName - Entity type name.
-     * @param term - Annotation term.
-     * @param qualifier - Annotation qualifier (optional).
-     * @returns Annotation path based on received params
-     */
-    createAnnotationPath(entityTypeName, term, qualifier) {
-        if (!entityTypeName) {
-            return undefined;
-        }
-        let annotationPath = `/${entityTypeName}/@${term}`;
-        if (qualifier) {
-            annotationPath += `#${qualifier}`;
-        }
-        this.getBase()[ux_specification_types_1.SchemaTag.annotationPath] = annotationPath;
-        return annotationPath;
-    }
-}
-exports.BaseClass = BaseClass;
-class Decorator extends BaseClass {
-    /**
-     * Creates an instance of Decorator.
-     *
-     * @param settings - General settings including appSchema, app, page, and logger
-     */
-    constructor(settings) {
-        super(settings);
-        // Define decoratorContext as non-enumerable to hide from serialization
-        Object.defineProperty(this, 'decoratorContext', {
-            value: {},
-            writable: true,
-            enumerable: false,
-            configurable: true
-        });
-    }
-    /**
-     * Initializes the decorator by applying all decorators to the schema definition.
-     *
-     * The decorator context is structured as:
-     * - `app`: The App configuration (from `this.app.config`, includes manifest)
-     * - `page`: The Page configuration (from `this.page.config`)
-     * - `custom`: Custom context provided by the caller.
-     *
-     * @param customContext - Optional custom context for decorator conditions.
-     *   Use this for runtime-specific conditions like table state, section state, etc.
-     * @param definition - Optional custom definition to apply decorators to.
-     *   If provided, decorators are applied to this definition instead of the one from appSchema.
-     * @example
-     * ```typescript
-     * // Basic initialization (app and page auto-injected)
-     * decorator.init();
-     *
-     * // With custom context for table-specific conditions
-     * decorator.init({
-     *     table: { type: 'GridTable', views: [] }
-     * });
-     *
-     * // With custom definition (for dynamically created definitions)
-     * decorator.init({ table: { type: 'GridTable' } }, customTableDefinition);
-     * ```
-     */
-    init(customContext, definition) {
-        this.decoratorContext = {
-            app: this.app?.config,
-            page: this.page?.config,
-            custom: customContext
-        };
-        // @ToDo activate for actual use of minUI5Version.
-        // const minUi5Version = this.app?.getMinUI5Version();
-        this.applyDecorators(undefined, undefined, definition);
-    }
-    /**
-     * Gets property value from the decorator context using a property path.
-     *
-     * The path must include an explicit source prefix ('app', 'page', or 'custom').
-     *
-     * @param propertyPath - The property path with explicit source prefix - supports full jsonpath syntax
-     * @returns Object containing the final key and its value, or undefined if not found
-     * @example
-     * ```typescript
-     * // With decoratorContext = {
-     * //   app: { manifest: { 'sap.ui5': { routing: {...} } } },
-     * //   page: { isALP: true },
-     * //   custom: { type: 'GridTable', items: [{ name: 'Item1' }, { name: 'Item2' }] }
-     * // }
-     * getPropertyKeyValue('page.isALP')                    // { key: 'isALP', value: true }
-     * getPropertyKeyValue('custom.items[0]')               // { key: '0', value: { name: 'Item1' } }
-     * getPropertyKeyValue('custom.items[1].name')          // { key: 'name', value: 'Item2' }
-     * getPropertyKeyValue('app.manifest["sap.ui5"]')       // Access property with dot in name
-     * getPropertyKeyValue('$.app.manifest["sap.ui5"].routing') // JSONPath with root reference
-     * getPropertyKeyValue('$app["manifest"]["sap.ui5"]')   // Alternative JSONPath format
-     * ```
-     */
-    getPropertyKeyValue(propertyPath) {
-        if (!propertyPath || !this.decoratorContext) {
-            return undefined;
-        }
-        try {
-            // Ensure path starts with $ for JSONPath
-            const jsonPath = propertyPath.startsWith('$') ? propertyPath : `$.${propertyPath}`;
-            // Use JSONPath to query with resultType 'all' to get both value and metadata
-            const results = (0, jsonpath_plus_1.JSONPath)({
-                path: jsonPath,
-                json: this.decoratorContext,
-                resultType: 'all'
-            });
-            // JSONPath with resultType 'all' returns an array of result objects
-            if (!results || results.length === 0) {
-                return undefined;
-            }
-            // Get the first result (wrap: false behavior)
-            const result = results[0];
-            // parentProperty contains the last key in the path
-            const key = String(result.parentProperty);
-            const value = result.value;
-            return { key, value };
-        }
-        catch {
-            // If JSONPath fails, return undefined
-            return undefined;
-        }
-    }
-    /**
-     * Evaluates a single dependency condition.
-     *
-     * @param condition - The single condition to evaluate
-     * @param condition.path - The property path to check
-     * @param condition.dependsOn - Optional custom condition function
-     * @param condition.expectedValue - Optional expected value for equality check
-     * @param condition.negate - Optional flag to invert the condition result
-     * @returns Object containing whether condition passed and the dependency value
-     */
-    evaluateSingleCondition(condition) {
-        // Handle special __always__ path (from @hide(true))
-        if (condition.path === '__always__') {
-            return { passed: true, value: true, key: '__always__' };
-        }
-        const result = this.getPropertyKeyValue(condition.path);
-        const key = result?.key ?? condition.path;
-        const value = result?.value;
-        let passed = false;
-        if (condition.dependsOn) {
-            // Use custom condition function
-            passed = condition.dependsOn(value);
-        }
-        else if (condition.expectedValue !== undefined) {
-            // Use simple equality check
-            passed = value === condition.expectedValue;
-        }
-        else {
-            // Default: truthy check
-            passed = !!value;
-        }
-        // Apply negation if negate flag is set (from not() helper)
-        if (condition.negate) {
-            passed = !passed;
-        }
-        return { passed, value, key };
-    }
-    /**
-     * Helper method to add a message to the schema property based on value condition.
-     *
-     * @param condition - DecoratorMetadata or EnumValueCondition object containing condition details
-     * @param syncRuleProviderInstance - The instance of the sync rule provider
-     * @param definition - The schema property definition
-     * @param i18nProperties - i18n properties for message translation
-     * @param i18nProperties.propertyName - The property name for the message
-     * @param i18nProperties.context - The context for the message
-     */
-    addConditionalMessage(condition, syncRuleProviderInstance, definition, i18nProperties) {
-        // Handle new MessageConfig format (from msg() helper)
-        const metadata = condition;
-        if (metadata.messageConfig && (0, decoration_1.isMessageConfig)(metadata.messageConfig)) {
-            // Resolve any PathNode values in the params
-            const resolvedParams = this.resolveMessageParams(metadata.messageConfig.params);
-            const messageText = i18next_1.default.t(metadata.messageConfig.i18nKey, resolvedParams);
-            addMessageToSchema(definition, { text: messageText, deletable: metadata.messageConfig.deletable });
-            return;
-        }
-        // Handle legacy DependsOnMessage format
-        if (!condition.message) {
-            return;
-        }
-        let messageText;
-        if (typeof condition.message.text === 'function') {
-            messageText = condition.message.text(syncRuleProviderInstance);
-        }
-        else if (typeof condition.message.text === 'string') {
-            messageText = condition.message.text;
-        }
-        else if (condition.message.text === true) {
-            // true means use default i18n translation
-            messageText = i18next_1.default.t('PROPERTY_NOT_ALLOWED', { ...i18nProperties });
-        }
-        else {
-            messageText = i18next_1.default.t('PROPERTY_NOT_ALLOWED', { ...i18nProperties });
-        }
-        addMessageToSchema(definition, { text: messageText, deletable: condition.message.deletable });
-    }
-    /**
-     * Resolves PathNode values in message params to their actual values from the decorator context.
-     *
-     * @param params - The message params potentially containing PathNode values
-     * @returns The params with PathNode values resolved to actual values
-     */
-    resolveMessageParams(params) {
-        if (!params) {
-            return params;
-        }
-        const resolved = {};
-        for (const [key, value] of Object.entries(params)) {
-            if ((0, decoration_1.isPathNode)(value)) {
-                // Resolve PathNode to actual value
-                const result = this.getPropertyKeyValue((0, decoration_1.getPath)(value));
-                resolved[key] = result?.value ?? '';
-            }
-            else {
-                resolved[key] = value;
-            }
-        }
-        return resolved;
-    }
-    /**
-     * Gets the context message from evaluation results.
-     *
-     * @param results - The evaluation results
-     * @returns The context message string
-     */
-    getContextForMessage(results) {
-        return results
-            .filter((result) => !result.passed)
-            .map((result) => `${result.key}: ${result.value}`)
-            .join(', ');
-    }
-    /**
-     * Evaluates an AND condition item which can be either a single condition or a nested OR group.
-     *
-     * @param conditionItem - The condition item to evaluate
-     * @returns Object containing whether condition passed and evaluation details
-     */
-    evaluateAndConditionItem(conditionItem) {
-        // Check if this is a nested OR group
-        if ((0, decoration_1.isOrConditionGroup)(conditionItem)) {
-            // Evaluate the nested OR - at least one must pass
-            return this.evaluateOrConditions(conditionItem.__orConditions);
-        }
-        // It's a single condition
-        const result = this.evaluateSingleCondition(conditionItem);
-        return { passed: result.passed, results: [result] };
-    }
-    /**
-     * Evaluates OR conditions (at least one condition must match).
-     * Supports both single conditions and nested AND groups.
-     *
-     * @param orConditions - Array of condition items (single conditions or AND groups)
-     * @returns Object containing whether any condition passed and evaluation details
-     */
-    evaluateOrConditions(orConditions) {
-        const allResults = [];
-        for (const conditionItem of orConditions) {
-            // Check if this is a nested AND group
-            if ((0, decoration_1.isAndConditionGroup)(conditionItem)) {
-                // Evaluate all conditions in the AND group - all must pass
-                const andResults = [];
-                let allAndPassed = true;
-                for (const andItem of conditionItem.__andConditions) {
-                    const { passed, results } = this.evaluateAndConditionItem(andItem);
-                    andResults.push(...results);
-                    if (!passed) {
-                        allAndPassed = false;
-                        // Don't break - we want all results for context
-                    }
-                }
-                allResults.push(...andResults);
-                if (allAndPassed) {
-                    // Short-circuit: if this AND group passes, the OR passes
-                    return { passed: true, results: allResults };
-                }
-            }
-            else {
-                // Single condition (symmetric with AND handling)
-                const result = this.evaluateSingleCondition(conditionItem);
-                allResults.push(result);
-                if (result.passed) {
-                    // Short-circuit: if any condition passes, the OR passes
-                    return { passed: true, results: allResults };
-                }
-            }
-        }
-        return { passed: false, results: allResults };
-    }
-    /**
-     * Evaluates AND conditions (all conditions must match).
-     * Supports both single conditions and nested OR groups.
-     *
-     * @param andConditions - Array of condition items (single conditions or OR groups)
-     * @returns Object containing whether all conditions passed and evaluation details
-     */
-    evaluateAndConditions(andConditions) {
-        const allResults = [];
-        let allPassed = true;
-        for (const conditionItem of andConditions) {
-            const { passed, results } = this.evaluateAndConditionItem(conditionItem);
-            allResults.push(...results);
-            if (!passed) {
-                allPassed = false;
-                // Continue to collect all results for context
-            }
-        }
-        return { passed: allPassed, results: allResults };
-    }
-    /**
-     * Evaluates condition metadata and returns whether the condition is met and the context.
-     *
-     * @param conditionInfo - The condition metadata
-     * @returns Object with passed (boolean) and context (string)
-     */
-    evaluateCondition(conditionInfo) {
-        let passed = false;
-        let context = '';
-        if (conditionInfo.orConditions && Array.isArray(conditionInfo.orConditions)) {
-            // OR logic: At least one condition object must match
-            const result = this.evaluateOrConditions(conditionInfo.orConditions);
-            passed = result.passed;
-            context = this.getContextForMessage(result.results);
-        }
-        else if (conditionInfo.conditions && Array.isArray(conditionInfo.conditions)) {
-            // Multi-condition: ALL must be met (AND logic)
-            // Now supports nested OR groups via evaluateAndConditions
-            const result = this.evaluateAndConditions(conditionInfo.conditions);
-            passed = result.passed;
-            context = this.getContextForMessage(result.results);
-        }
-        else if (conditionInfo.path) {
-            // Single condition
-            const result = this.evaluateSingleCondition(conditionInfo);
-            passed = result.passed;
-            context = this.getContextForMessage([result]);
-        }
-        return { passed, context };
-    }
-    /**
-     * Iterates over schema properties and yields property info for decorator processing.
-     * Centralizes the guard clause and property iteration logic.
-     *
-     * @param schemaDefinition - The schema definition to process
-     * @param target - The target object (used for guard clause validation)
-     * @yields Property name and definition for each property in the schema
-     */
-    *iterateProperties(schemaDefinition, target) {
-        if (!schemaDefinition?.properties || !target) {
-            return;
-        }
-        for (const propertyName in schemaDefinition.properties) {
-            const property = schemaDefinition.properties[propertyName];
-            yield { propertyName, property };
-        }
-    }
-    /**
-     * Applies the hide decorator to the schema definition.
-     * Hides properties when their condition evaluates to true, but only if
-     * the message decorator did not add any messages to the property.
-     *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
-     */
-    applyHideDecorator(schemaDefinition, syncRuleProviderInstance) {
-        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, syncRuleProviderInstance)) {
-            const hideInfo = (0, decoration_1.getHideMetadata)(syncRuleProviderInstance, propertyName);
-            if (hideInfo) {
-                const { passed } = this.evaluateCondition(hideInfo);
-                // Hide when condition IS met (passed=true means hide)
-                // But only if no messages were added by the message decorator
-                const hasMessages = Array.isArray(property[ux_specification_types_1.SchemaTag.messages]) && property[ux_specification_types_1.SchemaTag.messages].length > 0;
-                if (passed && !hasMessages) {
-                    property[ux_specification_types_1.SchemaTag.hidden] = true;
-                }
-            }
-        }
-    }
-    /**
-     * Applies the message decorator to the schema definition.
-     * Shows messages when their condition evaluates to true.
-     *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
-     */
-    applyMessageDecorator(schemaDefinition, syncRuleProviderInstance) {
-        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, syncRuleProviderInstance)) {
-            const messageInfoList = (0, decoration_1.getMessageMetadata)(syncRuleProviderInstance, propertyName);
-            if (messageInfoList) {
-                for (const messageInfo of messageInfoList) {
-                    const { passed, context } = this.evaluateCondition(messageInfo);
-                    if (passed && (messageInfo.message || messageInfo.messageConfig)) {
-                        this.addConditionalMessage(messageInfo, syncRuleProviderInstance, property, {
-                            propertyName,
-                            context
-                        });
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Applies the readonly decorator to the schema definition.
-     * Marks properties as readonly when their condition evaluates to true.
-     *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
-     */
-    applyReadonlyDecorator(schemaDefinition, syncRuleProviderInstance) {
-        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, syncRuleProviderInstance)) {
-            const readonlyInfo = (0, decoration_1.getReadonlyMetadata)(syncRuleProviderInstance, propertyName);
-            if (readonlyInfo) {
-                const { passed } = this.evaluateCondition(readonlyInfo);
-                if (passed) {
-                    property.readOnly = true;
-                }
-            }
-        }
-    }
-    /**
-     * Applies the enums decorator to the schema definition.
-     * Restricts enum values when their condition evaluates to true.
-     * If multiple @enums decorators exist on the same property, the first matching condition wins.
-     *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
-     */
-    applyEnumsDecorator(schemaDefinition, syncRuleProviderInstance) {
-        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, syncRuleProviderInstance)) {
-            const enumsMetadataList = (0, decoration_1.getEnumsMetadata)(syncRuleProviderInstance, propertyName);
-            if (!enumsMetadataList?.length) {
-                continue;
-            }
-            // Find first matching condition (first match wins)
-            for (const enumsMetadata of enumsMetadataList) {
-                const { passed } = this.evaluateCondition(enumsMetadata);
-                if (passed) {
-                    const currentEnumValues = this.resolveEnumFromProperty(property);
-                    if (currentEnumValues) {
-                        // Filter to only allowed values that exist in original enum
-                        const filteredValues = enumsMetadata.allowedValues.filter((v) => currentEnumValues.includes(v));
-                        this.applyFilteredEnumToProperty(property, filteredValues);
-                    }
-                    break; // First match wins, stop processing
-                }
-            }
-        }
-    }
-    /**
-     * Gets the validity metadata for a property.
-     *
-     * @param target - The target object
-     * @param propertyName - The property name
-     * @returns The validity metadata or undefined
-     */
-    getValidityMetadata(target, propertyName) {
-        let validityInfo;
-        if (target) {
-            validityInfo = Reflect.getMetadata(decoration_1.metadataKeys.validity, target, propertyName);
-        }
-        return validityInfo;
-    }
-    /**
-     * Resolves an enum array from a property definition.
-     * Handles both inline enums and $ref to enum definitions.
-     *
-     * @param property - The property definition
-     * @returns The enum array or undefined if not found
-     */
-    resolveEnumFromProperty(property) {
-        // Check for inline enum
-        if (property?.enum && Array.isArray(property.enum)) {
-            return property.enum;
-        }
-        // Check for $ref to an enum definition
-        if (property?.$ref) {
-            const refName = property.$ref.replace('#/definitions/', '');
-            const schema = this.appSchema?.get();
-            const refDef = schema?.definitions?.[refName];
-            if (refDef?.enum && Array.isArray(refDef.enum)) {
-                return refDef.enum;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * Applies filtered enum values to a property.
-     * For $ref properties, inlines the filtered enum, copies the type from the referenced definition, and removes the $ref.
-     * For inline enum properties, updates the enum directly.
-     *
-     * @param property - The property definition to update
-     * @param filteredEnum - The filtered enum values
-     */
-    applyFilteredEnumToProperty(property, filteredEnum) {
-        if (property.$ref) {
-            // For $ref properties, resolve the referenced definition to get the type
-            const refName = property.$ref.replace('#/definitions/', '');
-            const schema = this.appSchema?.get();
-            const refDef = schema?.definitions?.[refName];
-            // Copy the type from the referenced definition if it exists
-            if (refDef?.type) {
-                property.type = refDef.type;
-            }
-            // Remove the $ref and inline the filtered enum
-            delete property.$ref;
-            property.enum = filteredEnum;
-        }
-        else {
-            // For inline enum properties, update directly
-            property.enum = filteredEnum;
-        }
-    }
-    /**
-     * Applies the validity decorator to the schema definition based on the sync rule provider instance and minimum UI5 version.
-     *
-     * @param schemaDefinition The schema definition to apply the validity decorator to
-     * @param syncRuleProviderInstance The instance of the sync rule provider
-     * @param minUI5Version The minimum UI5 version to consider for validity checks
-     */
-    applyValidityDecorator(schemaDefinition, syncRuleProviderInstance, minUI5Version) {
-        if (!schemaDefinition?.properties || !syncRuleProviderInstance || !minUI5Version) {
-            return;
-        }
-        for (const propertyName in schemaDefinition.properties) {
-            const property = schemaDefinition.properties[propertyName];
-            const validityInfo = this.getValidityMetadata(syncRuleProviderInstance, propertyName);
-            // Check if property has a 'since' requirement that exceeds the app's minUI5Version
-            if (validityInfo?.since && !(0, utils_1.compareUI5Versions)(minUI5Version, validityInfo.since)) {
-                property[ux_specification_types_1.SchemaTag.hidden] = true;
-                // possible message?
-            }
-            // Process enum validity configuration from @validity decorator
-            // Supports both inline enums and $ref to enum definitions
-            if (validityInfo?.enum) {
-                const enumValues = this.resolveEnumFromProperty(property);
-                if (enumValues) {
-                    const filteredEnum = enumValues.filter((enumValue) => {
-                        const enumValueStr = String(enumValue);
-                        const condition = validityInfo.enum[enumValueStr];
-                        if (!condition) {
-                            return true; // Keep values without conditions
-                        }
-                        // Check UI5 version requirement (if specified)
-                        if (condition.since && minUI5Version) {
-                            if (!(0, utils_1.compareUI5Versions)(minUI5Version, condition.since)) {
-                                if (condition.message) {
-                                    this.addConditionalMessage(condition, syncRuleProviderInstance, property, {
-                                        propertyName: enumValueStr
-                                    });
-                                }
-                                return false; // Version requirement not met
-                            }
-                        }
-                        // Check property dependency using dependsOn function
-                        if (condition.dependsOn) {
-                            if (!condition.dependsOn(syncRuleProviderInstance)) {
-                                if (condition.message) {
-                                    this.addConditionalMessage(condition, syncRuleProviderInstance, property, {
-                                        propertyName: enumValueStr
-                                    });
-                                }
-                                return false; // Dependency condition not met
-                            }
-                        }
-                        return true;
-                    });
-                    // Only update if enum was actually filtered
-                    if (filteredEnum.length !== enumValues.length) {
-                        this.applyFilteredEnumToProperty(property, filteredEnum);
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Applies the isViewNode decorator to the schema definition based on the target and property name.
-     *
-     * @param schemaDefinition The schema definition to apply the isViewNode decorator to
-     * @param target The target object or function
-     * @param propertyName The property name (optional)
-     */
-    applyIsViewNodeDecorator(schemaDefinition, target, propertyName) {
-        const isViewNode = Reflect.getMetadata(decoration_1.metadataKeys.isViewNode, target, propertyName);
-        if (isViewNode !== undefined) {
-            schemaDefinition[ux_specification_types_1.SchemaTag.isViewNode] = isViewNode;
-            schemaDefinition.properties = schemaDefinition.properties || {};
-        }
-    }
-    /**
-     * Applies the description decorator to the schema definition.
-     *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param target - The target object or function
-     * @param propertyName - The property name (optional)
-     */
-    applyDescriptionDecorator(schemaDefinition, target, propertyName) {
-        const description = Reflect.getMetadata(decoration_1.metadataKeys.description, target, propertyName);
-        if (description !== undefined) {
-            schemaDefinition.description = description;
-        }
-    }
-    /**
-     * Applies all decorators to the schema definition.
-     *
-     * @param minUi5Version - The minimum UI5 version (optional)
-     * @param propertyName - The property name (optional)
-     * @param customDefinition - Optional custom definition to apply decorators to (overrides getBase())
-     * @returns Object containing the definition
-     */
-    applyDecorators(minUi5Version, propertyName, customDefinition) {
-        const definition = customDefinition ?? this.getBase();
-        if (!definition) {
-            return;
-        }
-        const target = propertyName ? this : this.constructor;
-        // Apply description decorator
-        this.applyDescriptionDecorator(definition, target, propertyName);
-        // Apply isViewNode decorator
-        this.applyIsViewNodeDecorator(definition, target, propertyName);
-        // Apply validity decorator (for properties)
-        this.applyValidityDecorator(definition, this, minUi5Version);
-        // Apply enums decorator - filter enum values based on conditions
-        this.applyEnumsDecorator(definition, this);
-        // Apply message decorator - show messages based on conditions
-        // NOTE: Message decorator must run before hide decorator so hide can check for messages
-        this.applyMessageDecorator(definition, this);
-        // Apply hide decorator - hide properties based on conditions
-        // NOTE: Only hides if message decorator did not add any messages
-        this.applyHideDecorator(definition, this);
-        // Apply readonly decorator - mark properties as readonly based on conditions
-        this.applyReadonlyDecorator(definition, this);
-        return { definition };
-    }
-}
-exports.Decorator = Decorator;
 //# sourceMappingURL=DecoratorClass.js.map