@sap/ux-specification 1.124.35 → 1.124.37

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

@@ -10,13 +10,13 @@ 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.
+ * Appends a message to a schema element's message array.
+ * Inlined here 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)
+ * @param element - The schema element that will receive the message
+ * @param message - The message content and options
+ * @param message.text - The translated message text to display
+ * @param message.deletable - Whether the user can dismiss the message (default: false)
  */
 function addMessageToSchema(element, { text, deletable = false }) {
     if (!element[ux_specification_types_1.SchemaTag.messages]) {
@@ -26,9 +26,9 @@ function addMessageToSchema(element, { text, deletable = false }) {
 }
 class BaseConstruct {
     /**
-     * Constructor for BaseConstruct.
+     * Creates the base construct with access to the app schema, app/page configuration, and logger.
      *
-     * @param settings - General settings including appSchema, app, page, and logger
+     * @param settings - Shared context (appSchema, app, page, logger) passed to all decorator classes
      */
     constructor(settings) {
         const { app, appSchema, page, logger } = settings || {};
@@ -59,9 +59,9 @@ class BaseConstruct {
         });
     }
     /**
-     * Gets the general settings.
+     * Returns the shared context (appSchema, app, page, logger) for use by subclasses or callers.
      *
-     * @returns The general settings object
+     * @returns The current settings object
      */
     getSettings() {
         return {
@@ -75,9 +75,9 @@ class BaseConstruct {
 exports.BaseConstruct = BaseConstruct;
 class BaseClass extends BaseConstruct {
     /**
-     * Creates an instance of BaseClass.
+     * Looks up the matching schema definition by class name and stores it as the base.
      *
-     * @param settings - General settings including appSchema, app, page, and logger
+     * @param settings - Shared context (appSchema, app, page, logger) passed to all decorator classes
      */
     constructor(settings) {
         super(settings);
@@ -91,36 +91,36 @@ class BaseClass extends BaseConstruct {
         });
     }
     /**
-     * Gets the class name.
+     * Returns the class name used to look up the matching schema definition.
      *
-     * @returns The name of the class
+     * @returns The constructor name of this class
      */
     getClassName() {
         return this.constructor.name;
     }
     /**
-     * Gets the base name.
+     * Returns the name stored at construction time for the schema definition lookup.
      *
-     * @returns The base name
+     * @returns The base definition name
      */
     getBaseName() {
         return this.base.name;
     }
     /**
-     * Gets the base definition.
+     * Returns the schema definition that decorators are applied to.
      *
-     * @returns The base definition
+     * @returns The JSON schema definition for this class
      */
     getBase() {
         return this.base.definition;
     }
     /**
-     * Creates an annotation path for schema based on entity type, term, and qualifier.
+     * Builds an annotation path like `/<EntityType>/@<Term>#<Qualifier>` and stores it on the schema definition.
      *
-     * @param entityTypeName - Entity type name.
-     * @param term - Annotation term.
-     * @param qualifier - Annotation qualifier (optional).
-     * @returns Annotation path based on received params
+     * @param entityTypeName - The OData entity type name (e.g. "SalesOrderItem")
+     * @param term - The annotation term (e.g. "com.sap.vocabularies.UI.v1.LineItem")
+     * @param qualifier - Optional qualifier to disambiguate multiple annotations of the same term
+     * @returns The built annotation path, or undefined if entityTypeName is empty
      */
     createAnnotationPath(entityTypeName, term, qualifier) {
         if (!entityTypeName) {
@@ -137,9 +137,9 @@ class BaseClass extends BaseConstruct {
 exports.BaseClass = BaseClass;
 class Decorator extends BaseClass {
     /**
-     * Creates an instance of Decorator.
+     * Sets up the decorator context as non-enumerable so it stays hidden from serialization.
      *
-     * @param settings - General settings including appSchema, app, page, and logger
+     * @param settings - Shared context (appSchema, app, page, logger) passed to all decorator classes
      */
     constructor(settings) {
         super(settings);
@@ -152,17 +152,11 @@ class Decorator extends BaseClass {
         });
     }
     /**
-     * Initializes the decorator by applying all decorators to the schema definition.
+     * Builds the decorator context from app, page, and custom values, then applies all
+     * decorators (enums, message, hide, readonly) 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.
+     * @param customContext - Specific values (e.g. table state, section state) used for condition evaluation
+     * @param definition - Override the schema definition to decorate (defaults to getBase())
      * @example
      * ```typescript
      * // Basic initialization (app and page auto-injected)
@@ -179,21 +173,22 @@ class Decorator extends BaseClass {
      */
     init(customContext, definition) {
         this.decoratorContext = {
-            app: this.app?.config,
-            page: this.page?.config,
-            custom: customContext
+            app: this.app,
+            page: this.page,
+            custom: customContext,
+            schema: this.appSchema
         };
         // @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').
+     * Resolves a dotted property path (e.g. `page.isALP`, `custom.items[0].name`) against
+     * the decorator context using JSONPath. The path must start with a known 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
+     * @param propertyPath - Dotted path with source prefix, supports full JSONPath syntax
+     * @returns The resolved `{ key, value }` pair, or undefined if the path does not resolve
      * @example
      * ```typescript
      * // With decoratorContext = {
@@ -239,14 +234,11 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * 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
+     * Evaluates one condition: resolves the path, applies the check (custom function,
+     * equality, or truthy), and optionally negates the result (for `not()` conditions).
+     *
+     * @param condition - A single condition with path, expected value, and optional negate flag
+     * @returns Whether the condition passed along with the resolved value and key
      */
     evaluateSingleCondition(condition) {
         // Handle special __always__ path (from @hide(true))
@@ -276,16 +268,17 @@ class Decorator extends BaseClass {
         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
+     * Translates and attaches a message to a schema property.
+     * Supports both the new `MessageConfig` format (from `msg()` helper) and the legacy `DependsOnMessage` format.
+     *
+     * @param condition - The decorator metadata or enum value condition containing the message definition
+     * @param decoratedClass - The decorated class instance, used for legacy function-based message text
+     * @param definition - The schema property definition to attach the message to
+     * @param i18nProperties - Context for i18n translation (propertyName, evaluation context)
+     * @param i18nProperties.propertyName - The property name used as i18n parameter
+     * @param i18nProperties.context - The evaluation context string used as i18n parameter
      */
-    addConditionalMessage(condition, syncRuleProviderInstance, definition, i18nProperties) {
+    addConditionalMessage(condition, decoratedClass, definition, i18nProperties) {
         // Handle new MessageConfig format (from msg() helper)
         const metadata = condition;
         if (metadata.messageConfig && (0, decoration_1.isMessageConfig)(metadata.messageConfig)) {
@@ -301,7 +294,7 @@ class Decorator extends BaseClass {
         }
         let messageText;
         if (typeof condition.message.text === 'function') {
-            messageText = condition.message.text(syncRuleProviderInstance);
+            messageText = condition.message.text(decoratedClass);
         }
         else if (typeof condition.message.text === 'string') {
             messageText = condition.message.text;
@@ -316,10 +309,10 @@ class Decorator extends BaseClass {
         addMessageToSchema(definition, { text: messageText, deletable: condition.message.deletable });
     }
     /**
-     * Resolves PathNode values in message params to their actual values from the decorator context.
+     * Resolves any `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
+     * @param params - Message parameters that may contain PathNode references
+     * @returns A new params object with PathNode values replaced by their resolved context values
      */
     resolveMessageParams(params) {
         if (!params) {
@@ -339,10 +332,11 @@ class Decorator extends BaseClass {
         return resolved;
     }
     /**
-     * Gets the context message from evaluation results.
+     * Builds a human-readable context string from the evaluation results that did not pass.
+     * Used for diagnostic messages showing which conditions were unmet.
      *
-     * @param results - The evaluation results
-     * @returns The context message string
+     * @param results - The condition evaluation results to summarize
+     * @returns A comma-separated string of `key: value` pairs for failed conditions
      */
     getContextForMessage(results) {
         return results
@@ -351,10 +345,10 @@ class Decorator extends BaseClass {
             .join(', ');
     }
     /**
-     * Evaluates an AND condition item which can be either a single condition or a nested OR group.
+     * Evaluates one item inside an AND group — 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
+     * @param conditionItem - A single condition or a nested `{ __orConditions }` group
+     * @returns Whether the item passed and the detailed evaluation results
      */
     evaluateAndConditionItem(conditionItem) {
         // Check if this is a nested OR group
@@ -367,11 +361,11 @@ class Decorator extends BaseClass {
         return { passed: result.passed, results: [result] };
     }
     /**
-     * Evaluates OR conditions (at least one condition must match).
-     * Supports both single conditions and nested AND groups.
+     * Evaluates OR conditions — passes when at least one item (single condition or nested AND group) matches.
+     * Short-circuits on the first passing item.
      *
-     * @param orConditions - Array of condition items (single conditions or AND groups)
-     * @returns Object containing whether any condition passed and evaluation details
+     * @param orConditions - Array of conditions or nested AND groups to evaluate
+     * @returns Whether any condition passed and the collected evaluation results
      */
     evaluateOrConditions(orConditions) {
         const allResults = [];
@@ -408,11 +402,11 @@ class Decorator extends BaseClass {
         return { passed: false, results: allResults };
     }
     /**
-     * Evaluates AND conditions (all conditions must match).
-     * Supports both single conditions and nested OR groups.
+     * Evaluates AND conditions — passes only when every item (single condition or nested OR group) matches.
+     * Continues even after a failure to collect all results for diagnostic context.
      *
-     * @param andConditions - Array of condition items (single conditions or OR groups)
-     * @returns Object containing whether all conditions passed and evaluation details
+     * @param andConditions - Array of conditions or nested OR groups that must all pass
+     * @returns Whether all conditions passed and the collected evaluation results
      */
     evaluateAndConditions(andConditions) {
         const allResults = [];
@@ -428,10 +422,11 @@ class Decorator extends BaseClass {
         return { passed: allPassed, results: allResults };
     }
     /**
-     * Evaluates condition metadata and returns whether the condition is met and the context.
+     * Entry point for condition evaluation. Dispatches to OR, AND, or single evaluation
+     * depending on the shape of the condition metadata.
      *
-     * @param conditionInfo - The condition metadata
-     * @returns Object with passed (boolean) and context (string)
+     * @param conditionInfo - The decorator condition metadata (single, AND, or OR)
+     * @returns Whether the condition passed and a diagnostic context string
      */
     evaluateCondition(conditionInfo) {
         let passed = false;
@@ -458,12 +453,12 @@ class Decorator extends BaseClass {
         return { passed, context };
     }
     /**
-     * Iterates over schema properties and yields property info for decorator processing.
-     * Centralizes the guard clause and property iteration logic.
+     * Yields each property from a schema definition for decorator processing.
+     * Returns early if the definition has no properties or the target is falsy.
      *
-     * @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
+     * @param schemaDefinition - The schema definition whose properties to iterate
+     * @param target - Guard object — iteration is skipped if falsy
+     * @yields Property name and its definition for each property in the schema
      */
     *iterateProperties(schemaDefinition, target) {
         if (!schemaDefinition?.properties || !target) {
@@ -475,42 +470,45 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * 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.
+     * Hides properties whose `@hide` conditions pass.
+     * Multiple `@hide` decorators use OR semantics — any passing condition hides the property.
+     * Skipped when the `@message` decorator already added messages to the property.
      *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
+     * @param schemaDefinition - The schema definition to process
+     * @param decoratedClass - The decorated class instance carrying `@hide` metadata
      */
-    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)
+    applyHideDecorator(schemaDefinition, decoratedClass) {
+        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, decoratedClass)) {
+            const hideConditions = Reflect.getMetadata(decoration_1.metadataKeys.hide, decoratedClass, propertyName);
+            if (hideConditions) {
+                // Hide when ANY condition IS met (OR semantics across multiple @hide decorators)
                 // 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;
+                for (const condition of hideConditions) {
+                    const { passed } = this.evaluateCondition(condition);
+                    if (passed && !hasMessages) {
+                        property[ux_specification_types_1.SchemaTag.hidden] = true;
+                        break;
+                    }
                 }
             }
         }
     }
     /**
-     * Applies the message decorator to the schema definition.
-     * Shows messages when their condition evaluates to true.
+     * Shows messages on properties whose `@message` conditions pass.
+     * Must run before `applyHideDecorator` so hide can detect existing messages.
      *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
+     * @param schemaDefinition - The schema definition to process
+     * @param decoratedClass - The decorated class instance carrying `@message` metadata
      */
-    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, {
+    applyMessageDecorator(schemaDefinition, decoratedClass) {
+        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, decoratedClass)) {
+            const messageConditions = Reflect.getMetadata(decoration_1.metadataKeys.message, decoratedClass, propertyName);
+            if (messageConditions) {
+                for (const condition of messageConditions) {
+                    const { passed, context } = this.evaluateCondition(condition);
+                    if (passed && (condition.message || condition.messageConfig)) {
+                        this.addConditionalMessage(condition, decoratedClass, property, {
                             propertyName,
                             context
                         });
@@ -520,45 +518,48 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * Applies the readonly decorator to the schema definition.
-     * Marks properties as readonly when their condition evaluates to true.
+     * Marks properties as read-only whose `@readonly` conditions pass.
+     * Multiple `@readonly` decorators use OR semantics — any passing condition makes the property read-only.
      *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param syncRuleProviderInstance - The sync rule provider instance
+     * @param schemaDefinition - The schema definition to process
+     * @param decoratedClass - The decorated class instance carrying `@readonly` metadata
      */
-    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;
+    applyReadonlyDecorator(schemaDefinition, decoratedClass) {
+        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, decoratedClass)) {
+            const readonlyConditions = Reflect.getMetadata(decoration_1.metadataKeys.readonly, decoratedClass, propertyName);
+            if (readonlyConditions) {
+                // Readonly when ANY condition IS met (OR semantics across multiple @readonly decorators)
+                for (const condition of readonlyConditions) {
+                    const { passed } = this.evaluateCondition(condition);
+                    if (passed) {
+                        property.readOnly = true;
+                        break;
+                    }
                 }
             }
         }
     }
     /**
-     * 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.
+     * Restricts enum values on properties whose `@enums` conditions pass.
+     * When 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
+     * @param schemaDefinition - The schema definition to process
+     * @param decoratedClass - The decorated class instance carrying `@enums` metadata
      */
-    applyEnumsDecorator(schemaDefinition, syncRuleProviderInstance) {
-        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, syncRuleProviderInstance)) {
-            const enumsMetadataList = (0, decoration_1.getEnumsMetadata)(syncRuleProviderInstance, propertyName);
-            if (!enumsMetadataList?.length) {
+    applyEnumsDecorator(schemaDefinition, decoratedClass) {
+        for (const { propertyName, property } of this.iterateProperties(schemaDefinition, decoratedClass)) {
+            const enumsConditions = Reflect.getMetadata(decoration_1.metadataKeys.enums, decoratedClass, propertyName);
+            if (!enumsConditions?.length) {
                 continue;
             }
             // Find first matching condition (first match wins)
-            for (const enumsMetadata of enumsMetadataList) {
-                const { passed } = this.evaluateCondition(enumsMetadata);
+            for (const condition of enumsConditions) {
+                const { passed } = this.evaluateCondition(condition);
                 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));
+                        const filteredValues = condition.allowedValues.filter((v) => currentEnumValues.includes(v));
                         this.applyFilteredEnumToProperty(property, filteredValues);
                     }
                     break; // First match wins, stop processing
@@ -567,11 +568,11 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * Gets the validity metadata for a property.
+     * Reads the `@validity` metadata stored on a property of the decorated class.
      *
-     * @param target - The target object
-     * @param propertyName - The property name
-     * @returns The validity metadata or undefined
+     * @param target - The decorated class instance
+     * @param propertyName - The property to read validity metadata from
+     * @returns The validity constraints (since, enum restrictions), or undefined if none
      */
     getValidityMetadata(target, propertyName) {
         let validityInfo;
@@ -581,11 +582,10 @@ class Decorator extends BaseClass {
         return validityInfo;
     }
     /**
-     * Resolves an enum array from a property definition.
-     * Handles both inline enums and $ref to enum definitions.
+     * Returns the enum values from a property definition, resolving `$ref` to a shared enum definition if needed.
      *
-     * @param property - The property definition
-     * @returns The enum array or undefined if not found
+     * @param property - The schema property definition (may have inline `enum` or a `$ref`)
+     * @returns The enum values array, or undefined if the property is not an enum
      */
     resolveEnumFromProperty(property) {
         // Check for inline enum
@@ -604,12 +604,11 @@ class Decorator extends BaseClass {
         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.
+     * Writes filtered enum values to a property definition.
+     * For `$ref` properties, inlines the enum, copies the type, and removes the `$ref`.
      *
-     * @param property - The property definition to update
-     * @param filteredEnum - The filtered enum values
+     * @param property - The schema property definition to update
+     * @param filteredEnum - The allowed enum values after filtering
      */
     applyFilteredEnumToProperty(property, filteredEnum) {
         if (property.$ref) {
@@ -631,19 +630,19 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * Applies the validity decorator to the schema definition based on the sync rule provider instance and minimum UI5 version.
+     * Hides properties and filters enum values that require a UI5 version higher than the app's minimum.
      *
-     * @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
+     * @param schemaDefinition - The schema definition to process
+     * @param decoratedClass - The decorated class instance carrying `@validity` metadata
+     * @param minUI5Version - The app's minimum UI5 version to check against
      */
-    applyValidityDecorator(schemaDefinition, syncRuleProviderInstance, minUI5Version) {
-        if (!schemaDefinition?.properties || !syncRuleProviderInstance || !minUI5Version) {
+    applyValidityDecorator(schemaDefinition, decoratedClass, minUI5Version) {
+        if (!schemaDefinition?.properties || !decoratedClass || !minUI5Version) {
             return;
         }
         for (const propertyName in schemaDefinition.properties) {
             const property = schemaDefinition.properties[propertyName];
-            const validityInfo = this.getValidityMetadata(syncRuleProviderInstance, propertyName);
+            const validityInfo = this.getValidityMetadata(decoratedClass, 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;
@@ -664,7 +663,7 @@ class Decorator extends BaseClass {
                         if (condition.since && minUI5Version) {
                             if (!(0, utils_1.compareUI5Versions)(minUI5Version, condition.since)) {
                                 if (condition.message) {
-                                    this.addConditionalMessage(condition, syncRuleProviderInstance, property, {
+                                    this.addConditionalMessage(condition, decoratedClass, property, {
                                         propertyName: enumValueStr
                                     });
                                 }
@@ -673,9 +672,9 @@ class Decorator extends BaseClass {
                         }
                         // Check property dependency using dependsOn function
                         if (condition.dependsOn) {
-                            if (!condition.dependsOn(syncRuleProviderInstance)) {
+                            if (!condition.dependsOn(decoratedClass)) {
                                 if (condition.message) {
-                                    this.addConditionalMessage(condition, syncRuleProviderInstance, property, {
+                                    this.addConditionalMessage(condition, decoratedClass, property, {
                                         propertyName: enumValueStr
                                     });
                                 }
@@ -693,11 +692,11 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * Applies the isViewNode decorator to the schema definition based on the target and property name.
+     * Marks the schema definition as a view node if the `@isViewNode` decorator is present on the target.
      *
-     * @param schemaDefinition The schema definition to apply the isViewNode decorator to
-     * @param target The target object or function
-     * @param propertyName The property name (optional)
+     * @param schemaDefinition - The schema definition to tag
+     * @param target - The class constructor or prototype carrying the decorator
+     * @param propertyName - Optional property name for property-level decorators
      */
     applyIsViewNodeDecorator(schemaDefinition, target, propertyName) {
         const isViewNode = Reflect.getMetadata(decoration_1.metadataKeys.isViewNode, target, propertyName);
@@ -707,11 +706,11 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * Applies the description decorator to the schema definition.
+     * Sets the schema `description` field from the `@description` decorator if present on the target.
      *
-     * @param schemaDefinition - The schema definition to apply the decorator to
-     * @param target - The target object or function
-     * @param propertyName - The property name (optional)
+     * @param schemaDefinition - The schema definition to update
+     * @param target - The class constructor or prototype carrying the decorator
+     * @param propertyName - Optional property name for property-level decorators
      */
     applyDescriptionDecorator(schemaDefinition, target, propertyName) {
         const description = Reflect.getMetadata(decoration_1.metadataKeys.description, target, propertyName);
@@ -720,12 +719,14 @@ class Decorator extends BaseClass {
         }
     }
     /**
-     * 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
+     * Applies all decorators to the schema in the correct order:
+     * description → isViewNode → validity → enums → message → hide → readonly.
+     * Message runs before hide so that hide can skip properties that already have messages.
+     *
+     * @param minUi5Version - The app's minimum UI5 version for validity checks
+     * @param propertyName - Optional property name when decorating a single property
+     * @param customDefinition - Override the schema definition (defaults to `getBase()`)
+     * @returns The decorated schema definition
      */
     applyDecorators(minUi5Version, propertyName, customDefinition) {
         const definition = customDefinition ?? this.getBase();