@sap/ux-specification 1.96.105 → 1.96.107

package/dist/specification/test/unit/decorators/validity-test-utils.js

@@ -12,23 +12,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMOJI_MATCH = exports.EMOJI_DIFF = exports.getPropertiesWithValidity = exports.VERSION_LATEST = exports.SchemaResults = exports.EMOJI_NOT_FOUND = exports.EMOJI_HIDDEN = exports.EMOJI_VISIBLE = void 0;
-exports.resolveDefinition = resolveDefinition;
+exports.getPropertiesWithValidity = exports.SchemaResults = exports.INDENT = exports.VERSION_LATEST = exports.EMOJI_DIFF = exports.EMOJI_MATCH = exports.EMOJI_NOT_FOUND = exports.EMOJI_HIDDEN = exports.EMOJI_VISIBLE = void 0;
 exports.findTableDefinition = findTableDefinition;
 exports.findDefinitionByName = findDefinitionByName;
-exports.getSchemaPropertyNames = getSchemaPropertyNames;
-exports.propertyExists = propertyExists;
-exports.isPropertyHidden = isPropertyHidden;
-exports.compareVersions = compareVersions;
-exports.getValidityPropertiesFromClass = getValidityPropertiesFromClass;
+exports.getEnumValidityFromClass = getEnumValidityFromClass;
 exports.generateExpectedVisibilityTable = generateExpectedVisibilityTable;
 exports.generateActualVisibilityTable = generateActualVisibilityTable;
+exports.generateDiffVisibilityTable = generateDiffVisibilityTable;
 exports.formatVisibilityTableMarkdown = formatVisibilityTableMarkdown;
-exports.generateSchemaWithVersion = generateSchemaWithVersion;
+exports.formatDiffTableMarkdown = formatDiffTableMarkdown;
+exports.formatEnumValidityTableMarkdown = formatEnumValidityTableMarkdown;
 exports.generateSchemasForVersions = generateSchemasForVersions;
 exports.getValidityProperties = getValidityProperties;
-exports.generateDiffVisibilityTable = generateDiffVisibilityTable;
-exports.formatDiffTableMarkdown = formatDiffTableMarkdown;
+exports.compareExpectedVsActual = compareExpectedVsActual;
+exports.compareExpectedVsActualEnum = compareExpectedVsActualEnum;
 const ux_specification_types_1 = require("@sap/ux-specification-types");
 const api_1 = require("../../../src/api");
 const path_1 = require("path");
@@ -44,30 +41,19 @@ exports.EMOJI_VISIBLE = '✅';
 exports.EMOJI_HIDDEN = '🚫';
 /** Emoji indicator for property not found in schema */
 exports.EMOJI_NOT_FOUND = '❓';
-// ============================================================================
-// Types
-// ============================================================================
-/**
- * Enum to specify which type of visibility table to generate
- */
-var SchemaResults;
-(function (SchemaResults) {
-    /** Generate expected visibility based on @validity decorator metadata */
-    SchemaResults["Expected"] = "expected";
-    /** Generate actual visibility from generated schemas */
-    SchemaResults["Actual"] = "actual";
-})(SchemaResults || (exports.SchemaResults = SchemaResults = {}));
+/** Emoji indicator for a match between expected and actual */
+exports.EMOJI_MATCH = '✅';
+/** Emoji indicator for a mismatch between expected and actual */
+exports.EMOJI_DIFF = '⚠️';
+/** Special version string representing the latest/newest version */
+exports.VERSION_LATEST = 'latest';
+/** Indentation for snapshot content (16 spaces to align within toMatchInlineSnapshot) */
+exports.INDENT = '                ';
 // ============================================================================
 // Helper Functions - Schema Operations
 // ============================================================================
 /**
  * Resolves a definition by following $ref chains in the schema
- *
- * @param schema - The JSON schema containing definitions
- * @param definitionName - The name of the definition to resolve
- * @returns The resolved definition, or undefined if not found
- * @example
- * const tableDef = resolveDefinition(schema, 'Table');
  */
 function resolveDefinition(schema, definitionName) {
     let def = schema.definitions?.[definitionName];
@@ -87,12 +73,6 @@ function resolveDefinition(schema, definitionName) {
 }
 /**
  * Finds the definition containing table properties by searching common patterns
- *
- * Searches for definitions with names like 'TableSPV', 'LRTableView', 'Table',
- * or any definition containing key table properties like 'condensedTableLayout'.
- *
- * @param schema - The JSON schema to search
- * @returns The table definition, or undefined if not found
  */
 function findTableDefinition(schema) {
     const definitions = schema.definitions || {};
@@ -119,12 +99,6 @@ function findTableDefinition(schema) {
 }
 /**
  * Creates a definition finder function for a specific definition name
- *
- * @param definitionName - The name of the definition to find
- * @returns A function that finds the definition in a given schema
- * @example
- * const finder = findDefinitionByName('CustomHeaderAction');
- * const def = finder(schema);
  */
 function findDefinitionByName(definitionName) {
     return (schema) => {
@@ -134,59 +108,16 @@ function findDefinitionByName(definitionName) {
 }
 /**
  * Gets all property names from a schema definition
- *
- * @param schema - The JSON schema containing definitions
- * @param definitionName - The name of the definition to get properties from
- * @returns Array of property names, or empty array if definition not found
  */
 function getSchemaPropertyNames(schema, definitionName) {
     const def = resolveDefinition(schema, definitionName);
     return def?.properties ? Object.keys(def.properties) : [];
 }
-/**
- * Checks if a property exists in a schema definition
- *
- * @param schema - The JSON schema containing definitions
- * @param definitionName - The name of the definition to check
- * @param propertyName - The name of the property to check for
- * @returns True if the property exists, false otherwise
- */
-function propertyExists(schema, definitionName, propertyName) {
-    const def = resolveDefinition(schema, definitionName);
-    return def?.properties?.[propertyName] !== undefined;
-}
-/**
- * Checks if a property is marked as hidden in a schema definition
- *
- * @param schema - The JSON schema containing definitions
- * @param definitionName - The name of the definition to check
- * @param propertyName - The name of the property to check
- * @returns True if hidden, false if visible, undefined if property not found
- */
-function isPropertyHidden(schema, definitionName, propertyName) {
-    const def = resolveDefinition(schema, definitionName);
-    return def?.properties?.[propertyName]?.[ux_specification_types_1.SchemaTag.hidden];
-}
 // ============================================================================
 // Helper Functions - Version Comparison
 // ============================================================================
-/** Special version string representing the latest/newest version */
-exports.VERSION_LATEST = 'latest';
 /**
  * Compares two semantic version strings
- *
- * Handles the special 'latest' version which is always considered
- * greater than any other version.
- *
- * @param a - First version string (e.g., '1.84.0' or 'latest')
- * @param b - Second version string (e.g., '1.96.0' or 'latest')
- * @returns Negative if a < b, positive if a > b, zero if equal
- * @example
- * compareVersions('1.84.0', '1.96.0') // returns negative
- * compareVersions('1.96.0', '1.84.0') // returns positive
- * compareVersions('1.84.0', '1.84.0') // returns 0
- * compareVersions('1.142.0', 'latest') // returns negative
- * compareVersions('latest', '1.84.0') // returns positive
  */
 function compareVersions(a, b) {
     // Handle 'latest' as a special case - it's always the highest version
@@ -213,20 +144,8 @@ function compareVersions(a, b) {
 // ============================================================================
 /**
  * Extracts all properties from a class, including those with @validity decorator
- *
- * Walks the prototype chain to find all properties, then checks each
- * for validity metadata. Properties without @validity are marked with since: '-'.
- * Results are sorted by version (ascending), then alphabetically by property name.
- *
- * @param ClassConstructor - The class constructor to inspect
- * @param schemaPropertyNames - Optional list of additional property names to check
- * @param onlyWithValidity - If true, only return properties with @validity decorator (default: false)
- * @returns Array of ValidityInfo objects sorted by version then name
- * @example
- * const validityProps = getValidityPropertiesFromClass(TableSettings, ['type', 'selectAll']);
- * // Returns: [{ property: 'enableOnSelect', since: '-' }, { property: 'type', since: '1.84.0' }, ...]
  */
-function getValidityPropertiesFromClass(ClassConstructor, schemaPropertyNames = [], onlyWithValidity = false) {
+function getValidityPropertiesFromClass(ClassConstructor, schemaPropertyNames = []) {
     const prototype = ClassConstructor.prototype;
     const result = [];
     const candidateProperties = new Set();
@@ -243,18 +162,21 @@ function getValidityPropertiesFromClass(ClassConstructor, schemaPropertyNames =
     // Add schema property names as candidates
     schemaPropertyNames.forEach((p) => candidateProperties.add(p));
     for (const property of candidateProperties) {
-        const validity = (0, decorators_1.getValidityMetadata)(prototype, property);
+        const validity = Reflect.getMetadata(decorators_1.metadataKeys.validity, prototype, property);
         if (validity?.since) {
             result.push({ property, since: validity.since });
         }
-        else if (!onlyWithValidity && schemaPropertyNames.includes(property)) {
+        else if (validity?.enum) {
+            // Property has enum validity but no property-level since
+            result.push({ property, since: '-' });
+        }
+        else if (schemaPropertyNames.includes(property)) {
             // Include properties without @validity if they exist in schema
             result.push({ property, since: '-' });
         }
     }
     // Sort: properties without version ('-') first, then by version, then alphabetically
     return result.sort((a, b) => {
-        // '-' (no version) comes first
         if (a.since === '-' && b.since !== '-') {
             return -1;
         }
@@ -271,19 +193,91 @@ function getValidityPropertiesFromClass(ClassConstructor, schemaPropertyNames =
         return a.property.localeCompare(b.property);
     });
 }
+/**
+ * Gets all property names that have validity metadata on a class prototype
+ */
+function getPropertiesWithValidityMetadata(prototype) {
+    const properties = [];
+    if (typeof Reflect !== 'undefined' && Reflect.getMetadataKeys) {
+        const knownProperties = new Set();
+        // Walk the prototype chain
+        let current = prototype;
+        while (current && current !== Object.prototype) {
+            const propNames = Object.getOwnPropertyNames(current);
+            propNames.forEach((p) => knownProperties.add(p));
+            current = Object.getPrototypeOf(current);
+        }
+        // Common property names that might have enum validity
+        const testProperties = [
+            'type',
+            'personalization',
+            'selectionMode',
+            'selectAll',
+            'selectionLimit',
+            'enableExport',
+            'quickVariantSelection',
+            'condensedTableLayout',
+            'hierarchyQualifier',
+            'widthIncludingColumnHeader',
+            'disableCopyToClipboard',
+            'initialLoad',
+            'enableMassEdit',
+            'creationMode',
+            'analyticalConfiguration',
+            'popinLayout',
+            'rowCountMode',
+            ...Array.from(knownProperties)
+        ];
+        for (const property of testProperties) {
+            if (!properties.includes(property)) {
+                const validity = Reflect.getMetadata(decorators_1.metadataKeys.validity, prototype, property);
+                if (validity?.enum) {
+                    properties.push(property);
+                }
+            }
+        }
+    }
+    return properties;
+}
+/**
+ * Extracts enum value validity information from a class's properties
+ */
+function getEnumValidityFromClass(ClassConstructor) {
+    const prototype = ClassConstructor.prototype;
+    const result = [];
+    const propertiesWithValidity = getPropertiesWithValidityMetadata(prototype);
+    for (const property of propertiesWithValidity) {
+        const validity = Reflect.getMetadata(decorators_1.metadataKeys.validity, prototype, property);
+        if (validity?.enum) {
+            for (const [enumValue, config] of Object.entries(validity.enum)) {
+                if (config.since) {
+                    result.push({
+                        property,
+                        enumValue,
+                        since: config.since
+                    });
+                }
+            }
+        }
+    }
+    // Sort by property, then by since version, then by enum value
+    return result.sort((a, b) => {
+        const propCompare = a.property.localeCompare(b.property);
+        if (propCompare !== 0) {
+            return propCompare;
+        }
+        const versionCompare = compareVersions(a.since, b.since);
+        if (versionCompare !== 0) {
+            return versionCompare;
+        }
+        return a.enumValue.localeCompare(b.enumValue);
+    });
+}
 // ============================================================================
-// Helper Functions - Table Formatting
+// Helper Functions - Table Generation
 // ============================================================================
 /**
  * Generates expected visibility table based on @validity decorator metadata
- *
- * For each property, determines if it should be visible in each version
- * based on comparing the version against the property's 'since' value.
- * Properties with since: '-' (no @validity) are always visible.
- *
- * @param validityInfos - Array of properties with their validity info
- * @param versions - Array of version strings to generate columns for
- * @returns Array of rows with visibility status for each version
  */
 function generateExpectedVisibilityTable(validityInfos, versions) {
     return validityInfos.map((info) => {
@@ -300,21 +294,6 @@ function generateExpectedVisibilityTable(validityInfos, versions) {
 }
 /**
  * Generates actual visibility table from generated schemas
- *
- * For each property and version, checks the actual generated schema
- * to determine if the property is visible (not hidden).
- *
- * @param validityInfos - Array of properties with their validity info
- * @param versions - Array of version strings to check
- * @param schemaResults - Map of version strings to generated schemas
- * @param findDefinition - Function to locate the definition within each schema
- * @returns Array of rows with actual visibility status for each version
- * @remarks
- * Status symbols:
- * - ✅ = property exists and is visible
- * - 🚫 = property exists but is hidden
- * - ? = schema or definition not found
- * - - = property not found in definition
  */
 function generateActualVisibilityTable(validityInfos, versions, schemaResults, findDefinition) {
     return validityInfos.map((info) => {
@@ -344,52 +323,137 @@ function generateActualVisibilityTable(validityInfos, versions, schemaResults, f
         return row;
     });
 }
+/**
+ * Generates expected enum visibility table based on @validity decorator enum metadata
+ */
+function generateExpectedEnumVisibilityTable(enumInfos, versions) {
+    return enumInfos.map((info) => {
+        const row = {
+            property: `${info.property}.${info.enumValue}`,
+            since: info.since
+        };
+        for (const version of versions) {
+            const shouldBeVisible = compareVersions(version, info.since) >= 0;
+            row[version] = shouldBeVisible ? exports.EMOJI_VISIBLE : exports.EMOJI_HIDDEN;
+        }
+        return row;
+    });
+}
+/**
+ * Resolves enum values from a property definition.
+ */
+function resolveEnumValues(propDef, schema) {
+    // Check for inline enum
+    if (propDef.enum && Array.isArray(propDef.enum)) {
+        return propDef.enum;
+    }
+    // Check for anyOf with enums
+    if (propDef.anyOf) {
+        const values = propDef.anyOf.flatMap((x) => x.enum || []);
+        if (values.length > 0) {
+            return values;
+        }
+    }
+    // Check for $ref to an enum definition
+    if (propDef.$ref) {
+        const refName = propDef.$ref.replace('#/definitions/', '');
+        const refDef = schema.definitions?.[refName];
+        if (refDef?.enum && Array.isArray(refDef.enum)) {
+            return refDef.enum;
+        }
+    }
+    return undefined;
+}
+/**
+ * Generates actual enum visibility table from generated schemas
+ */
+function generateActualEnumVisibilityTable(enumInfos, versions, schemaResults, findDefinition) {
+    return enumInfos.map((info) => {
+        const row = {
+            property: `${info.property}.${info.enumValue}`,
+            since: info.since
+        };
+        for (const version of versions) {
+            const schema = schemaResults.get(version);
+            if (!schema) {
+                row[version] = '?';
+                continue;
+            }
+            const def = findDefinition(schema);
+            if (!def?.properties) {
+                row[version] = '?';
+                continue;
+            }
+            const propDef = def.properties[info.property];
+            if (!propDef) {
+                row[version] = exports.EMOJI_NOT_FOUND;
+                continue;
+            }
+            const enumValues = resolveEnumValues(propDef, schema);
+            if (!enumValues) {
+                row[version] = exports.EMOJI_NOT_FOUND;
+                continue;
+            }
+            const enumExists = enumValues.includes(info.enumValue);
+            row[version] = enumExists ? exports.EMOJI_VISIBLE : exports.EMOJI_HIDDEN;
+        }
+        return row;
+    });
+}
+/**
+ * Generates a diff visibility table comparing expected vs actual
+ */
+function generateDiffVisibilityTable(validityInfos, versions, schemaResults, findDefinition) {
+    const expectedTable = generateExpectedVisibilityTable(validityInfos, versions);
+    const actualTable = generateActualVisibilityTable(validityInfos, versions, schemaResults, findDefinition);
+    return validityInfos.map((info, index) => {
+        const row = {
+            property: info.property,
+            since: info.since
+        };
+        for (const version of versions) {
+            const expected = expectedTable[index][version];
+            const actual = actualTable[index][version];
+            // Match if both are the same, or if actual is not found (❓) we consider it a mismatch
+            const isMatch = expected === actual;
+            row[version] = isMatch ? exports.EMOJI_MATCH : exports.EMOJI_DIFF;
+        }
+        return row;
+    });
+}
+// ============================================================================
+// Helper Functions - Table Formatting
+// ============================================================================
 /**
  * Formats visibility table as a markdown string for snapshot testing
- *
- * Generates a properly aligned markdown table with:
- * - Header row with Property, Since, and version columns
- * - Separator row
- * - Data rows with centered emoji indicators
- * - Legend explaining the emoji meanings
- *
- * @param rows - Array of visibility rows to format
- * @param versions - Array of version strings for column headers
- * @returns Formatted markdown table string
- * @example
- * ```
- * | Property | Since  | 1.84.0 | 1.96.0 |
- * | -------- | ------ | ------ | ------ |
- * | type     | 1.84.0 |   ✅   |   ✅   |
- *
- * Legend: ✅ = visible, 🚫 = hidden
- * ```
  */
 function formatVisibilityTableMarkdown(rows, versions) {
     const lines = [];
     // Calculate column widths
     const propWidth = Math.max(26, ...rows.map((r) => r.property.length));
     const sinceWidth = 7;
-    const versionWidth = 9;
+    const versionCellWidth = 9;
     // Helper functions for padding
     const padEnd = (str, width) => str.padEnd(width);
-    const padCenter = (str, width) => {
+    const padCenterVersion = (str, width) => {
         const padding = width - str.length;
         const left = Math.floor(padding / 2);
         return ' '.repeat(left) + str + ' '.repeat(padding - left);
     };
-    // Emoji centering - emojis are 1 char but display as 2 wide
-    // Use fixed padding for consistent appearance: "   X    " (3 spaces + emoji + 4 spaces = 9 width visually)
     const padCenterEmoji = (emoji) => `   ${emoji}    `;
     // Header
     const headerCells = [
         padEnd('Property', propWidth),
         padEnd('Since', sinceWidth),
-        ...versions.map((v) => padCenter(v, versionWidth))
+        ...versions.map((v) => padCenterVersion(v, versionCellWidth))
     ];
     lines.push(`| ${headerCells.join(' | ')} |`);
     // Separator
-    const sepCells = ['-'.repeat(propWidth), '-'.repeat(sinceWidth), ...versions.map(() => '-'.repeat(versionWidth))];
+    const sepCells = [
+        '-'.repeat(propWidth),
+        '-'.repeat(sinceWidth),
+        ...versions.map(() => '-'.repeat(versionCellWidth))
+    ];
     lines.push(`| ${sepCells.join(' | ')} |`);
     // Data rows
     for (const row of rows) {
@@ -405,20 +469,132 @@ function formatVisibilityTableMarkdown(rows, versions) {
     lines.push(`Legend: ${exports.EMOJI_VISIBLE} = visible (version >= since), ${exports.EMOJI_HIDDEN} = hidden (version < since), ${exports.EMOJI_NOT_FOUND} = not found in schema`);
     return lines.join('\n');
 }
+/**
+ * Formats diff table as a markdown string for report generation
+ */
+function formatDiffTableMarkdown(rows, versions) {
+    const lines = [];
+    // Calculate column widths
+    const propWidth = Math.max(26, ...rows.map((r) => r.property.length));
+    const sinceWidth = 7;
+    const versionCellWidth = 9;
+    // Helper functions for padding
+    const padEnd = (str, width) => str.padEnd(width);
+    const padCenterVersion = (str, width) => {
+        const padding = width - str.length;
+        const left = Math.floor(padding / 2);
+        return ' '.repeat(left) + str + ' '.repeat(padding - left);
+    };
+    const padCenterEmoji = (emoji) => `   ${emoji}    `;
+    // Header
+    const headerCells = [
+        padEnd('Property', propWidth),
+        padEnd('Since', sinceWidth),
+        ...versions.map((v) => padCenterVersion(v, versionCellWidth))
+    ];
+    lines.push(`| ${headerCells.join(' | ')} |`);
+    // Separator
+    const sepCells = [
+        '-'.repeat(propWidth),
+        '-'.repeat(sinceWidth),
+        ...versions.map(() => '-'.repeat(versionCellWidth))
+    ];
+    lines.push(`| ${sepCells.join(' | ')} |`);
+    // Data rows
+    for (const row of rows) {
+        const cells = [
+            padEnd(row.property, propWidth),
+            padEnd(row.since, sinceWidth),
+            ...versions.map((v) => padCenterEmoji(row[v]))
+        ];
+        lines.push(`| ${cells.join(' | ')} |`);
+    }
+    // Legend
+    lines.push('');
+    lines.push(`Legend: ${exports.EMOJI_MATCH} = match, ${exports.EMOJI_DIFF} = mismatch`);
+    return lines.join('\n');
+}
+/**
+ * Formats enum validity information as a markdown table for report generation
+ */
+function formatEnumValidityTableMarkdown(enumInfos, versions) {
+    if (enumInfos.length === 0) {
+        return 'No enum values with version requirements found.';
+    }
+    const lines = [];
+    // Calculate column widths
+    const propWidth = Math.max(30, ...enumInfos.map((e) => `${e.property}.${e.enumValue}`.length));
+    const sinceWidth = 7;
+    const versionCellWidth = 10;
+    // Helper functions for padding
+    const padEnd = (str, width) => str.padEnd(width);
+    const padCenterVersion = (str, width) => {
+        const padding = width - str.length;
+        const left = Math.floor(padding / 2);
+        return ' '.repeat(left) + str + ' '.repeat(padding - left);
+    };
+    const padCenterEmoji = (emoji) => `   ${emoji}     `;
+    // Header
+    const headerCells = [
+        padEnd('Property.EnumValue', propWidth),
+        padEnd('Since', sinceWidth),
+        ...versions.map((v) => padCenterVersion(v, versionCellWidth))
+    ];
+    lines.push(`| ${headerCells.join(' | ')} |`);
+    // Separator
+    const sepCells = [
+        '-'.repeat(propWidth),
+        '-'.repeat(sinceWidth),
+        ...versions.map(() => '-'.repeat(versionCellWidth))
+    ];
+    lines.push(`| ${sepCells.join(' | ')} |`);
+    // Data rows - generate expected visibility based on since version
+    for (const info of enumInfos) {
+        const rowCells = [
+            padEnd(`${info.property}.${info.enumValue}`, propWidth),
+            padEnd(info.since, sinceWidth),
+            ...versions.map((v) => {
+                const shouldBeVisible = compareVersionsExported(v, info.since) >= 0;
+                return padCenterEmoji(shouldBeVisible ? exports.EMOJI_VISIBLE : exports.EMOJI_HIDDEN);
+            })
+        ];
+        lines.push(`| ${rowCells.join(' | ')} |`);
+    }
+    // Legend
+    lines.push('');
+    lines.push(`Legend: ${exports.EMOJI_VISIBLE} = enum value available, ${exports.EMOJI_HIDDEN} = enum value not available`);
+    return lines.join('\n');
+}
+/**
+ * Exported version comparison function for use in formatting functions
+ */
+function compareVersionsExported(a, b) {
+    // Handle 'latest' as a special case - it's always the highest version
+    if (a === exports.VERSION_LATEST && b === exports.VERSION_LATEST) {
+        return 0;
+    }
+    if (a === exports.VERSION_LATEST) {
+        return 1;
+    }
+    if (b === exports.VERSION_LATEST) {
+        return -1;
+    }
+    const aParts = a.split('.').map(Number);
+    const bParts = b.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((aParts[i] || 0) !== (bParts[i] || 0)) {
+            return (aParts[i] || 0) - (bParts[i] || 0);
+        }
+    }
+    return 0;
+}
 // ============================================================================
 // Helper Functions - Schema Generation
 // ============================================================================
 /**
  * Generates an app schema with a specific minUI5Version
- *
- * Creates a schema for the v4new test project with the specified
- * UI5 version, using the provided generic schema as base.
- *
- * @param genericSchema - The generic schema to use as base
- * @param minUI5Version - The minimum UI5 version to set (e.g., '1.84.0')
- * @returns The generated app schema
  */
-async function generateSchemaWithVersion(genericSchema, minUI5Version) {
+async function generateSchemaWithVersion(genericSchema, schemaType, minUI5Version) {
     const manifestTemp = JSON.parse(JSON.stringify(manifest_json_1.default));
     manifestTemp['sap.ui5'].dependencies.minUI5Version = minUI5Version;
     const projectRoot = (0, path_1.join)('test', 'test-projects', 'v4new');
@@ -426,158 +602,80 @@ async function generateSchemaWithVersion(genericSchema, minUI5Version) {
         (0, utils_1.prepareFileData)((0, path_1.join)(projectRoot, 'webapp', 'localService', 'metadata.xml')),
         (0, utils_1.prepareFileData)((0, path_1.join)(projectRoot, 'webapp', 'annotations', 'annotation.xml'))
     ];
+    const schemaParams = {
+        genericSchema,
+        contextPath: '/Products',
+        annotations: allAnnotationData,
+        manifest: manifestTemp
+    };
+    // Use type assertion to handle dynamic schema type
+    // The function only supports ListReport, ObjectPage, and AnalyticalListPage for v4
+    const v4Params = { [schemaType]: schemaParams };
     return (0, api_1.generateSchema)({
-        [ux_specification_types_1.FioriElementsVersion.v4]: {
-            [ux_specification_types_1.SchemaType.ListReport]: {
-                genericSchema,
-                contextPath: '/Products',
-                annotations: allAnnotationData,
-                manifest: manifestTemp
-            }
-        }
+        [ux_specification_types_1.FioriElementsVersion.v4]: v4Params
     });
 }
 /**
  * Generates schemas for multiple UI5 versions
- *
- * @param genericSchema - The generic schema to use as base for all versions
- * @param versions - Array of version strings to generate schemas for
- * @returns Map of version string to generated schema
- * @example
- * const schemas = await generateSchemasForVersions(genericSchema, ['1.84.0', '1.96.0']);
- * const schema84 = schemas.get('1.84.0');
  */
-async function generateSchemasForVersions(genericSchema, versions) {
+async function generateSchemasForVersions(genericSchema, schemaType, versions) {
     const results = new Map();
     for (const version of versions) {
-        const schema = await generateSchemaWithVersion(genericSchema, version);
+        const schema = await generateSchemaWithVersion(genericSchema, schemaType, version);
         results.set(version, schema);
     }
     return results;
 }
+// ============================================================================
+// Public API
+// ============================================================================
 /**
  * Gets validity properties for a class from a generic schema
- *
- * Combines schema property names with validity decorator metadata
- * to get complete validity information for testing.
- *
- * @param genericSchema - The generic schema containing the definition
- * @param classRef - The class constructor to extract validity metadata from
- * @param schemaName - Optional schema definition name (defaults to class name)
- * @returns Array of ValidityInfo objects
  */
 function getValidityProperties(genericSchema, classRef, schemaName) {
     const schemaProps = getSchemaPropertyNames(genericSchema, schemaName || classRef.name);
-    const validityProperties = getValidityPropertiesFromClass(classRef, schemaProps);
-    return validityProperties;
+    return getValidityPropertiesFromClass(classRef, schemaProps);
 }
 /**
- * Generates a markdown visibility table for a decorated class
- *
- * @param config - Configuration object with classRef and optional schemaName
- * @param config.classRef - The class constructor containing @validity decorators
- * @param config.schemaName - Optional schema definition name (defaults to class name)
- * @param schemaType - Whether to generate expected or actual visibility
- * @param context - Test context containing genericSchema, versions, and schemaResults
- * @returns Formatted markdown table string
+ * Compares expected vs actual visibility and returns both tables for assertion
+ */
+function compareExpectedVsActual(validityInfos, versions, schemaResults, findDefinition) {
+    const expectedTable = generateExpectedVisibilityTable(validityInfos, versions);
+    const actualTable = generateActualVisibilityTable(validityInfos, versions, schemaResults, findDefinition);
+    return {
+        expected: formatVisibilityTableMarkdown(expectedTable, versions),
+        actual: formatVisibilityTableMarkdown(actualTable, versions)
+    };
+}
+/**
+ * Compares expected vs actual enum visibility and returns both tables for assertion
  */
+function compareExpectedVsActualEnum(enumInfos, versions, schemaResults, findDefinition) {
+    const expectedTable = generateExpectedEnumVisibilityTable(enumInfos, versions);
+    const actualTable = generateActualEnumVisibilityTable(enumInfos, versions, schemaResults, findDefinition);
+    return {
+        expected: formatVisibilityTableMarkdown(expectedTable, versions),
+        actual: formatVisibilityTableMarkdown(actualTable, versions)
+    };
+}
+// ============================================================================
+// Backward-compatible API
+// ============================================================================
+var SchemaResults;
+(function (SchemaResults) {
+    SchemaResults["Expected"] = "expected";
+    SchemaResults["Actual"] = "actual";
+})(SchemaResults || (exports.SchemaResults = SchemaResults = {}));
 const getPropertiesWithValidity = ({ classRef, schemaName }, schemaType, { genericSchema, versions, schemaResults }) => {
     const validityProperties = getValidityProperties(genericSchema, classRef, schemaName);
     let table;
     if (schemaType === SchemaResults.Expected) {
         table = generateExpectedVisibilityTable(validityProperties, versions);
     }
-    else if (schemaType === SchemaResults.Actual) {
+    else {
         table = generateActualVisibilityTable(validityProperties, versions, schemaResults, findDefinitionByName(schemaName || classRef.name));
     }
-    const tableMarkdown = formatVisibilityTableMarkdown(table, versions);
-    return tableMarkdown;
+    return formatVisibilityTableMarkdown(table, versions);
 };
 exports.getPropertiesWithValidity = getPropertiesWithValidity;
-/** Emoji indicator for a difference between expected and actual */
-exports.EMOJI_DIFF = '⚠️';
-/** Emoji indicator for match between expected and actual */
-exports.EMOJI_MATCH = '✅';
-/**
- * Generates a diff table comparing expected vs actual visibility
- *
- * For each property and version, compares expected (from @validity metadata)
- * vs actual (from generated schema) and highlights differences.
- *
- * @param validityInfos - Array of properties with their validity info
- * @param versions - Array of version strings to check
- * @param schemaResults - Map of version strings to generated schemas
- * @param findDefinition - Function to locate the definition within each schema
- * @returns Array of rows showing expected vs actual comparison per version
- */
-function generateDiffVisibilityTable(validityInfos, versions, schemaResults, findDefinition) {
-    const expectedTable = generateExpectedVisibilityTable(validityInfos, versions);
-    const actualTable = generateActualVisibilityTable(validityInfos, versions, schemaResults, findDefinition);
-    return validityInfos.map((info, index) => {
-        const row = {
-            property: info.property,
-            since: info.since
-        };
-        for (const version of versions) {
-            const expected = expectedTable[index][version];
-            const actual = actualTable[index][version];
-            if (expected === actual) {
-                row[version] = exports.EMOJI_MATCH;
-            }
-            else {
-                row[version] = exports.EMOJI_DIFF;
-            }
-        }
-        return row;
-    });
-}
-/**
- * Formats diff table as a markdown string for snapshot testing
- *
- * Shows which property/version combinations have mismatches between
- * expected (decorator metadata) and actual (generated schema) visibility.
- *
- * @param rows - Array of diff rows to format
- * @param versions - Array of version strings for column headers
- * @returns Formatted markdown table string with diff indicators
- */
-function formatDiffTableMarkdown(rows, versions) {
-    const lines = [];
-    // Calculate column widths
-    const propWidth = Math.max(26, ...rows.map((r) => r.property.length));
-    const sinceWidth = 7;
-    const versionWidth = 9;
-    // Helper functions for padding
-    const padEnd = (str, width) => str.padEnd(width);
-    const padCenter = (str, width) => {
-        const padding = width - str.length;
-        const left = Math.floor(padding / 2);
-        return ' '.repeat(left) + str + ' '.repeat(padding - left);
-    };
-    // Emoji centering
-    const padCenterEmoji = (emoji) => `   ${emoji}    `;
-    // Header
-    const headerCells = [
-        padEnd('Property', propWidth),
-        padEnd('Since', sinceWidth),
-        ...versions.map((v) => padCenter(v, versionWidth))
-    ];
-    lines.push(`| ${headerCells.join(' | ')} |`);
-    // Separator
-    const sepCells = ['-'.repeat(propWidth), '-'.repeat(sinceWidth), ...versions.map(() => '-'.repeat(versionWidth))];
-    lines.push(`| ${sepCells.join(' | ')} |`);
-    // Data rows
-    for (const row of rows) {
-        const cells = [
-            padEnd(row.property, propWidth),
-            padEnd(row.since, sinceWidth),
-            ...versions.map((v) => padCenterEmoji(row[v]))
-        ];
-        lines.push(`| ${cells.join(' | ')} |`);
-    }
-    // Legend
-    lines.push('');
-    lines.push(`Legend: ${exports.EMOJI_MATCH} = match, ${exports.EMOJI_DIFF} = mismatch`);
-    return lines.join('\n');
-}
 //# sourceMappingURL=validity-test-utils.js.map