@siliconst/metaui 1.4.51 → 2.0.0

package/src/nz/co/siliconst/ui5/metaui/plugins/policies/conditions/StringEqualsConditionPlugin.ts

@@ -1,34 +1,43 @@
-import { IPolicyConditionPlugin } from "../../../interfaces/IPolicyPlugin";
-
-/**
- * Evaluates whether a target property matches a specific string exactly.
- * Used for routing logic, like hiding fields based on a dropdown selection.
- */
-export class StringEqualsConditionPlugin implements IPolicyConditionPlugin {
-    /**
-     * Determines if this plugin can handle the given schema condition block.
-     * @param conditionKey The key found in the schema (e.g., "StringEquals").
-     * @returns True if the key is "StringEquals".
-     */
-    public canHandle(conditionKey: string): boolean {
-        return conditionKey === "StringEquals";
-    }
-
-    /**
-     * Evaluates the configured equality strings against the live state payload.
-     * @param conditionPayload A record mapping JSON pointers to target string values.
-     * @param data The live JSON model payload.
-     * @param resolvePointer A function to resolve a JSON pointer against the data payload.
-     * @returns True if all mapped properties strictly equal their targets, false otherwise.
-     */
-    public evaluate(conditionPayload: unknown, data: unknown, resolvePointer: (d: unknown, p: string) => unknown): boolean {
-        const payload = conditionPayload as Record<string, string>;
-        if (!payload) return true;
-
-        for (const [path, targetStr] of Object.entries(payload)) {
-            const val = resolvePointer(data, path);
-            if (String(val) !== String(targetStr)) return false;
-        }
-        return true;
-    }
-}
+/**
+ * @file StringEqualsConditionPlugin.ts
+ * @description Policy condition plugin that evaluates whether target properties strictly equal configured string values.
+ */
+
+import { IPolicyConditionPlugin } from "../../../interfaces/IPolicyPlugin";
+import { isRecord } from "../../../utils/TypeGuards";
+import { Logger } from "../../../utils/Logger";
+import { PolicyConditionUtil } from "../../../utils/PolicyConditionUtil";
+
+/**
+ * Evaluates whether a target property matches a specific string exactly.
+ * Used for routing logic, like hiding fields based on a dropdown selection.
+ */
+export class StringEqualsConditionPlugin implements IPolicyConditionPlugin {
+    /**
+     * Evaluates the configured equality strings against the live state payload.
+     * @param conditionPayload A record mapping JSON pointers to target string values.
+     * @param data The live JSON model payload.
+     * @param resolvePointer A function to resolve a JSON pointer against the data payload.
+     * @returns True if all mapped properties strictly equal their targets, false otherwise.
+     */
+    public evaluate(conditionPayload: unknown, data: unknown, resolvePointer: (d: unknown, p: string) => unknown): boolean {
+        if (!isRecord(conditionPayload) || Object.keys(conditionPayload).length === 0) {
+            Logger.warn(
+                `Malformed condition payload for operator 'StringEquals': ` +
+                `expected non-empty object, got ${typeof conditionPayload}. Failing closed (false).`,
+                undefined,
+                "StringEqualsConditionPlugin"
+            );
+            return false;
+        }
+
+        for (const [path, targetStr] of Object.entries(conditionPayload)) {
+            const val = resolvePointer(data, path);
+            const resolvedTarget = PolicyConditionUtil.resolveThreshold(targetStr, data, resolvePointer);
+            const actual = val === undefined || val === null ? "" : String(val);
+            const expected = resolvedTarget === undefined || resolvedTarget === null ? "" : String(resolvedTarget);
+            if (actual !== expected) return false;
+        }
+        return true;
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/plugins/policies/effects/BinaryEffectPlugin.ts

@@ -0,0 +1,48 @@
+/**
+ * @file BinaryEffectPlugin.ts
+ * @description Unified table-driven policy effect plugin translating all 8 binary effects
+ * (Show, Hide, Validate, Invalidate, Require, Optional, Enable, Disable) into structural UI deltas.
+ */
+
+import { IPolicyEffectPlugin } from "../../../interfaces/IPolicyPlugin";
+import { PropertyName } from "../../../core/PolicyEngine";
+
+const EFFECT_TABLE: Readonly<Record<string, readonly [PropertyName, boolean]>> = {
+    Show: ["visibility", true],
+    Hide: ["visibility", false],
+    Validate: ["validity", true],
+    Invalidate: ["validity", false],
+    Require: ["required", true],
+    Optional: ["required", false],
+    Enable: ["editable", true],
+    Disable: ["editable", false]
+};
+
+/**
+ * Table-driven policy effect plugin that translates semantic policy effects into binary structural UI deltas
+ * with automatic symmetrical reversal when the governing condition is false.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.plugins.policies.effects
+ * @internal
+ */
+export class BinaryEffectPlugin implements IPolicyEffectPlugin {
+    /**
+     * Resolves any registered binary policy effect into its target structural property and boolean state.
+     *
+     * @param isConditionMet Whether the governing policy condition passed.
+     * @param originalEffect The semantic effect name declared in the schema.
+     * @returns {{ property: PropertyName; value: boolean }} The resolved property and boolean value.
+     */
+    public resolveState(
+        isConditionMet: boolean,
+        originalEffect: string
+    ): { property: PropertyName; value: boolean } {
+        const entry = EFFECT_TABLE[originalEffect] || ["visibility", true];
+        const [property, baseValue] = entry;
+        return {
+            property,
+            value: isConditionMet ? baseValue : !baseValue
+        };
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/ArrayItemsValidatorPlugin.ts

@@ -0,0 +1,102 @@
+/**
+ * @file ArrayItemsValidatorPlugin.ts
+ * @description Enforces the JSON-Schema array keywords `minItems`, `maxItems` and `uniqueItems`.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { isRecord, readNumber, readBoolean } from "../../utils/TypeGuards";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/** Arguments accepted by the array items validator. */
+export interface IArrayItemsArgs {
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+}
+
+/**
+ * Produces a deterministic, key-order-independent JSON string signature for structural equality checks.
+ *
+ * @param value The value to serialize.
+ * @returns {string} Canonical JSON string.
+ */
+export function canonicalSerialize(value: unknown): string {
+    if (Array.isArray(value)) {
+        return `[${value.map((entry) => canonicalSerialize(entry)).join(",")}]`;
+    }
+    if (isRecord(value)) {
+        const sortedKeys = Object.keys(value).sort();
+        const pairs = sortedKeys.map((k) => `${JSON.stringify(k)}:${canonicalSerialize(value[k])}`);
+        return `{${pairs.join(",")}}`;
+    }
+    return JSON.stringify(value);
+}
+
+/**
+ * Validates array cardinality and uniqueness. Non-array values are ignored.
+ * Uniqueness compares items structurally (JSON serialization), matching JSON-Schema semantics for objects.
+ */
+export class ArrayItemsValidatorPlugin implements IValidator {
+    /**
+     * Extracts `minItems`, `maxItems`, and `uniqueItems` constraints from a schema property descriptor.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status and array constraint arguments.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        const active =
+            propMeta.minItems !== undefined || propMeta.maxItems !== undefined || propMeta.uniqueItems === true;
+        if (!active) {
+            return { active: false };
+        }
+        return {
+            active: true,
+            args: {
+                minItems: propMeta.minItems,
+                maxItems: propMeta.maxItems,
+                uniqueItems: propMeta.uniqueItems
+            }
+        };
+    }
+
+    /**
+     * An `args` payload that is not an {@link IArrayItemsArgs} record is a schema configuration error and fails
+     * closed, matching `PatternValidatorPlugin`: a constraint the engine cannot apply must never report the field
+     * as valid. A non-array value is a different case and still passes — these keywords do not apply to it.
+     *
+     * @param parsedValue The array to test.
+     * @param args The {@link IArrayItemsArgs} constraints.
+     * @returns {IValidationResult} Invalid if any constraint is violated or the constraints are misconfigured.
+     */
+    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
+        if (!isRecord(args)) {
+            return {
+                isValid: false,
+                errorMessage: I18n.getText(TEXT_KEY.schemaConfigArrayItemsObject)
+            };
+        }
+        if (!Array.isArray(parsedValue)) return { isValid: true };
+
+        const minItems = readNumber(args, "minItems");
+        const maxItems = readNumber(args, "maxItems");
+
+        if (minItems !== undefined && parsedValue.length < minItems) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.arrayMinItems, [minItems]) };
+        }
+        if (maxItems !== undefined && parsedValue.length > maxItems) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.arrayMaxItems, [maxItems]) };
+        }
+        if (readBoolean(args, "uniqueItems") === true) {
+            const seen = new Set<string>();
+            for (const item of parsedValue) {
+                const signature = canonicalSerialize(item);
+                if (seen.has(signature)) {
+                    return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.arrayUniqueItems) };
+                }
+                seen.add(signature);
+            }
+        }
+        return { isValid: true };
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/ConstValidatorPlugin.ts

@@ -0,0 +1,48 @@
+/**
+ * @file ConstValidatorPlugin.ts
+ * @description Validates that a value strictly matches the JSON Schema `const` keyword.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+import { safeToString } from "../../core/SafeConvert";
+
+/**
+ * Enforces the JSON Schema `const` constraint.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
+ * @internal
+ */
+export class ConstValidatorPlugin implements IValidator {
+    /**
+     * Extracts the `const` target value from a schema property descriptor.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status and expected constant value.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        if (propMeta.const === undefined) {
+            return { active: false };
+        }
+        return { active: true, args: propMeta.const };
+    }
+
+    /**
+     * Validates that `parsedValue` strictly equals the expected `const` argument.
+     *
+     * @param parsedValue The value to test.
+     * @param args The expected constant value.
+     * @returns {IValidationResult} Invalid if the value does not equal `args`.
+     */
+    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
+        if (parsedValue === undefined || parsedValue === null || parsedValue === "" || args === undefined) {
+            return { isValid: true };
+        }
+        if (parsedValue !== args) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.constEquality, [safeToString(args)]) };
+        }
+        return { isValid: true };
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/EmailValidatorPlugin.ts

@@ -1,30 +1,46 @@
-/**
- * @file EmailValidatorPlugin.ts
- * @description Standard business logic validator for email addresses.
- */
-
-import { IValidator, IValidationResult } from "../../interfaces/IPipeline";
-
-/**
- * Standard business logic validator for email addresses.
- * Extracts the email regex validation logic into a standalone, modular plugin.
- * 
- * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
- * @public
- */
-export class EmailValidatorPlugin implements IValidator {
-    /**
-     * Validates parsed data before it enters the JSON model.
-     * @param parsedValue The cleaned data to validate.
-     * @param args Optional arguments provided in the schema.
-     * @returns IValidationResult containing status and optional error message.
-     */
-    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
-        if (!parsedValue) return { isValid: true }; // Let RequiredValidator handle empty
-        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-        if (typeof parsedValue !== "string" || !emailRegex.test(parsedValue)) {
-            return { isValid: false, errorMessage: "Please enter a valid email address." };
-        }
-        return { isValid: true };
-    }
-}
+/**
+ * @file EmailValidatorPlugin.ts
+ * @description Standard business logic validator for email addresses.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { WIDGET_TYPE } from "../../constants/MetaUIConstants";
+import { isEmptyValue } from "./RequiredValidatorPlugin";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/**
+ * Standard business logic validator for email addresses.
+ * Extracts the email regex validation logic into a standalone, modular plugin.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
+ * @internal
+ */
+export class EmailValidatorPlugin implements IValidator {
+    /**
+     * Activates when `ui.format` is set to `"email"`.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        const fmt = propMeta.ui?.format || propMeta.format;
+        const widget = propMeta.ui?.widget;
+        return { active: fmt === "email" || widget === WIDGET_TYPE.EMAIL };
+    }
+
+    /**
+     * Validates parsed data before it enters the JSON model.
+     * @param parsedValue The cleaned data to validate.
+     * @param args Optional arguments provided in the schema.
+     * @returns IValidationResult containing status and optional error message.
+     */
+    public validate(parsedValue: unknown, _args?: unknown): IValidationResult {
+        if (isEmptyValue(parsedValue)) return { isValid: true }; // Let RequiredValidator handle empty
+        const emailRegex = /^[^\s@.]+(?:\.[^\s@.]+)*@[^\s@.]+(?:\.[^\s@.]+)+$/;
+        if (typeof parsedValue !== "string" || !emailRegex.test(parsedValue)) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.email) };
+        }
+        return { isValid: true };
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/EnumValidatorPlugin.ts

@@ -0,0 +1,82 @@
+/**
+ * @file EnumValidatorPlugin.ts
+ * @description Validates that a value matches one of the allowed JSON Schema `enum` entries.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { canonicalSerialize } from "./ArrayItemsValidatorPlugin";
+import { isRecord } from "../../utils/TypeGuards";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/**
+ * Enforces the JSON Schema `enum` constraint across primitive, object, array, and `{ key, text }` enum entries.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
+ * @internal
+ */
+export class EnumValidatorPlugin implements IValidator {
+    /**
+     * Extracts the `enum` array from a schema property descriptor.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status and allowed enum list.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        if (Array.isArray(propMeta.enum) && propMeta.enum.length > 0) {
+            return { active: true, args: { enum: propMeta.enum, isItemEnum: false } };
+        }
+        if (Array.isArray(propMeta.items?.enum) && propMeta.items!.enum.length > 0) {
+            return { active: true, args: { enum: propMeta.items!.enum, isItemEnum: true } };
+        }
+        return { active: false };
+    }
+
+    /**
+     * Validates that `parsedValue` is included in the allowed `enum` array.
+     *
+     * @param parsedValue The value to test.
+     * @param args The allowed enum values array or `{ enum: unknown[], isItemEnum: boolean }`.
+     * @returns {IValidationResult} Invalid if the value is not in the allowed set.
+     */
+    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
+        const enumList = Array.isArray(args)
+            ? args
+            : isRecord(args) && Array.isArray(args.enum)
+              ? args.enum
+              : null;
+        const isItemEnum = isRecord(args) && args.isItemEnum === true;
+        if (parsedValue === undefined || parsedValue === null || parsedValue === "" || !enumList || enumList.length === 0) {
+            return { isValid: true };
+        }
+        const matchesEntry = (val: unknown): boolean => {
+            if (enumList.includes(val)) return true;
+            const serializedVal = typeof val === "object" && val !== null ? canonicalSerialize(val) : null;
+            return enumList.some((item) => {
+                if (serializedVal !== null && typeof item === "object" && item !== null) {
+                    if (canonicalSerialize(item) === serializedVal) return true;
+                }
+                if (isRecord(item) && "key" in item && "text" in item) {
+                    return item.key === val || String(item.key) === String(val);
+                }
+                return false;
+            });
+        };
+        const shouldCheckItems = Array.isArray(parsedValue) && (isItemEnum || !enumList.some(Array.isArray));
+        const matched = shouldCheckItems
+            ? parsedValue.every((elem) => matchesEntry(elem))
+            : matchesEntry(parsedValue);
+        if (!matched) {
+            const labels = enumList.map((item) =>
+                isRecord(item) && "key" in item && "text" in item && item.key !== undefined
+                    ? String(item.key)
+                    : typeof item === "object" && item !== null
+                      ? JSON.stringify(item)
+                      : String(item)
+            );
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.enumMembership, [labels.join(", ")]) };
+        }
+        return { isValid: true };
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/IbanValidatorPlugin.ts

@@ -1,35 +1,66 @@
-/**
- * @file IbanValidatorPlugin.ts
- * @description Standard business logic validator for International Bank Account Numbers.
- */
-
-import { IValidator, IValidationResult } from "../../interfaces/IPipeline";
-
-/**
- * Validates a standard IBAN string.
- * This provides a simplified check for demonstration (starts with 2 chars, followed by digits/chars).
- * 
- * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
- * @public
- */
-export class IbanValidatorPlugin implements IValidator {
-    /**
-     * Validates parsed data before it enters the JSON model.
-     * @param parsedValue The cleaned data to validate.
-     * @param args Optional arguments provided in the schema.
-     * @returns IValidationResult containing status and optional error message.
-     */
-    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
-        if (!parsedValue) return { isValid: true }; // Let RequiredValidator handle empty
-        
-        // Very basic IBAN structure regex (e.g. DE89370400440532013000)
-        // A true IBAN check requires modulo 97 arithmetic which is out of scope for a basic mock.
-        const ibanRegex = /^[A-Z]{2}\d{2}[A-Z0-9]{1,30}$/;
-        
-        if (typeof parsedValue !== "string" || !ibanRegex.test(parsedValue.replace(/\s+/g, '').toUpperCase())) {
-            return { isValid: false, errorMessage: "Please enter a valid IBAN." };
-        }
-        
-        return { isValid: true };
-    }
-}
+/**
+ * @file IbanValidatorPlugin.ts
+ * @description Validates International Bank Account Numbers (ISO 13616).
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/**
+ * Full IBAN validation: structural check plus the ISO 7064 MOD 97-10 checksum.
+ * Spaces are ignored and letters are case-insensitive, matching how IBANs are printed.
+ */
+export class IbanValidatorPlugin implements IValidator {
+    /**
+     * Activates when `ui.format` is set to `"iban"`.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        const fmt = propMeta.ui?.format || propMeta.format;
+        return { active: fmt === "iban" };
+    }
+
+    /**
+     * @param parsedValue The value to test.
+     * @returns {IValidationResult} Invalid if the structure or checksum is wrong.
+     */
+    public validate(parsedValue: unknown): IValidationResult {
+        if (parsedValue === null || parsedValue === undefined || parsedValue === "") return { isValid: true };
+        if (typeof parsedValue !== "string") {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.iban) };
+        }
+
+        const iban = parsedValue.replace(/\s+/g, "").toUpperCase();
+        if (!/^[A-Z]{2}\d{2}[A-Z0-9]{11,30}$/.test(iban)) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.iban) };
+        }
+
+        if (IbanValidatorPlugin.mod97(iban) !== 1) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.ibanChecksum) };
+        }
+        return { isValid: true };
+    }
+
+    /**
+     * Computes the ISO 7064 MOD 97-10 remainder. The country code and check digits are moved to the end,
+     * letters are expanded to numbers (A=10 … Z=35), and the remainder is computed digit by digit to avoid
+     * exceeding the safe integer range.
+     *
+     * @param iban A normalized (uppercase, no spaces) IBAN.
+     * @returns {number} The remainder; 1 for a valid IBAN.
+     */
+    private static mod97(iban: string): number {
+        const rearranged = iban.slice(4) + iban.slice(0, 4);
+        let remainder = 0;
+        for (const char of rearranged) {
+            const digits = /[A-Z]/.test(char) ? String(char.charCodeAt(0) - 55) : char;
+            for (const digit of digits) {
+                remainder = (remainder * 10 + Number(digit)) % 97;
+            }
+        }
+        return remainder;
+    }
+}

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/IntegerValidatorPlugin.ts

@@ -0,0 +1,43 @@
+/**
+ * @file IntegerValidatorPlugin.ts
+ * @description Validates that numeric values for `type: "integer"` fields are finite whole numbers.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/**
+ * Enforces that fields declared with `type: "integer"` contain finite whole integers.
+ *
+ * @namespace nz.co.siliconst.ui5.metaui.plugins.validators
+ * @internal
+ */
+export class IntegerValidatorPlugin implements IValidator {
+    /**
+     * Activates the integer validator when `propMeta.type === "integer"`.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        return { active: propMeta.type === "integer" };
+    }
+
+    /**
+     * Validates that `parsedValue` is a finite whole number when numeric.
+     *
+     * @param parsedValue The value to test.
+     * @returns {IValidationResult} Invalid if the numeric value is fractional or non-finite.
+     */
+    public validate(parsedValue: unknown): IValidationResult {
+        if (typeof parsedValue !== "number") {
+            return { isValid: true };
+        }
+        if (!Number.isFinite(parsedValue) || !Number.isInteger(parsedValue)) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.integer) };
+        }
+        return { isValid: true };
+    }
+}
+

package/src/nz/co/siliconst/ui5/metaui/plugins/validators/MaxLengthValidatorPlugin.ts

@@ -0,0 +1,49 @@
+/**
+ * @file MaxLengthValidatorPlugin.ts
+ * @description Enforces the JSON-Schema `maxLength` keyword on strings.
+ */
+
+import { IValidator, IValidationResult, IValidatorRuleExtraction } from "../../interfaces/IPipeline";
+import { IPropertyMetadata } from "../../interfaces/ISchema";
+import { I18n, TEXT_KEY } from "../../utils/I18n";
+
+/**
+ * Fails when a string exceeds the configured number of characters. Non-strings are ignored.
+ */
+export class MaxLengthValidatorPlugin implements IValidator {
+    /**
+     * Extracts the `maxLength` constraint from a schema property descriptor.
+     *
+     * @param propMeta The schema property descriptor.
+     * @returns {IValidatorRuleExtraction} Activation status and `maxLength` limit.
+     */
+    public extractRule(propMeta: IPropertyMetadata): IValidatorRuleExtraction {
+        return {
+            active: propMeta.maxLength !== undefined,
+            args: propMeta.maxLength
+        };
+    }
+
+    /**
+     * A non-numeric `maxLength` is a schema configuration error and fails closed, matching
+     * `PatternValidatorPlugin`: a constraint the engine cannot apply must never report the field as valid.
+     * A non-string value is a different case and still passes — `maxLength` simply does not apply to it.
+     *
+     * @param parsedValue The value to test.
+     * @param args The maximum allowed length.
+     * @returns {IValidationResult} Invalid if the string is too long or the limit is misconfigured.
+     */
+    public validate(parsedValue: unknown, args?: unknown): IValidationResult {
+        if (typeof args !== "number") {
+            return {
+                isValid: false,
+                errorMessage: I18n.getText(TEXT_KEY.schemaConfigMustBeNumber, ["maxLength"])
+            };
+        }
+        if (typeof parsedValue !== "string") return { isValid: true };
+        if (Array.from(parsedValue).length > args) {
+            return { isValid: false, errorMessage: I18n.getText(TEXT_KEY.maxLength, [args]) };
+        }
+        return { isValid: true };
+    }
+}