@arsedizioni/ars-utils 22.5.6 → 22.5.7

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

@@ -0,0 +1,717 @@
+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';
+
+/**
+ * Directive that delegates validation to an externally provided validator function.
+ * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
+ */
+class ValidatorDirective {
+    constructor() {
+        /** The custom validator function to apply. */
+        this.validator = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Invokes the provided validator function against the given control.
+     * Returns `null` (valid) when no function is bound.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const fn = this.validator();
+        return fn ? fn(control) : null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: ValidatorDirective, isStandalone: true, selector: "[validator]", inputs: { validator: { classPropertyName: "validator", publicName: "validator", isSignal: true, isRequired: false, transformFunction: null } }, providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[validator]',
+                    providers: [{ provide: NG_VALIDATORS, useExisting: ValidatorDirective, multi: true }],
+                    standalone: true,
+                }]
+        }], propDecorators: { validator: [{ type: i0.Input, args: [{ isSignal: true, alias: "validator", required: false }] }] } });
+
+/**
+ * Directive that validates a control using the host object's `isValid()` method
+ * or a boolean expression passed via `[validIf]`.
+ */
+class ValidIfDirective {
+    constructor() {
+        /** When `true`, the control is considered valid regardless of the bound value. */
+        this.validIf = input(false, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "validIf" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Validates the control value against a boolean flag or the value's own `isValid()` method.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        let isValid = false;
+        const c = control.value ? control.value : null;
+        if (!c) {
+            isValid = this.validIf() === true;
+        }
+        else {
+            try {
+                isValid = c.isValid();
+            }
+            catch { }
+        }
+        return isValid ? null : { validIf: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ValidIfDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: ValidIfDirective, isStandalone: true, selector: "[validIf]", inputs: { validIf: { classPropertyName: "validIf", publicName: "validIf", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => ValidIfDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: ValidIfDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[validIf]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => ValidIfDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { validIf: [{ type: i0.Input, args: [{ isSignal: true, alias: "validIf", required: false }] }] } });
+
+/**
+ * Directive that validates that the host control's value equals the value of another control.
+ * Bind `[equals]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes:
+ * without this, typing a new password AFTER the confirmation field was filled
+ * left the form incorrectly valid (the classic password/confirm bug).
+ *
+ * IMPORTANT (reciprocal-binding safety): the re-validation triggered from the
+ * other control's `valueChanges` runs with `{ emitEvent: false }`. Calling
+ * Angular's `onValidatorChange` instead would re-emit valueChanges, so a
+ * reciprocal setup (A [equals]=B and B [equals]=A) would overflow the stack.
+ */
+class EqualsValidatorDirective {
+    constructor() {
+        /** The control whose value must match the host control's value. */
+        this.equals = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []));
+        // Re-subscribe whenever the [equals] binding points to a different control,
+        // and re-validate the host on every change of the other control.
+        effect(() => {
+            const other = this.equals();
+            this.subscription?.unsubscribe();
+            this.subscription = other?.valueChanges.subscribe(() => 
+            // emitEvent:false breaks the reciprocal valueChanges loop (see class doc).
+            this.hostControl?.updateValueAndValidity({ emitEvent: false }));
+            // Re-validate the host when the bound control itself is swapped.
+            this.hostControl?.updateValueAndValidity({ emitEvent: false });
+        });
+        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+    }
+    /**
+     * Validates that the host control value equals the bound control's value.
+     * Returns `null` (valid) when no control is bound.
+     * @param control - The form control to validate.
+     * @returns `null` when valid, `{ equals: ... }` otherwise.
+     */
+    validate(control) {
+        this.hostControl = control;
+        const eq = this.equals();
+        if (!eq)
+            return null;
+        return eq.value === control.value ? null : { equals: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: EqualsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: EqualsValidatorDirective, isStandalone: true, selector: "[equals]", inputs: { equals: { classPropertyName: "equals", publicName: "equals", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => EqualsValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: EqualsValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[equals]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => EqualsValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { equals: [{ type: i0.Input, args: [{ isSignal: true, alias: "equals", required: false }] }] } });
+
+/**
+ * Directive that validates that the host control's value is different from another control's value.
+ * Bind `[notEqual]="otherControl"`.
+ *
+ * The host control is re-validated whenever the OTHER control's value changes,
+ * so editing either field keeps both error states consistent.
+ *
+ * IMPORTANT (reciprocal-binding safety): the re-validation triggered from the
+ * other control's `valueChanges` is run with `{ emitEvent: false }`. Using
+ * Angular's `onValidatorChange` here instead would call `host.updateValueAndValidity()`
+ * WITH events, so a reciprocal setup (A [notEqual]=B and B [notEqual]=A) would
+ * ping-pong valueChanges between the two controls and overflow the stack.
+ */
+class NotEqualValidatorDirective {
+    constructor() {
+        /** The control whose value must differ from the host control's value. */
+        this.notEqual = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []));
+        effect(() => {
+            const other = this.notEqual();
+            this.subscription?.unsubscribe();
+            this.subscription = other?.valueChanges.subscribe(() => 
+            // Re-validate the host WITHOUT emitting valueChanges, otherwise a
+            // reciprocal binding would loop forever (see class doc).
+            this.hostControl?.updateValueAndValidity({ emitEvent: false }));
+            // Re-validate the host when the bound control itself is swapped.
+            this.hostControl?.updateValueAndValidity({ emitEvent: false });
+        });
+        inject(DestroyRef).onDestroy(() => this.subscription?.unsubscribe());
+    }
+    /**
+     * Validates that the host control value is not equal to the bound control's value.
+     * Also clears the `notequal` error on the other control when the host becomes valid.
+     * Returns `null` (valid) when no control is bound.
+     * @param control - The form control to validate.
+     * @returns `null` when valid, `{ notequal: true }` otherwise.
+     */
+    validate(control) {
+        this.hostControl = control;
+        const notEqual = this.notEqual();
+        if (!notEqual)
+            return null;
+        const isValid = (!notEqual.value && !control.value) || (notEqual.value !== control.value);
+        const errors = isValid ? null : { notequal: true };
+        if (errors) {
+            control.markAsTouched();
+        }
+        else if (notEqual.hasError('notequal')) {
+            const { notequal: _removed, ...rest } = notEqual.errors ?? {};
+            // emitEvent:false on both: clearing the partner's error must not feed
+            // back through valueChanges/statusChanges into this validator.
+            notEqual.setErrors(Object.keys(rest).length > 0 ? rest : null, { emitEvent: false });
+            notEqual.updateValueAndValidity({ onlySelf: true, emitEvent: false });
+            notEqual.markAsTouched();
+            notEqual.markAsDirty();
+        }
+        return errors;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotEqualValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: NotEqualValidatorDirective, isStandalone: true, selector: "[notEqual]", inputs: { notEqual: { classPropertyName: "notEqual", publicName: "notEqual", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NotEqualValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotEqualValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[notEqual]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NotEqualValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], ctorParameters: () => [], propDecorators: { notEqual: [{ type: i0.Input, args: [{ isSignal: true, alias: "notEqual", required: false }] }] } });
+
+/**
+ * Directive that validates a semicolon-separated list of email addresses.
+ * Apply `emails` to a text input containing one or more addresses separated by `;`.
+ */
+class EmailsValidatorDirective {
+    /**
+     * Validates each address in a semicolon-separated email list.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.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 : { emails: "Elenco non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: EmailsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: EmailsValidatorDirective, isStandalone: true, selector: "[emails]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => EmailsValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: EmailsValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[emails]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => EmailsValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a control value as a GUID / UUID string.
+ * Apply `guid` to a text input that expects a valid UUID.
+ */
+class GuidValidatorDirective {
+    /**
+     * Validates that the control value is a well-formed GUID / UUID.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        return SystemUtils.parseUUID(input) ? null : { guid: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: GuidValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: GuidValidatorDirective, isStandalone: true, selector: "[guid]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => GuidValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: GuidValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[guid]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => GuidValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a control value as a parseable SQL-compatible date string.
+ * Apply `sqlDate` to a text input that expects a date after year 1750.
+ */
+class SqlDateValidatorDirective {
+    /**
+     * Validates that the control value can be parsed as a date after 1750.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        const parsed = SystemUtils.parseDate(input);
+        if (!parsed)
+            return { sqlDate: "Non valido." };
+        const d = endOfDay(parsed);
+        return d.getFullYear() > 1750 ? null : { sqlDate: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: SqlDateValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: SqlDateValidatorDirective, isStandalone: true, selector: "[sqlDate]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => SqlDateValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: SqlDateValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[sqlDate]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => SqlDateValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates that a control value is not a future date.
+ * Apply `notFuture` to a text input that expects a date on or before today.
+ */
+class NotFutureValidatorDirective {
+    /**
+     * Validates that the control value represents a date that is not in the future.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        const parsed = SystemUtils.parseDate(input);
+        if (!parsed)
+            return { notFuture: "Non valido." };
+        const today = endOfDay(new Date());
+        const d = endOfDay(parsed);
+        return d <= today ? null : { notFuture: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotFutureValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: NotFutureValidatorDirective, isStandalone: true, selector: "[notFuture]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NotFutureValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotFutureValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[notFuture]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NotFutureValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a control value as a well-formed URL.
+ * Apply `url` to a text input that expects a URL.
+ */
+class UrlValidatorDirective {
+    /**
+     * Validates that the control value is a well-formed URL.
+     * Returns `null` (valid) when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        return SystemUtils.parseUrl(input) ? null : { url: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: UrlValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: UrlValidatorDirective, isStandalone: true, selector: "[url]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => UrlValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: UrlValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[url]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => UrlValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a file size against configurable minimum and maximum bounds.
+ * Bind `[fileSize]` together with `[size]="fileSizeInMb"`, `[maxSizeMb]`, and `[minSizeMb]`.
+ */
+class FileSizeValidatorDirective {
+    constructor() {
+        /** Maximum allowed file size in megabytes. Defaults to 5. */
+        this.maxSizeMb = input(5, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "maxSizeMb" }] : /* istanbul ignore next */ []));
+        /** Minimum required file size in megabytes. Defaults to 0. */
+        this.minSizeMb = input(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "minSizeMb" }] : /* istanbul ignore next */ []));
+        /** The actual file size in megabytes to validate against the bounds. */
+        this.size = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "size" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Validates that the bound file size falls within the configured min/max range.
+     * Returns `null` when no control value is present.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input)
+            return null;
+        const s = this.size() ?? 0;
+        const isValid = s <= this.maxSizeMb() && s >= this.minSizeMb();
+        return isValid ? null : { fileSize: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: FileSizeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: FileSizeValidatorDirective, isStandalone: true, selector: "[fileSize]", inputs: { maxSizeMb: { classPropertyName: "maxSizeMb", publicName: "maxSizeMb", isSignal: true, isRequired: false, transformFunction: null }, minSizeMb: { classPropertyName: "minSizeMb", publicName: "minSizeMb", isSignal: true, isRequired: false, transformFunction: null }, size: { classPropertyName: "size", publicName: "size", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => FileSizeValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: FileSizeValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[fileSize]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => FileSizeValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { maxSizeMb: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxSizeMb", required: false }] }], minSizeMb: [{ type: i0.Input, args: [{ isSignal: true, alias: "minSizeMb", required: false }] }], size: [{ type: i0.Input, args: [{ isSignal: true, alias: "size", required: false }] }] } });
+
+/**
+ * Directive that validates that a control value does not exceed a maximum word count.
+ * Bind `[maxTerms]="10"` to allow at most 10 whitespace-separated terms.
+ */
+class MaxTermsValidatorDirective {
+    constructor() {
+        /** The maximum number of whitespace-separated terms allowed. */
+        this.maxTerms = input(0, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "maxTerms" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * Validates that the control value contains no more than the configured number of terms.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input)
+            return null;
+        const terms = input.match(/\S+/g)?.length ?? 0;
+        return terms <= this.maxTerms() ? null : { maxTerms: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: MaxTermsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: MaxTermsValidatorDirective, isStandalone: true, selector: "[maxTerms]", inputs: { maxTerms: { classPropertyName: "maxTerms", publicName: "maxTerms", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => MaxTermsValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: MaxTermsValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[maxTerms]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => MaxTermsValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { maxTerms: [{ type: i0.Input, args: [{ isSignal: true, alias: "maxTerms", required: false }] }] } });
+
+/**
+ * Directive that validates a control value as a sufficiently strong password.
+ * Apply `password` to a password input.
+ */
+class PasswordValidatorDirective {
+    /**
+     * Validates that the control value meets the minimum password-strength requirements.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value ?? '';
+        const strength = SystemUtils.calculatePasswordStrength(input);
+        return strength.isValid ? null : { password: "Non valido." };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: PasswordValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: PasswordValidatorDirective, isStandalone: true, selector: "[password]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => PasswordValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: PasswordValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[password]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => PasswordValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/**
+ * Directive that validates a time string against optional allowed time slot ranges.
+ * Bind `[time]` and optionally `[slots]="'08:00-12:00|14:00-18:00'"` (pipe-separated ranges).
+ */
+class TimeValidatorDirective {
+    constructor() {
+        /** Optional pipe-separated list of allowed time ranges, e.g. `"08:00-12:00|14:00-18:00"`. */
+        this.slots = input(undefined, /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []));
+    }
+    /**
+     * 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.
+     */
+    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;
+    }
+    /**
+     * Validates that the control value is a valid time string and, when slots are configured,
+     * that it falls within at least one of the allowed ranges.
+     * Returns `null` when the control is empty.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control.value;
+        if (!input || input.length === 0)
+            return null;
+        const t = this.getTime(input);
+        if (t === -1)
+            return { time: "Non valido." };
+        const slotsValue = this.slots();
+        if (slotsValue) {
+            const isValid = slotsValue.split('|').some(s => {
+                const t1 = this.getTime(s.substring(0, 5));
+                const t2 = this.getTime(s.substring(6));
+                return t1 !== -1 && t2 !== -1 && t1 <= t && t2 >= t;
+            });
+            return isValid ? null : { time: "Non valido." };
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: TimeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.1.3", type: TimeValidatorDirective, isStandalone: true, selector: "[time]", inputs: { slots: { classPropertyName: "slots", publicName: "slots", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => TimeValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: TimeValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[time]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => TimeValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }], propDecorators: { slots: [{ type: i0.Input, args: [{ isSignal: true, alias: "slots", required: false }] }] } });
+
+/**
+ * Directive that validates that a string control value is not blank (whitespace-only).
+ * Apply `notEmpty` to a text input where non-blank content is required.
+ */
+class NotEmptyValidatorDirective {
+    /**
+     * Validates that the control value is a non-blank string.
+     * Returns `null` when the control is empty or not a string.
+     * @param control - The form control to validate.
+     */
+    validate(control) {
+        const input = control?.value;
+        if (!input || typeof input !== 'string' || input.length === 0)
+            return null;
+        return input.trim().length > 0 ? null : { notEmpty: true };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotEmptyValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "22.1.3", type: NotEmptyValidatorDirective, isStandalone: true, selector: "[notEmpty]", providers: [
+            {
+                provide: NG_VALIDATORS,
+                useExisting: forwardRef(() => NotEmptyValidatorDirective),
+                multi: true,
+            },
+        ], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: NotEmptyValidatorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[notEmpty]",
+                    providers: [
+                        {
+                            provide: NG_VALIDATORS,
+                            useExisting: forwardRef(() => NotEmptyValidatorDirective),
+                            multi: true,
+                        },
+                    ],
+                    standalone: true,
+                }]
+        }] });
+
+/*
+ * Public API Surface of @arsedizioni/ars-utils/core.validators
+ *
+ * Template-driven form validators. Kept OUT of `core` on purpose: every one of them pulls in
+ * `@angular/forms` (53 KB), and `core` is on the boot path of every application through
+ * `ThemeService`, `BroadcastService` and friends. Importing a validator now costs `@angular/forms`
+ * only to the lazy chunk that actually uses one.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EmailsValidatorDirective, EqualsValidatorDirective, FileSizeValidatorDirective, GuidValidatorDirective, MaxTermsValidatorDirective, NotEmptyValidatorDirective, NotEqualValidatorDirective, NotFutureValidatorDirective, PasswordValidatorDirective, SqlDateValidatorDirective, TimeValidatorDirective, UrlValidatorDirective, ValidIfDirective, ValidatorDirective };
+//# sourceMappingURL=arsedizioni-ars-utils-core.validators.mjs.map