@arsedizioni/ars-utils 22.5.46 → 22.5.48

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

@@ -3,7 +3,7 @@ import { input, Directive, forwardRef, effect, inject, DestroyRef } from '@angul
 import { NG_VALIDATORS } from '@angular/forms';
 import { SystemUtils } from '@arsedizioni/ars-utils/core';
 import { endOfDay } from 'date-fns';
-import { validate, required } from '@angular/forms/signals';
+import { validate } from '@angular/forms/signals';
 
 /**
  * Directive that delegates validation to an externally provided validator function.
@@ -664,37 +664,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImpor
 /**
  * @file emptiness.ts
  *
- * The single definition of "empty" shared by the `notEmpty` / `requiredNotEmpty` rules, in both
- * their flavours: the template-driven directives and the signal-form validators. It lives apart
- * from either of them so that the two faces of the same rule cannot drift, and it pulls in
- * nothing — not `@angular/forms`, not `@angular/core`.
+ * The single definition of "empty" behind the `notEmpty` rule, in both its flavours: the
+ * template-driven directive and the signal-form validator. It lives apart from either of them so
+ * that the two faces of the same rule cannot drift, and it pulls in nothing — not
+ * `@angular/forms`, not `@angular/core`.
  */
-/**
- * Tells whether a value carries nothing at all.
- *
- * Nullish, the empty string and the empty array all count as missing; anything else does not,
- * including `0` and `false`, which are legitimate values a form can hold.
- *
- * @param value - The value to inspect.
- * @returns `true` when the value is absent, an empty string or an empty array.
- */
-function isMissingValue(value) {
-    if (value === undefined || value === null)
-        return true;
-    if (typeof value === 'string')
-        return value.length === 0;
-    if (Array.isArray(value))
-        return value.length === 0;
-    return false;
-}
 /**
  * Tells whether a value is what the `notEmpty` rule rejects: a string made of whitespace alone,
  * or an array with no elements.
  *
  * An absent value and an empty string are deliberately NOT rejected: declaring a field mandatory
- * is the job of `required()` (or of `requiredNotEmpty`), and a blank field would otherwise raise
- * two errors saying the same thing. The empty array is the one exception, because there it IS the
- * only shape emptiness can take — a multi-select never holds `''`.
+ * is the job of `required()`, and a blank field would otherwise raise two errors saying the same
+ * thing. The empty array is the one exception, because there it IS the only shape emptiness can
+ * take — a multi-select never holds `''`, and Angular's own `required()` does not see `[]` as
+ * empty, so nothing else would catch it.
  *
  * @param value - The value to inspect.
  * @returns `true` when the value is a whitespace-only string or an empty array.
@@ -712,8 +695,8 @@ function isBlankValue(value) {
  * nor an empty array. Apply `notEmpty` to a text input where non-blank content is required, or
  * to a multi-value control that must carry at least one entry.
  *
- * A value that is simply absent passes: saying "obbligatorio" is the job of `required`, or of
- * `requiredNotEmpty` when both rules belong on the same control.
+ * A value that is simply absent passes: saying "obbligatorio" is the job of `required`, which is
+ * declared next to this one when both rules belong on the same control.
  */
 class NotEmptyValidatorDirective {
     /**
@@ -749,63 +732,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImpor
                 }]
         }] });
 
-/**
- * Directive that validates that a control carries actual content: present AND not blank.
- * Apply `requiredNotEmpty` where `required notEmpty` would otherwise be spelled out together.
- *
- * It raises the very errors those two rules raise — `required` when the value is missing, an
- * empty string or an empty array, `notEmpty` when a value is there but made of whitespace alone —
- * so existing error messages and `getFieldErrorMessage` keep working untouched, and the user
- * still reads "Obbligatorio" rather than the vaguer "Non può essere vuoto".
- *
- * IMPORTANT, on a Material field: this directive does NOT draw the asterisk. `MatInput` reads its
- * own `required` input first and falls back to `hasValidator(Validators.required)`, which no
- * directive-provided validator can satisfy — the validators of a template-driven control are
- * merged into one composed function before they get there. Keep writing `required` on the
- * control next to this one: the two produce the same `{ required: true }` key, so the errors
- * merge and nothing is reported twice.
- *
- * `aria-required` is set here so that assistive technology is told the truth even where the
- * `required` attribute is absent.
- */
-class RequiredNotEmptyValidatorDirective {
-    /**
-     * Validates that the control value is present and carries content.
-     * @param control - The form control to validate.
-     * @returns `{ required: true }` when nothing was entered, `{ notEmpty: true }` when the value
-     *          is blank, `null` when the value is acceptable.
-     */
-    validate(control) {
-        const input = control?.value;
-        if (isMissingValue(input))
-            return { required: true };
-        return isBlankValue(input) ? { notEmpty: true } : null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: RequiredNotEmptyValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.4", type: RequiredNotEmptyValidatorDirective, isStandalone: true, selector: "[requiredNotEmpty]", host: { properties: { "attr.aria-required": "true" } }, providers: [
-            {
-                provide: NG_VALIDATORS,
-                useExisting: forwardRef(() => RequiredNotEmptyValidatorDirective),
-                multi: true,
-            },
-        ], ngImport: i0 }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImport: i0, type: RequiredNotEmptyValidatorDirective, decorators: [{
-            type: Directive,
-            args: [{
-                    selector: "[requiredNotEmpty]",
-                    host: { '[attr.aria-required]': 'true' },
-                    providers: [
-                        {
-                            provide: NG_VALIDATORS,
-                            useExisting: forwardRef(() => RequiredNotEmptyValidatorDirective),
-                            multi: true,
-                        },
-                    ],
-                    standalone: true,
-                }]
-        }] });
-
 /**
  * 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
@@ -822,8 +748,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.4", ngImpor
  */
 const MIN_VALID_YEAR = 1970;
 const ARS_VALIDATOR_MESSAGES = {
-    // Produced by the Angular built-in `required()` and by {@link requiredNotEmpty}. It sits here,
-    // and no longer among the built-in fallbacks below, so that the text exists exactly once.
     required: 'Obbligatorio',
     guid: 'Ticket non riconosciuto',
     password: 'Password non sufficientemente robusta',
@@ -893,12 +817,16 @@ function password(path, config) {
  * The signal-form counterpart of `NotEmptyValidatorDirective`, sharing its predicate through
  * {@link isBlankValue}: a blank string and an empty array are errors, an absent value is not.
  * That last part is not an oversight — saying "obbligatorio" belongs to `required()`, and a field
- * that is merely blank would otherwise raise two errors that mean the same thing. Pair the two,
- * or reach for {@link requiredNotEmpty}, when a field must be both present and non-blank.
+ * that is merely blank would otherwise raise two errors that mean the same thing. Declare the two
+ * together when a field must be both present and non-blank.
  *
  * Replaces the `pattern(p.x, /\S/)` workaround: same rule, but the intent is in the name and the
  * error kind is `notEmpty` rather than `pattern`.
  *
+ * On a multi-value field this rule is the ONLY one that sees an empty selection: Angular's
+ * `required()` treats emptiness as `'' | false | null | undefined`, so an empty array walks past
+ * it. Give it a message of its own there, because the default one talks about whitespace.
+ *
  * @param path   - Path of the field to validate.
  * @param config - Optional message override.
  * @returns void
@@ -916,55 +844,6 @@ function notEmpty(path, config) {
             : null;
     });
 }
-/**
- * Requires the value to be both present and made of something: the two rules a mandatory text
- * field almost always needs together, declared once.
- *
- * The signal-form counterpart of `RequiredNotEmptyValidatorDirective`. It raises the errors the
- * two rules raise on their own rather than a kind of its own — `required` when nothing was
- * entered, `notEmpty` when a value is there but blank — so the message stays as precise as it was
- * and nothing downstream needs to learn a new kind.
- *
- * The presence half is DELEGATED to Angular's own `required()` and is not reimplemented here.
- * That call does more than validate: it writes the `REQUIRED` metadata on the field, and that
- * metadata is the only thing the Material compatibility layer looks at when it answers
- * `hasValidator(Validators.required)` through `field().required()`. A plain `validate()` would
- * reject the empty value just the same and silently drop the asterisk from the label.
- *
- * The empty array is the one case handled here rather than there: Angular's emptiness check is
- * `value === '' || value === false || value == null`, so an empty array walks straight past
- * `required()`. It is reported with the `required` kind all the same, because for a multi-value
- * field "nothing selected" is exactly what the user needs to be told.
- *
- * @param path   - Path of the field to validate.
- * @param config - Optional message override, applied to whichever of the two errors is raised,
- *                 and `when` condition, honoured by both halves of the rule.
- * @returns void
- * @example
- * const f = form(this.model, p => { requiredNotEmpty(p.city); });
- */
-function requiredNotEmpty(path, config) {
-    required(path, {
-        message: config?.message ?? ARS_VALIDATOR_MESSAGES['required'],
-        when: config?.when,
-    });
-    validate(path, ctx => {
-        if (config?.when && !config.when(ctx))
-            return null;
-        const input = ctx.value();
-        // The empty array, which `required()` above does not see.
-        if (Array.isArray(input) && input.length === 0) {
-            return { kind: 'required', message: config?.message ?? ARS_VALIDATOR_MESSAGES['required'] };
-        }
-        // Nullish and the empty string have already been reported by `required()`: saying it twice
-        // would put two errors on one empty field, which is what this rule exists to avoid.
-        if (isMissingValue(input))
-            return null;
-        return isBlankValue(input)
-            ? { kind: 'notEmpty', message: config?.message ?? ARS_VALIDATOR_MESSAGES['notEmpty'] }
-            : null;
-    });
-}
 /**
  * Requires the value to differ from the value of another field of the same form.
  *
@@ -1411,5 +1290,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, RequiredNotEmptyValidatorDirective, SignalsUtils, SqlDateValidatorDirective, TimeValidatorDirective, UrlValidatorDirective, ValidIfDirective, ValidatorDirective, date, dateRange, emails, equals, fileSize, guid, maxTerms, notEmpty, notEqual, notFuture, otp, password, requiredNotEmpty, 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, maxTerms, notEmpty, notEqual, notFuture, otp, password, sqlDate, time, url, validIf };
 //# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map