@arsedizioni/ars-utils 22.5.28 → 22.5.32

package/fesm2022/arsedizioni-ars-utils-core.validators.mjs

@@ -702,118 +702,38 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImpor
         }] });
 
 /**
- * Signal-forms counterparts of the classic validator directives in this entry point.
- *
- * The `[formField]` directive only honours `NG_VALIDATORS` providers on ControlValueAccessor
- * hosts (custom controls); on native inputs the attribute directives (`password`, `emails`,
- * `time`, `equals`) are ignored. Schemas built with `form()` must therefore use these
- * functions instead. Error kinds and messages match the directive versions one to one.
- */
-/**
- * Binds a validator requiring the value to be a semicolon-separated list of valid
- * email addresses. An empty value is considered valid (pair with `required` if needed).
- * Signal-forms counterpart of `EmailsValidatorDirective`.
- * @param path - Path of the string field to validate.
- */
-function emailsValidator(path) {
-    validate(path, ({ value }) => {
-        const input = value();
-        if (!input || input.length === 0)
-            return undefined;
-        const parts = input.replaceAll(/\r\n/g, '').split(';');
-        const isValid = parts.every(part => part.length === 0 || !!SystemUtils.parseEmail(part));
-        return isValid ? undefined : { kind: 'emails', message: 'Elenco non valido.' };
-    });
-}
-/**
- * Binds a validator requiring the value to meet the minimum password-strength
- * requirements (see `SystemUtils.calculatePasswordStrength`). An empty value is
- * INVALID, exactly like the classic directive.
- * Signal-forms counterpart of `PasswordValidatorDirective`.
- * @param path - Path of the string field to validate.
+ * Default texts of the rules declared here, in one place so that the validators and the fallback
+ * map of `SignalsUtils.getFieldErrorMessage` cannot drift apart: a rule added below without a
+ * message here would show "Errore", and one renamed here without touching the validator would
+ * leave the map with a kind nobody produces.
  */
-function passwordValidator(path) {
-    validate(path, ({ value }) => {
-        const strength = SystemUtils.calculatePasswordStrength(value() ?? '');
-        return strength.isValid ? undefined : { kind: 'password', message: 'Non valido.' };
-    });
-}
 /**
- * Binds a validator requiring the value to be a valid `"HH:MM"` time string and,
- * when slots are provided, to fall within at least one of the allowed ranges.
- * An empty value is considered valid (pair with `required` if needed).
- * Signal-forms counterpart of `TimeValidatorDirective`.
- * @param path  - Path of the string field to validate.
- * @param slots - Optional reactive function returning the pipe-separated allowed
- *                ranges (e.g. `"08:00-12:00|14:00-18:00"`), or `undefined` for none.
- */
-function timeValidator(path, slots) {
-    /**
-     * Parses a `"HH:MM"` time string into a comparable integer (e.g. `"09:30"` -> `930`).
-     * Returns `-1` when the string is not a valid time.
-     * @param value - The time string to parse.
-     * @returns The comparable integer, or `-1` when invalid.
-     */
-    const getTime = (value) => {
-        const p = value.split(':');
-        if (p.length !== 2)
-            return -1;
-        const hh = parseInt(p[0], 10);
-        if (isNaN(hh) || hh < 0 || hh > 23)
-            return -1;
-        const mm = parseInt(p[1], 10);
-        if (isNaN(mm) || mm < 0 || mm > 59)
-            return -1;
-        return hh * 100 + mm;
-    };
-    validate(path, ({ value }) => {
-        const input = value();
-        if (!input || input.length === 0)
-            return undefined;
-        const t = getTime(input);
-        if (t === -1)
-            return { kind: 'time', message: 'Non valido.' };
-        const slotsValue = slots?.();
-        if (slotsValue) {
-            const isValid = slotsValue.split('|').some(s => {
-                const t1 = getTime(s.substring(0, 5));
-                const t2 = getTime(s.substring(6));
-                return t1 !== -1 && t2 !== -1 && t1 <= t && t2 >= t;
-            });
-            if (!isValid)
-                return { kind: 'time', message: 'Non valido.' };
-        }
-        return undefined;
-    });
-}
-/**
- * Binds a validator requiring the value to strictly equal the value of another field
- * of the same form. Reactive on both fields, so the host field re-validates when the
- * other field changes (this replaces the `valueChanges` subscription of the directive).
- * Signal-forms counterpart of `EqualsValidatorDirective`.
- * @param path  - Path of the field to validate.
- * @param other - Path of the field whose value must match.
- */
-function equalsValidator(path, other) {
-    validate(path, ctx => ctx.valueOf(other) === ctx.value()
-        ? undefined
-        : { kind: 'equals', message: 'Non valido.' });
-}
-/**
- * Binds a validator requiring the value to be either empty or a complete 6-digit
- * OTP code. A partial code (e.g. `"12"`) is invalid; emptiness is left to `required`.
- * Schema-level counterpart of the `OtpInputComponent` internal validator.
- * @param path - Path of the string field to validate.
+ * Earliest date {@link date} and {@link dateRange} accept: 1 January 1970.
+ *
+ * Everything this application stores — events, certificates, payments, communications — happened
+ * after it, so an earlier value is always a typo (a two-digit year, a slipped keystroke) and never
+ * real data. The floor is deliberately higher than the one of {@link sqlDate}, which only asks
+ * what SQL Server can physically store.
  */
-function otpValidator(path) {
-    validate(path, ({ value }) => {
-        const input = value() ?? '';
-        if (input.length === 0)
-            return undefined;
-        return /^\d{6}$/.test(input) ? undefined : { kind: 'otp', message: 'Non valido.' };
-    });
-}
-
+const MIN_VALID_YEAR = 1970;
+const ARS_VALIDATOR_MESSAGES = {
+    guid: 'Ticket non riconosciuto',
+    password: 'Password non sufficientemente robusta',
+    notEmpty: 'Non può contenere solo spazi',
+    notEqual: 'Deve essere diverso dall\'altro valore',
+    sqlDate: 'Data non valida',
+    date: 'Data non valida',
+    dateRange: 'Intervallo non valido',
+    notFuture: 'La data non può essere futura',
+    url: 'Indirizzo non valido',
+    maxTerms: 'Troppe parole',
+    fileSize: 'Dimensione del file non ammessa',
+    validIf: 'Non valido',
+    emails: 'Elenco non valido',
+    time: 'Orario non valido',
+    equals: 'I due valori non coincidono',
+    otp: 'Codice non valido',
+};
 /**
  * Requires the value to be a well-formed GUID / UUID.
  *
@@ -836,7 +756,7 @@ function guid(path, config) {
             return null;
         return SystemUtils.parseUUID(input)
             ? null
-            : { kind: 'guid', message: config?.message ?? 'Ticket non riconosciuto' };
+            : { kind: 'guid', message: config?.message ?? ARS_VALIDATOR_MESSAGES['guid'] };
     });
 }
 /**
@@ -856,7 +776,7 @@ function password(path, config) {
         const strength = SystemUtils.calculatePasswordStrength(ctx.value() ?? '');
         return strength.isValid
             ? null
-            : { kind: 'password', message: config?.message ?? 'Password non sufficientemente robusta' };
+            : { kind: 'password', message: config?.message ?? ARS_VALIDATOR_MESSAGES['password'] };
     });
 }
 /**
@@ -885,9 +805,448 @@ function notEmpty(path, config) {
             return null;
         return input.trim().length > 0
             ? null
-            : { kind: 'notEmpty', message: config?.message ?? 'Non può contenere solo spazi' };
+            : { kind: 'notEmpty', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notEmpty'] };
+    });
+}
+/**
+ * Requires the value to differ from the value of another field of the same form.
+ *
+ * The signal-form counterpart of `NotEqualValidatorDirective`, with its exact rule: two empty
+ * values are considered different, so an untouched pair of fields does not start out in error.
+ * Reactive on both fields — editing either one re-validates this one, which is what the
+ * directive needed a `valueChanges` subscription (and a re-entrancy guard) to achieve.
+ *
+ * @param path   - Path of the field to validate.
+ * @param other  - Path of the field whose value must differ.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function notEqual(path, other, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const mine = ctx.value();
+        const theirs = ctx.valueOf(other);
+        const isValid = (!theirs && !mine) || theirs !== mine;
+        return isValid ? null : { kind: 'notEqual', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notEqual'] };
+    });
+}
+/**
+ * Requires the value to be a date the backend can store: parseable, and after 1750.
+ *
+ * The signal-form counterpart of `SqlDateValidatorDirective`. The year floor is not arbitrary —
+ * it is what separates a real date from the 01/01/0001 that a mistyped year produces, which SQL
+ * Server rejects with an error nobody can read.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function sqlDate(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input || input.length === 0)
+            return null;
+        const parsed = SystemUtils.parseDate(input);
+        const invalid = { kind: 'sqlDate', message: config?.message ?? ARS_VALIDATOR_MESSAGES['sqlDate'] };
+        if (!parsed)
+            return invalid;
+        return endOfDay(parsed).getFullYear() > 1750 ? null : invalid;
+    });
+}
+/**
+ * Requires the value to be a real date, as {@link SystemUtils.parseDate} understands one.
+ *
+ * This is the rule for anything a user picks or types as a date: it accepts both the `Date` a
+ * Material datepicker or timepicker writes into the model and the text of a plain input, since
+ * `parseDate` handles the shapes this codebase produces (ISO, `dd/MM/yyyy`, `yyyy-MM-dd`, and the
+ * shorthand forms). Empty passes — saying "obbligatorio" is the job of `required()`.
+ *
+ * A date earlier than {@link MIN_VALID_YEAR} (1 January 1970) is rejected: nothing this
+ * application stores predates it, so an earlier value is a typo rather than data.
+ *
+ * Distinct from {@link sqlDate} on purpose: that one is about what the DATABASE can store (the
+ * 1750 floor), this one is about whether the value is a date at all. Pair them when both matter.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ * @example
+ * const f = form(this.model, p => { required(p.expiry); date(p.expiry); });
+ */
+function date(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (input === undefined || input === null || input === '')
+            return null;
+        const parsed = SystemUtils.parseDate(input);
+        return parsed && parsed.getFullYear() >= MIN_VALID_YEAR
+            ? null
+            : { kind: 'date', message: config?.message ?? ARS_VALIDATOR_MESSAGES['date'] };
+    });
+}
+/**
+ * Requires the two ends of a date range to be real dates and to be in order.
+ *
+ * Written for the two inputs of a `mat-date-range-input`, whose start and end live in two
+ * separate fields of the model. Each end is checked with the same rule as {@link date}, and the
+ * ordering is checked only when BOTH ends are filled in — a half-open range ("from today
+ * onwards") is a legitimate filter, not an error. The 1 January 1970 floor of {@link date}
+ * applies to both ends.
+ *
+ * The rule is bound to BOTH paths, so the error appears on whichever end the user is looking at
+ * and a single `<mat-error>` under the range can read either one. Comparison is made on the end
+ * of the day, so picking the same day for both ends is valid.
+ *
+ * @param from   - Path of the field holding the start of the range.
+ * @param to     - Path of the field holding the end of the range.
+ * @param config - Optional message override (used for the ordering error) and `when` condition.
+ * @returns void
+ * @example
+ * const f = form(this.model, p => { dateRange(p.sentFrom, p.sentTo); });
+ */
+function dateRange(from, to, config) {
+    date(from, config);
+    date(to, config);
+    /**
+     * Compares the two ends of the range once both of them are filled in.
+     * @param startValue - Raw value of the start field.
+     * @param endValue   - Raw value of the end field.
+     * @returns The ordering error, or `null` when the pair is acceptable.
+     */
+    const checkOrder = (startValue, endValue) => {
+        const start = SystemUtils.parseDate(startValue ?? undefined);
+        const end = SystemUtils.parseDate(endValue ?? undefined);
+        // A half-open range is legitimate: nothing to compare until both ends are there. An end that
+        // is not a valid date is already reported by the `date` rule bound above, so it is skipped
+        // here rather than reported twice.
+        if (!start || !end)
+            return null;
+        if (start.getFullYear() < MIN_VALID_YEAR || end.getFullYear() < MIN_VALID_YEAR)
+            return null;
+        return endOfDay(start) <= endOfDay(end)
+            ? null
+            : { kind: 'dateRange', message: config?.message ?? ARS_VALIDATOR_MESSAGES['dateRange'] };
+    };
+    // Reading the opposite end through `valueOf` keeps each rule reactive on the other field, so
+    // filling in one end re-validates the other.
+    validate(from, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        return checkOrder(ctx.value(), ctx.valueOf(to));
+    });
+    validate(to, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        return checkOrder(ctx.valueOf(from), ctx.value());
+    });
+}
+/**
+ * Requires the value to be a date that is not in the future.
+ *
+ * The signal-form counterpart of `NotFutureValidatorDirective`. Today counts as valid: the
+ * comparison is made on the end of the day, so a date entered this morning does not become
+ * invalid because the clock says 09:00.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function notFuture(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input || input.length === 0)
+            return null;
+        const parsed = SystemUtils.parseDate(input);
+        const invalid = { kind: 'notFuture', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notFuture'] };
+        if (!parsed)
+            return invalid;
+        return endOfDay(parsed) <= endOfDay(new Date()) ? null : invalid;
+    });
+}
+/**
+ * Requires the value to be a well-formed URL. An empty value passes, as everywhere else here.
+ *
+ * The signal-form counterpart of `UrlValidatorDirective`.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function url(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input || input.length === 0)
+            return null;
+        return SystemUtils.parseUrl(input)
+            ? null
+            : { kind: 'url', message: config?.message ?? ARS_VALIDATOR_MESSAGES['url'] };
+    });
+}
+/**
+ * Requires the value to hold no more than `max` whitespace-separated terms.
+ *
+ * The signal-form counterpart of `MaxTermsValidatorDirective`, used on the search boxes where
+ * the backend refuses a query past a certain number of words.
+ *
+ * @param path   - Path of the field to validate.
+ * @param max    - The maximum number of terms, as a number or a reactive function.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function maxTerms(path, max, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input)
+            return null;
+        const terms = input.match(/\S+/g)?.length ?? 0;
+        return terms <= (typeof max === 'function' ? max() : max)
+            ? null
+            : { kind: 'maxTerms', message: config?.message ?? ARS_VALIDATOR_MESSAGES['maxTerms'] };
+    });
+}
+/**
+ * Requires the size of the picked file to fall within the allowed range.
+ *
+ * The signal-form counterpart of `FileSizeValidatorDirective`, and it keeps its shape: the field
+ * itself holds the file NAME, while the size arrives from outside — the control that picked the
+ * file knows it, the form does not. An empty field passes, so "no file" is `required()`'s call
+ * and not a size error.
+ *
+ * @param path      - Path of the field holding the file name.
+ * @param sizeMb    - The size of the picked file in megabytes, as a reactive function.
+ * @param maxSizeMb - The maximum allowed size in megabytes. Defaults to `5`.
+ * @param minSizeMb - The minimum required size in megabytes. Defaults to `0`.
+ * @param config    - Optional message override and `when` condition.
+ * @returns void
+ */
+function fileSize(path, sizeMb, maxSizeMb = 5, minSizeMb = 0, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        if (!ctx.value())
+            return null;
+        const size = sizeMb() ?? 0;
+        const max = typeof maxSizeMb === 'function' ? maxSizeMb() : maxSizeMb;
+        const min = typeof minSizeMb === 'function' ? minSizeMb() : minSizeMb;
+        return size <= max && size >= min
+            ? null
+            : { kind: 'fileSize', message: config?.message ?? ARS_VALIDATOR_MESSAGES['fileSize'] };
+    });
+}
+/**
+ * Requires the value to declare itself valid.
+ *
+ * The signal-form counterpart of `ValidIfDirective`: when the field holds an object implementing
+ * `Validated` the verdict is its own `isValid()`, and when the field is empty the verdict is the
+ * `flag`. It is the escape hatch for the composite controls whose validity only they can judge.
+ *
+ * @param path   - Path of the field to validate.
+ * @param flag   - Verdict used while the field is empty, as a boolean or a reactive function.
+ *                 Defaults to `false`.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function validIf(path, flag = false, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const value = ctx.value();
+        let isValid;
+        if (!value) {
+            isValid = (typeof flag === 'function' ? flag() : flag) === true;
+        }
+        else {
+            try {
+                isValid = value.isValid?.() === true;
+            }
+            catch {
+                isValid = false;
+            }
+        }
+        return isValid ? null : { kind: 'validIf', message: config?.message ?? ARS_VALIDATOR_MESSAGES['validIf'] };
+    });
+}
+/**
+ * Requires the value to be a semicolon-separated list of valid e-mail addresses.
+ *
+ * The signal-form counterpart of `EmailsValidatorDirective`. An empty value passes, and so does
+ * an empty entry between two semicolons: the list is typed by hand and a trailing `;` is not a
+ * mistake worth an error.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function emails(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input || input.length === 0)
+            return null;
+        const parts = input.replaceAll(/\r\n/g, '').split(';');
+        const isValid = parts.every(part => part.length === 0 || !!SystemUtils.parseEmail(part));
+        return isValid ? null : { kind: 'emails', message: config?.message ?? ARS_VALIDATOR_MESSAGES['emails'] };
+    });
+}
+/**
+ * Requires the value to be a `"HH:MM"` time and, when slots are given, to fall inside one of them.
+ *
+ * The signal-form counterpart of `TimeValidatorDirective`. An empty value passes.
+ *
+ * @param path   - Path of the field to validate.
+ * @param slots  - Optional reactive function returning the pipe-separated allowed ranges
+ *                 (e.g. `"08:00-12:00|14:00-18:00"`), or `undefined` for no restriction.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function time(path, slots, config) {
+    /**
+     * Turns `"HH:MM"` into a comparable integer (`"09:30"` -> `930`).
+     * @param value - The time string to parse.
+     * @returns The comparable integer, or `-1` when the string is not a valid time.
+     */
+    const getTime = (value) => {
+        const p = value.split(':');
+        if (p.length !== 2)
+            return -1;
+        const hh = parseInt(p[0], 10);
+        if (isNaN(hh) || hh < 0 || hh > 23)
+            return -1;
+        const mm = parseInt(p[1], 10);
+        if (isNaN(mm) || mm < 0 || mm > 59)
+            return -1;
+        return hh * 100 + mm;
+    };
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value();
+        if (!input || input.length === 0)
+            return null;
+        const invalid = { kind: 'time', message: config?.message ?? ARS_VALIDATOR_MESSAGES['time'] };
+        const t = getTime(input);
+        if (t === -1)
+            return invalid;
+        const slotsValue = slots?.();
+        if (slotsValue) {
+            const inSlot = slotsValue.split('|').some(s => {
+                const from = getTime(s.substring(0, 5));
+                const to = getTime(s.substring(6));
+                return from !== -1 && to !== -1 && from <= t && to >= t;
+            });
+            if (!inSlot)
+                return invalid;
+        }
+        return null;
+    });
+}
+/**
+ * Requires the value to equal the value of another field of the same form.
+ *
+ * The signal-form counterpart of `EqualsValidatorDirective`. Reactive on both fields, which is
+ * what the directive needed a `valueChanges` subscription to obtain: retyping the first password
+ * re-validates the confirmation without anyone wiring the two together.
+ *
+ * @param path   - Path of the field to validate.
+ * @param other  - Path of the field whose value must match.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function equals(path, other, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        return ctx.valueOf(other) === ctx.value()
+            ? null
+            : { kind: 'equals', message: config?.message ?? ARS_VALIDATOR_MESSAGES['equals'] };
+    });
+}
+/**
+ * Requires the value to be either empty or a complete six-digit one-time code.
+ *
+ * The schema-level counterpart of the validator inside `OtpInputComponent`: a partial code is an
+ * error, an empty one is `required()`'s business.
+ *
+ * @param path   - Path of the field to validate.
+ * @param config - Optional message override and `when` condition.
+ * @returns void
+ */
+function otp(path, config) {
+    validate(path, ctx => {
+        if (config?.when && !config.when(ctx))
+            return null;
+        const input = ctx.value() ?? '';
+        if (input.length === 0)
+            return null;
+        return /^\d{6}$/.test(input)
+            ? null
+            : { kind: 'otp', message: config?.message ?? ARS_VALIDATOR_MESSAGES['otp'] };
     });
 }
+/** Helpers around signal forms that are not validators themselves. */
+class SignalsUtils {
+    /**
+     * Builds the error text for a signal-forms field.
+     *
+     * Deliberately dumb: the wording lives in the schema, next to the rule that produces it
+     * (`required(p.x, { message: ... })`), so a field says what is wrong with it in one place
+     * instead of here in a switch that has to guess from the error kind. The map below is only
+     * the safety net for the rules declared without a message — the Angular built-ins, plus
+     * {@link ARS_VALIDATOR_MESSAGES} for the ones declared in this file.
+     * @param errors  - The errors currently on the field, from `f.x().errors()`.
+     * @param message - Optional override applied to every error of the field.
+     * @returns The first relevant error text, or `undefined` when the field has no errors.
+     */
+    static getFieldErrorMessage(errors, message) {
+        if (!errors || errors.length === 0)
+            return undefined;
+        const fallback = {
+            // Angular built-ins declared without a message of their own.
+            required: 'Obbligatorio',
+            min: 'Valore troppo basso',
+            max: 'Valore troppo alto',
+            minLength: 'Testo troppo corto',
+            maxLength: 'Testo troppo lungo',
+            pattern: 'Formato non valido',
+            email: 'Indirizzo email non valido',
+            minDate: 'Data troppo indietro',
+            maxDate: 'Data troppo avanti',
+            parse: 'Valore non valido',
+            // Material's own date/time controls. They validate through NG_VALIDATORS, which the
+            // `[formField]` directive honours on a ControlValueAccessor host, and the interop turns
+            // each legacy key into a `CompatValidationError` carrying the key as `kind` and NO
+            // message — so without these entries an unparseable date reads "Non valido", and the
+            // message declared on the schema rule never gets a say because the parse error comes
+            // first and the field value is `null` (which every rule here treats as empty).
+            matDatepickerParse: 'Data non valida',
+            matDatepickerMin: 'Data troppo indietro',
+            matDatepickerMax: 'Data troppo avanti',
+            matDatepickerFilter: 'Data non selezionabile',
+            matStartDateInvalid: 'Intervallo non valido',
+            matEndDateInvalid: 'Intervallo non valido',
+            matTimepickerParse: 'Orario non valido',
+            matTimepickerMin: 'Orario troppo presto',
+            matTimepickerMax: 'Orario troppo tardi',
+            // The rules of this file, from the single table above: adding a validator there is enough,
+            // and this map can never fall behind it.
+            ...ARS_VALIDATOR_MESSAGES,
+        };
+        message = message ?? errors[0].message ?? fallback[errors[0].kind] ?? '';
+        return message.length > 0 ? message : 'Non valido';
+    }
+}
 
 /*
  * Public API Surface of @arsedizioni/ars-utils/core.validators
@@ -902,5 +1261,5 @@ function notEmpty(path, config) {
  * Generated bundle index. Do not edit.
  */
 
-export { EmailsValidatorDirective, EqualsValidatorDirective, FileSizeValidatorDirective, GuidValidatorDirective, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, SqlDateValidatorDirective, TimeValidatorDirective, UrlValidatorDirective, ValidIfDirective, ValidatorDirective, emailsValidator, equalsValidator, guid, notEmpty, otpValidator, password, passwordValidator, timeValidator };
+export { ARS_VALIDATOR_MESSAGES, EmailsValidatorDirective, EqualsValidatorDirective, FileSizeValidatorDirective, GuidValidatorDirective, MIN_VALID_YEAR, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, SignalsUtils, SqlDateValidatorDirective, TimeValidatorDirective, UrlValidatorDirective, ValidIfDirective, ValidatorDirective, date, dateRange, emails, equals, fileSize, guid, maxTerms, notEmpty, notEqual, notFuture, otp, password, sqlDate, time, url, validIf };
 //# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map