@arsedizioni/ars-utils 22.5.72 → 22.6.75

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

@@ -2,7 +2,7 @@ import * as i0 from '@angular/core';
 import { input, Directive, forwardRef, effect, inject, DestroyRef } from '@angular/core';
 import { NG_VALIDATORS } from '@angular/forms';
 import { SystemUtils } from '@arsedizioni/ars-utils/core';
-import { endOfDay } from 'date-fns';
+import { endOfDay, startOfDay } from 'date-fns';
 import { validate } from '@angular/forms/signals';
 
 /**
@@ -732,6 +732,155 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.6", ngImpor
                 }]
         }] });
 
+/**
+ * @file italian.ts
+ *
+ * The two check algorithms behind the `italianVat` and `italianFiscalCode` rules, kept apart from
+ * the validators that use them for the same reason `emptiness.ts` is: the rule must exist in one
+ * place only, so that no second copy of it can drift. They pull in nothing — not `@angular/forms`,
+ * not `@angular/core` — and they live here rather than in `SystemUtils` so that `core`, which sits
+ * on the boot path of every application, does not carry code only a form needs.
+ */
+/**
+ * Digits an "omocodia" substitution replaces with a letter, in digit order: `0` becomes `L`, `1`
+ * becomes `M`, and so on.
+ *
+ * The Agenzia delle Entrate applies it when two people would otherwise share the same fiscal code,
+ * so a perfectly legitimate code can carry letters where the format expects numbers. Ignoring this
+ * is the classic way a validator rejects a real person.
+ */
+const OMOCODIA_CHARS = 'LMNPQRSTUV';
+/** Letters usable as month of birth, one per month from January (`A`) to December (`T`). */
+const MONTH_CHARS = 'ABCDEHLMPRST';
+/** Alphabet the control character of a fiscal code is drawn from. */
+const CONTROL_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+/** Weight of each character sitting in an ODD position (1-based) of the first 15 of a fiscal code. */
+const ODD_WEIGHTS = {
+    '0': 1, '1': 0, '2': 5, '3': 7, '4': 9, '5': 13, '6': 15, '7': 17, '8': 19, '9': 21,
+    A: 1, B: 0, C: 5, D: 7, E: 9, F: 13, G: 15, H: 17, I: 19, J: 21, K: 2, L: 4, M: 18,
+    N: 20, O: 11, P: 3, Q: 6, R: 8, S: 12, T: 14, U: 16, V: 10, W: 22, X: 25, Y: 24, Z: 23,
+};
+/** Weight of each character sitting in an EVEN position (1-based) of the first 15 of a fiscal code. */
+const EVEN_WEIGHTS = {
+    '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9,
+    A: 0, B: 1, C: 2, D: 3, E: 4, F: 5, G: 6, H: 7, I: 8, J: 9, K: 10, L: 11, M: 12,
+    N: 13, O: 14, P: 15, Q: 16, R: 17, S: 18, T: 19, U: 20, V: 21, W: 22, X: 23, Y: 24, Z: 25,
+};
+/**
+ * Shape of a fiscal code of a natural person, omocodia included: every group that is normally
+ * numeric also admits the ten letters that stand in for a digit.
+ */
+const FISCAL_CODE_REGEX = /^[A-Z]{6}[0-9LMNPQRSTUV]{2}[ABCDEHLMPRST][0-9LMNPQRSTUV]{2}[A-Z][0-9LMNPQRSTUV]{3}[A-Z]$/;
+/**
+ * Strips what a user types around a code without changing the code itself: surrounding and inner
+ * spaces, dots and dashes, and the letter case.
+ *
+ * Accepting a pasted `"IT 123 456 789 01"` is not indulgence — the value arrives from an invoice,
+ * a registry export or a colleague's e-mail far more often than it is typed character by
+ * character, and rejecting it teaches nothing to the person who pasted it.
+ *
+ * @param value - The raw value as the user entered it.
+ * @returns The value in upper case with spaces, dots and dashes removed.
+ */
+function normalize(value) {
+    return (value ?? '').toUpperCase().replace(/[\s.\-/]/g, '');
+}
+/**
+ * Turns the letters an omocodia substitution left behind back into the digits they stand for.
+ *
+ * @param value - A group of characters of a fiscal code that is numeric in the plain form.
+ * @returns The same group with every substitution letter replaced by its digit.
+ */
+function decodeOmocodia(value) {
+    let decoded = '';
+    for (const char of value) {
+        const index = OMOCODIA_CHARS.indexOf(char);
+        decoded += index === -1 ? char : String(index);
+    }
+    return decoded;
+}
+/**
+ * Tells whether a value is a valid Italian VAT number (partita IVA).
+ *
+ * Eleven digits, of which the last one is the check digit of the Luhn-like algorithm of
+ * D.P.R. 633/72: the digits in even position (1-based) are doubled and folded back under ten, the
+ * sum is completed to the next multiple of ten, and what is missing is the check digit. An
+ * optional `IT` prefix is accepted, because that is how the number travels on invoices and in
+ * VIES exports.
+ *
+ * The seven digits of the sequential number are required not to be all zeros, which is the one
+ * combination the checksum happily accepts and the Agenzia delle Entrate never issues. The office
+ * code (positions 8 to 10) is deliberately NOT checked against the list of the provinces: that
+ * list grows, and a validator that rejects a number issued last month is worse than one that lets
+ * a fabricated office code through.
+ *
+ * @param value - The value to check, with or without the `IT` prefix and any spacing.
+ * @returns `true` when the value is a well-formed VAT number.
+ */
+function isValidItalianVat(value) {
+    const normalized = normalize(value);
+    const digits = normalized.startsWith('IT') ? normalized.slice(2) : normalized;
+    if (!/^\d{11}$/.test(digits))
+        return false;
+    if (digits.startsWith('0000000'))
+        return false;
+    let sum = 0;
+    for (let i = 0; i < 10; i++) {
+        let digit = digits.charCodeAt(i) - 48;
+        // Positions are 1-based in the norm, so the doubled ones are those at an even index here.
+        if (i % 2 === 1) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        sum += digit;
+    }
+    const check = (10 - (sum % 10)) % 10;
+    return check === digits.charCodeAt(10) - 48;
+}
+/**
+ * Tells whether a value is a valid Italian fiscal code (codice fiscale), in either of the two
+ * shapes a form can receive.
+ *
+ * A natural person has the sixteen-character code of D.M. 23/12/1976: the shape is checked, the
+ * month letter and the day of birth are checked (41 to 71 for a woman, which is the day plus
+ * forty), and the sixteenth character is recomputed from the first fifteen and compared. Letters
+ * left by an omocodia substitution are accepted and decoded before the date is judged, so a
+ * legitimately altered code is not turned away.
+ *
+ * A company or a public body has no such code: its fiscal code IS its VAT number, eleven digits
+ * checked by {@link isValidItalianVat}. Both are accepted here because a single "codice fiscale"
+ * field in a registry form receives both, and asking the user which kind they are about to type is
+ * a question the code can answer by itself.
+ *
+ * @param value - The value to check, in any case and with any spacing.
+ * @returns `true` when the value is a well-formed fiscal code of either shape.
+ */
+function isValidItalianFiscalCode(value) {
+    const code = normalize(value);
+    // A company or a public body: its fiscal code is the VAT number.
+    if (/^\d{11}$/.test(code))
+        return isValidItalianVat(code);
+    if (code.length !== 16 || !FISCAL_CODE_REGEX.test(code))
+        return false;
+    // The day carries the sex: 01-31 for a man, 41-71 for a woman (the day plus forty).
+    const day = parseInt(decodeOmocodia(code.substring(9, 11)), 10);
+    const isValidDay = (day >= 1 && day <= 31) || (day >= 41 && day <= 71);
+    if (!isValidDay)
+        return false;
+    // The month letter is already constrained by the regex; this keeps the two in step if it changes.
+    if (!MONTH_CHARS.includes(code[8]))
+        return false;
+    let sum = 0;
+    for (let i = 0; i < 15; i++) {
+        // Odd positions in the norm are the even indexes here. The character is weighted as it is
+        // written, substitution letters included: the control character is computed on the altered
+        // code, not on the original one.
+        sum += i % 2 === 0 ? ODD_WEIGHTS[code[i]] : EVEN_WEIGHTS[code[i]];
+    }
+    return CONTROL_CHARS[sum % 26] === code[15];
+}
+
 /**
  * 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
@@ -757,6 +906,7 @@ const ARS_VALIDATOR_MESSAGES = {
     date: 'Data non valida',
     dateRange: 'Intervallo non valido',
     notFuture: 'La data non può essere futura',
+    notPast: 'La data non può essere passata',
     url: 'Indirizzo non valido',
     maxTerms: 'Troppe parole',
     fileSize: 'Dimensione del file non ammessa',
@@ -765,6 +915,8 @@ const ARS_VALIDATOR_MESSAGES = {
     time: 'Orario non valido',
     equals: 'I due valori non coincidono',
     otp: 'Codice non valido',
+    italianVat: 'Partita IVA non valida',
+    italianFiscalCode: 'Codice fiscale non valido',
 };
 /**
  * Requires the value to be a well-formed GUID / UUID.
@@ -1006,6 +1158,38 @@ function notFuture(path, config) {
         return endOfDay(parsed) <= endOfDay(new Date()) ? null : invalid;
     });
 }
+/**
+ * Requires the value to be a date that is not in the past.
+ *
+ * The mirror image of {@link notFuture}, for the fields that can only look forward: an expiry, a
+ * deadline, the date of a course still to be held. Today counts as valid — the comparison is made
+ * on the start of the day, so a date picked this afternoon for today does not become invalid
+ * because the clock has moved on.
+ *
+ * Like {@link date}, and unlike the older {@link notFuture}, it accepts both the `Date` a Material
+ * datepicker writes into the model and the text of a plain input. An empty value passes: saying
+ * "obbligatorio" is the job of `required()`.
+ *
+ * @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.scadenza); notPast(p.scadenza); });
+ */
+function notPast(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);
+        const invalid = { kind: 'notPast', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notPast'] };
+        if (!parsed)
+            return invalid;
+        return startOfDay(parsed) >= startOfDay(new Date()) ? null : invalid;
+    });
+}
 /**
  * Requires the value to be a well-formed URL. An empty value passes, as everywhere else here.
  *
@@ -1231,6 +1415,71 @@ function otp(path, config) {
             : { kind: 'otp', message: config?.message ?? ARS_VALIDATOR_MESSAGES['otp'] };
     });
 }
+/**
+ * Requires the value to be a valid Italian VAT number (partita IVA).
+ *
+ * Eleven digits whose last one is the check digit of D.P.R. 633/72, so a mistyped or invented
+ * number is caught here rather than by the backend that will refuse the invoice. An `IT` prefix
+ * and the spacing of a pasted value are tolerated, because that is the shape the number arrives
+ * in; what is stored is still whatever the user typed, since this rule only judges.
+ *
+ * An empty value passes, as everywhere else here: declaring the field mandatory is `required()`'s
+ * job.
+ *
+ * @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.partitaIva); italianVat(p.partitaIva); });
+ */
+function italianVat(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 isValidItalianVat(input)
+            ? null
+            : { kind: 'italianVat', message: config?.message ?? ARS_VALIDATOR_MESSAGES['italianVat'] };
+    });
+}
+/**
+ * Requires the value to be a valid Italian fiscal code (codice fiscale).
+ *
+ * Both shapes a registry form receives are accepted: the sixteen-character code of a natural
+ * person, control character recomputed and compared, and the eleven digits of a company or a
+ * public body, whose fiscal code IS its VAT number. Nothing has to tell the rule which one is
+ * coming — the value says it by its own length.
+ *
+ * Codes altered by an "omocodia" substitution (digits replaced by letters when two people would
+ * otherwise share a code) are accepted: they are issued by the Agenzia delle Entrate and rejecting
+ * them is the classic way a form turns away a real person.
+ *
+ * An empty value passes. Pair with `required()` when the field is mandatory, and reach for
+ * {@link italianVat} instead on a field that is specifically a VAT number.
+ *
+ * @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.codiceFiscale); italianFiscalCode(p.codiceFiscale); });
+ */
+function italianFiscalCode(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 isValidItalianFiscalCode(input)
+            ? null
+            : {
+                kind: 'italianFiscalCode',
+                message: config?.message ?? ARS_VALIDATOR_MESSAGES['italianFiscalCode'],
+            };
+    });
+}
 /** Helpers around signal forms that are not validators themselves. */
 class SignalsUtils {
     /**
@@ -1290,5 +1539,5 @@ class SignalsUtils {
  * Generated bundle index. Do not edit.
  */
 
-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 };
+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, italianFiscalCode, italianVat, maxTerms, notEmpty, notEqual, notFuture, notPast, otp, password, sqlDate, time, url, validIf };
 //# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map