@sap/ux-specification 1.136.14 → 1.136.16

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

@@ -3,10 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Decorator = exports.BaseClass = void 0;
+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.
@@ -23,25 +24,67 @@ function addMessageToSchema(element, { text, deletable = false }) {
     }
     element[ux_specification_types_1.SchemaTag.messages].push({ text, deletable });
 }
-class BaseClass {
+class BaseConstruct {
     /**
-     * Creates an instance of BaseClass.
+     * Constructor for BaseConstruct.
      *
-     * @param appSchema - The application schema definition
+     * @param settings - General settings including appSchema, app, page, and logger
      */
-    constructor(appSchema) {
-        // Define appSchema as non-enumerable to hide it from serialization and Object.keys()
+    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: true,
+            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();
-        const definitions = appSchema?.definitions;
         // Define base as non-enumerable to hide it from serialization and Object.keys()
         Object.defineProperty(this, 'base', {
-            value: { name, definition: definitions?.[name] },
+            value: { name, definition: this.appSchema?.get().definitions?.[name] },
             writable: true,
             enumerable: false,
             configurable: true
@@ -71,22 +114,6 @@ class BaseClass {
     getBase() {
         return this.base.definition;
     }
-    /**
-     * Sets the base definition and name.
-     *
-     * @param base - The base object containing name and definition
-     */
-    setBase(base) {
-        this.base = base;
-    }
-    /**
-     * Gets the definitions from the app schema.
-     *
-     * @returns The definitions object or undefined
-     */
-    getDefinitions() {
-        return this.appSchema?.definitions;
-    }
     /**
      * Creates an annotation path for schema based on entity type, term, and qualifier.
      *
@@ -110,57 +137,106 @@ class BaseClass {
 exports.BaseClass = BaseClass;
 class Decorator extends BaseClass {
     /**
-     * Sets the parent decorator instance for this object.
-     * This enables nested decorators to access parent properties using the '../' prefix in @dependsOn.
+     * Creates an instance of Decorator.
      *
-     * @param parent - The parent Decorator instance
-     * @returns this (for method chaining)
+     * @param settings - General settings including appSchema, app, page, and logger
      */
-    setParent(parent) {
-        this.__parent__ = parent;
-        return this;
+    constructor(settings) {
+        super(settings);
+        // Define decoratorContext as non-enumerable to hide from serialization
+        Object.defineProperty(this, 'decoratorContext', {
+            value: {},
+            writable: true,
+            enumerable: false,
+            configurable: true
+        });
     }
     /**
-     * Gets the parent decorator instance if it exists.
+     * 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: [] }
+     * });
      *
-     * @returns The parent Decorator instance or undefined
+     * // With custom definition (for dynamically created definitions)
+     * decorator.init({ table: { type: 'GridTable' } }, customTableDefinition);
+     * ```
      */
-    getParent() {
-        return this.__parent__;
+    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);
     }
     /**
-     * Helper method to get property value from an object using a property path.
-     * Supports simple property names (e.g., 'visualFilters'), nested paths (e.g., 'settings.enabled'),
-     * and parent traversal (e.g., '../type' to access parent object's type property).
+     * Gets property value from the decorator context using a property path.
      *
-     * @param syncInstance - The object instance to retrieve the property value from
-     * @param propertyPath - The property path (e.g., 'visualFilters', 'settings.enabled', or '../type')
+     * 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(syncInstance, propertyPath) {
-        if (!syncInstance || !propertyPath) {
+    getPropertyKeyValue(propertyPath) {
+        if (!propertyPath || !this.decoratorContext) {
             return undefined;
         }
-        // Handle parent traversal (../)
-        if (propertyPath.startsWith('../')) {
-            const parent = this.getParent();
-            if (!parent) {
-                return undefined;
-            }
-            // Remove '../' and get the property from parent
-            const parentPath = propertyPath.substring(3);
-            return this.getPropertyKeyValue(parent, parentPath);
-        }
-        const keys = propertyPath.split('.');
-        let value = syncInstance;
-        for (const key of keys) {
-            if (value === null || value === 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;
             }
-            value = value[key];
+            // 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;
         }
-        const key = keys[keys.length - 1];
-        return { key, value };
     }
     /**
      * Evaluates a single dependency condition.
@@ -169,11 +245,17 @@ class Decorator extends BaseClass {
      * @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 syncRuleProviderInstance - The sync rule provider instance
+     * @param condition.negate - Optional flag to invert the condition result
      * @returns Object containing whether condition passed and the dependency value
      */
-    evaluateSingleCondition(condition, syncRuleProviderInstance) {
-        const { key, value } = this.getPropertyKeyValue(syncRuleProviderInstance, condition.path);
+    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
@@ -187,12 +269,16 @@ class Decorator extends BaseClass {
             // 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 - EnumValueCondition object containing condition details
+     * @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
@@ -200,11 +286,58 @@ class Decorator extends BaseClass {
      * @param i18nProperties.context - The context for the message
      */
     addConditionalMessage(condition, syncRuleProviderInstance, definition, i18nProperties) {
-        const messageText = typeof condition.message.text === 'function'
-            ? condition.message.text(syncRuleProviderInstance)
-            : i18next_1.default.t('PROPERTY_NOT_ALLOWED', { ...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.
      *
@@ -218,43 +351,217 @@ class Decorator extends BaseClass {
             .join(', ');
     }
     /**
-     * Applies the dependsOn decorator to the schema definition.
+     * Evaluates an AND condition item which can be either a single condition or a nested OR group.
      *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
+     * @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
      */
-    applyDependsOnDecorator(schemaDefinition, syncRuleProviderInstance) {
-        if (!schemaDefinition?.properties || !syncRuleProviderInstance) {
+    *iterateProperties(schemaDefinition, target) {
+        if (!schemaDefinition?.properties || !target) {
             return;
         }
         for (const propertyName in schemaDefinition.properties) {
             const property = schemaDefinition.properties[propertyName];
-            const dependsOnInfo = (0, decoration_1.getDependsOnMetadata)(syncRuleProviderInstance, propertyName);
-            if (dependsOnInfo) {
-                let shouldHide = false;
-                let context = '';
-                // Check if this is multi-condition or single condition
-                if (dependsOnInfo.conditions && Array.isArray(dependsOnInfo.conditions)) {
-                    // Multi-condition: ALL must be met (AND logic)
-                    const results = dependsOnInfo.conditions.map((condition) => this.evaluateSingleCondition(condition, syncRuleProviderInstance));
-                    // All conditions must pass
-                    shouldHide = !results.every((result) => result.passed);
-                    context = this.getContextForMessage(results);
-                }
-                else {
-                    const result = this.evaluateSingleCondition(dependsOnInfo, syncRuleProviderInstance);
-                    context = this.getContextForMessage([result]);
-                    shouldHide = !result.passed;
+            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;
                 }
-                if (shouldHide) {
-                    if (dependsOnInfo.message) {
-                        this.addConditionalMessage(dependsOnInfo, syncRuleProviderInstance, property, {
+            }
+        }
+    }
+    /**
+     * 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
                         });
                     }
-                    // Alternative to hide: delete schemaDefinition.properties[propertyName];
-                    property[ux_specification_types_1.SchemaTag.hidden] = true;
+                }
+            }
+        }
+    }
+    /**
+     * 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
                 }
             }
         }
@@ -273,6 +580,56 @@ class Decorator extends BaseClass {
         }
         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.
      *
@@ -292,39 +649,46 @@ class Decorator extends BaseClass {
                 property[ux_specification_types_1.SchemaTag.hidden] = true;
                 // possible message?
             }
-            // Process inline enum validity configuration from @validity decorator
-            if (validityInfo?.enum && property?.enum && Array.isArray(property.enum)) {
-                const filteredEnum = property.enum.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
-                                });
+            // 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
                             }
-                            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
-                                });
+                        // 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 false; // Dependency condition not met
                         }
+                        return true;
+                    });
+                    // Only update if enum was actually filtered
+                    if (filteredEnum.length !== enumValues.length) {
+                        this.applyFilteredEnumToProperty(property, filteredEnum);
                     }
-                    return true;
-                });
-                property.enum = filteredEnum;
+                }
             }
         }
     }
@@ -355,40 +719,16 @@ class Decorator extends BaseClass {
             schemaDefinition.description = description;
         }
     }
-    /**
-     * Applies the hidden 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)
-     */
-    applyHiddenDecorator(schemaDefinition, target, propertyName) {
-        const hiddenCondition = Reflect.getMetadata(decoration_1.metadataKeys.hidden, target, propertyName);
-        if (typeof hiddenCondition === 'function') {
-            const shouldHide = hiddenCondition(this);
-            if (shouldHide) {
-                schemaDefinition[ux_specification_types_1.SchemaTag.hidden] = true;
-            }
-        }
-        else if (hiddenCondition === true) {
-            schemaDefinition[ux_specification_types_1.SchemaTag.hidden] = true;
-        }
-        if (!schemaDefinition?.properties) {
-            return;
-        }
-        for (const propertyName in schemaDefinition.properties) {
-            this.applyHiddenDecorator(schemaDefinition.properties[propertyName], target, propertyName);
-        }
-    }
     /**
      * 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) {
-        const definition = this.getDefinitions()?.[this.getBaseName()];
+    applyDecorators(minUi5Version, propertyName, customDefinition) {
+        const definition = customDefinition ?? this.getBase();
         if (!definition) {
             return;
         }
@@ -399,10 +739,16 @@ class Decorator extends BaseClass {
         this.applyIsViewNodeDecorator(definition, target, propertyName);
         // Apply validity decorator (for properties)
         this.applyValidityDecorator(definition, this, minUi5Version);
-        // Apply dependsOn decorator - check property dependencies
-        this.applyDependsOnDecorator(definition, this);
-        // Apply hidden decorator - evaluate condition function if provided
-        this.applyHiddenDecorator(definition, this);
+        // 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 };
     }
 }