@arsedizioni/ars-utils 21.2.207 → 21.2.209

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

@@ -1,24 +1,27 @@
 import * as i0 from '@angular/core';
-import { inject, ElementRef, Directive, input, HostListener, output, forwardRef, Pipe, EventEmitter, Injectable, signal, RendererFactory2, computed, NgModule } from '@angular/core';
+import { inject, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, Pipe, EventEmitter, signal, computed, Injectable, RendererFactory2, NgModule } from '@angular/core';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { Subject, BehaviorSubject } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
 import { HttpParams } from '@angular/common/http';
 import { parseISO, parse, format, endOfDay, getYear, getMonth, getDate, getDay, getDaysInMonth, addYears, addMonths, addDays, formatISO, isDate, isValid } from 'date-fns';
 import { it } from 'date-fns/locale';
 import { TZDate } from '@date-fns/tz';
-import { debounceTime } from 'rxjs/operators';
-import { Subject, BehaviorSubject } from 'rxjs';
 import { NG_VALIDATORS } from '@angular/forms';
 import { DomSanitizer } from '@angular/platform-browser';
 import { SelectionModel } from '@angular/cdk/collections';
 import { DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';
 
+/**
+ * Directive that moves browser focus to the host element after the first render cycle.
+ * Apply `autoFocus` to any focusable element to set focus automatically on initialisation.
+ */
 class AutoFocusDirective {
     constructor() {
         this.elementRef = inject(ElementRef);
-    }
-    ngAfterContentInit() {
-        setTimeout(() => {
-            this.elementRef.nativeElement.focus();
-        }, 500);
+        afterNextRender(() => {
+            this.elementRef.nativeElement?.focus();
+        });
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AutoFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: AutoFocusDirective, isStandalone: true, selector: "[autoFocus]", ngImport: i0 }); }
@@ -26,10 +29,10 @@ class AutoFocusDirective {
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: AutoFocusDirective, decorators: [{
             type: Directive,
             args: [{
-                    selector: "[autoFocus]",
+                    selector: '[autoFocus]',
                     standalone: true
                 }]
-        }] });
+        }], ctorParameters: () => [] });
 
 class FileInfo {
     isValid() {
@@ -178,27 +181,25 @@ class SystemUtils {
         return nodes;
     }
     /**
-     * Used to copare items during an array of objects sorting
-     * @param key     : the property name to sort for
-     * @param order   : the order 'asc' or 'desc'
-     * @returns       : 0 if equals, 1 if bigger, -1 if lower
+     * Comparator factory for sorting arrays of objects by a given property key.
+     * @param key   - Name of the property to sort by.
+     * @param order - Sort direction: `'asc'` (default) or `'desc'`.
+     * @returns A comparator function that returns `0`, `1`, or `-1`.
      */
-    static arraySortCompare(key, order = "asc") {
-        const result = function innerSort(a, b) {
-            if (!a.hasOwnProperty(key) || !b.hasOwnProperty(key)) {
-                // property doesn't exist on either object
+    static arraySortCompare(key, order = 'asc') {
+        return function innerSort(a, b) {
+            if (!Object.prototype.hasOwnProperty.call(a, key) || !Object.prototype.hasOwnProperty.call(b, key)) {
                 return 0;
             }
-            const varA = typeof a[key] === "string" ? a[key].toUpperCase() : a[key];
-            const varB = typeof b[key] === "string" ? b[key].toUpperCase() : b[key];
+            const varA = typeof a[key] === 'string' ? a[key].toUpperCase() : a[key];
+            const varB = typeof b[key] === 'string' ? b[key].toUpperCase() : b[key];
             let comparison = 0;
             if (varA > varB)
                 comparison = 1;
             else if (varA < varB)
                 comparison = -1;
-            return order === "desc" ? comparison * -1 : comparison;
+            return order === 'desc' ? comparison * -1 : comparison;
         };
-        return result;
     }
     /**
      * Format weight
@@ -311,21 +312,22 @@ class SystemUtils {
         return items[0];
     }
     /**
-     * Replace stuff in text html
-     * @param s   : the string to process
-     * @returns   : the replaced string
+     * Wraps bare URLs in the given string with `<a>` anchor tags.
+     * @param s - The plain-text or HTML string to process.
+     * @returns The string with URLs replaced by clickable links, or `''` when `s` is falsy.
      */
     static replaceAsHtml(s) {
         if (!s)
             return '';
         const regex = /https?:\/\/.*[^\s]/ig;
         const m = regex.exec(s);
-        if (m && m.length > 0) {
-            for (const v of m) {
-                s = s.replace(v, `<a href="${v}" target="_blank">${v}</a>`);
-            }
+        if (!m || m.length === 0)
+            return s;
+        let result = s;
+        for (const v of m) {
+            result = result.replace(v, `<a href="${v}" target="_blank">${v}</a>`);
         }
-        return s;
+        return result;
     }
     /**
      * Convert markdown to html
@@ -595,16 +597,18 @@ class SystemUtils {
         return JSON.parse(JSON.stringify(obj));
     }
     /**
-     * Clone an object using deep cloning
-     * @param obj   : the oblect to clone
-     * @returns     : a new object
+     * Creates a deep clone of an object by recursively copying all own properties.
+     * @param obj  - The source object to clone.
+     * @param dest - Optional pre-allocated destination object; a new instance is created when omitted.
+     * @returns A deep copy of `obj`.
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static deepClone(obj, dest) {
-        const cloneObj = dest ? dest : obj.constructor();
-        const attributes = Object.keys(obj);
-        for (const attribute of attributes) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const cloneObj = dest ?? obj.constructor();
+        for (const attribute of Object.keys(obj)) {
             const property = obj[attribute];
-            if (typeof property === "object" && property != null) {
+            if (typeof property === 'object' && property !== null) {
                 cloneObj[attribute] = this.deepClone(property);
             }
             else {
@@ -614,22 +618,20 @@ class SystemUtils {
         return cloneObj;
     }
     /**
-     * Check if a string is a valid UUID
-     * @param value   : the value to parse
-     * @returns       : true if is a valid UUID
+     * Returns `true` when `value` is a syntactically valid UUID string.
+     * @param value - The string to validate.
      */
     static parseUUID(value) {
         const regex = /^({|()?[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}(}|))?$/;
-        return value?.length > 0 && regex.test(value);
+        return !!value && value.length > 0 && regex.test(value);
     }
     /**
-     * Parse and ensure that UUID is not empty
-     * @param value   : the value to parse
-     * @returns       : true if valid and not empty
+     * Returns `true` when `value` is a valid, non-empty (non-zero) UUID.
+     * @param value - The string to validate.
      */
     static parseUUIDNotEmpty(value) {
         const regex = /^({|()?0{8}-(0{4}-){3}0{12}(}|))?$/;
-        return this.parseUUID(value) && !regex.test(value);
+        return this.parseUUID(value) && !regex.test(value ?? '');
     }
     /**
      * Return an empty UUID
@@ -717,7 +719,7 @@ class SystemUtils {
         if (d && d.getTime() && d.getFullYear() > 1750)
             return d;
         // Parse values manually
-        let parts = this.getDateParts(value);
+        const parts = this.getDateParts(value);
         if (!parts)
             return undefined;
         if (parts[0] < 100)
@@ -746,13 +748,13 @@ class SystemUtils {
     static formatDate(value, fmt = DateFormat.Short, locale = it) {
         // No value at all
         if (!value)
-            return undefined;
+            return '';
         // A string
         if (typeof value === 'string' || value instanceof String)
             value = this.parseDate(value);
-        // Not a date 
+        // Not a date
         if (!(value instanceof Date && value.getTime()))
-            return undefined;
+            return '';
         // Format
         switch (fmt) {
             case DateFormat.Short: return format(value, "dd/MM/yyyy", { locale: locale });
@@ -824,63 +826,62 @@ class SystemUtils {
         }
     }
     /**
-     * Format number
-     * @param value : the number to format
-     * @param decimals : the number of decimal places
-     * @param locale : the locale to use for formatting
-     * @returns : the formatted number as a string
+     * Formats a number using `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted number string.
      */
     static formatNumber(value, decimals = 2, locale = 'it-IT') {
-        return Intl.NumberFormat(locale, { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value ?? 0);
+        return Intl.NumberFormat(locale, { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
     }
     /**
-     * Format currency
-     * @param value : the number to format
-     * @param currency : the currency code (e.g., 'EUR', 'USD')
-     * @param decimals : the number of decimal places
-     * @param locale : the locale to use for formatting
-     * @returns : the formatted currency as a string
+     * Formats a number as a currency string using `Intl.NumberFormat`.
+     * @param value    - The number to format.
+     * @param currency - ISO 4217 currency code (default: `'EUR'`).
+     * @param decimals - Maximum decimal places (default: `2`).
+     * @param locale   - BCP 47 locale tag (default: `'it-IT'`).
+     * @returns The formatted currency string.
      */
     static formatCurrency(value, currency = 'EUR', decimals = 2, locale = 'it-IT') {
-        return Intl.NumberFormat(locale, { style: 'currency', currency: currency, minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value ?? 0);
+        return Intl.NumberFormat(locale, { style: 'currency', currency, minimumFractionDigits: 0, maximumFractionDigits: decimals }).format(value);
     }
     /**
-     * Encode url
-     * @param value : the value to encode
-     * @returns     : the url encoded string
+     * Percent-encodes a string for safe inclusion in a URL.
+     * @param value - The string to encode.
+     * @returns The encoded string, or `undefined` when `value` is empty.
      */
     static urlEncode(value) {
-        return value?.length > 0
+        return value.length > 0
             ? encodeURIComponent(value)
             : undefined;
     }
     /**
-     * Decode url
-     * @param value : the url to decode
-     * @returns     : the decode url string
+     * Decodes a percent-encoded URL string, treating `+` as a space.
+     * @param value - The encoded string to decode.
+     * @returns The decoded string, or `undefined` when `value` is empty or absent.
      */
     static urlDecode(value) {
-        const regex = /\+/g;
-        return value?.length > 0
-            ? decodeURIComponent((value + "").replace(regex, "%20"))
+        return value && value.length > 0
+            ? decodeURIComponent(value.replace(/\+/g, '%20'))
             : undefined;
     }
     /**
-     * Get a querystring parameter value
-     * @param name  : the parameter name
-     * @returns     : the string value
+     * Reads a query string parameter value from the current page URL.
+     * @param name - The parameter name to look up.
+     * @returns The decoded parameter value, or `undefined` when absent or running server-side.
      */
     static getQueryStringValueByName(name) {
         if (!this.isBrowser())
             return undefined;
         const url = window.location.href;
-        if (url.includes("?")) {
-            const httpParams = new HttpParams({ fromString: url.split("?")[1] });
-            const v = decodeURIComponent(httpParams.get(name));
-            if (v && v !== "null")
-                return v;
-            else
+        if (url.includes('?')) {
+            const httpParams = new HttpParams({ fromString: url.split('?')[1] });
+            const raw = httpParams.get(name);
+            if (!raw)
                 return undefined;
+            const v = decodeURIComponent(raw);
+            return v && v !== 'null' ? v : undefined;
         }
         return undefined;
     }
@@ -911,7 +912,7 @@ class SystemUtils {
      * @returns the password strength info
      */
     static calculatePasswordStrength(password) {
-        if (password?.length > 0) {
+        if (password && password.length > 0) {
             let score = 0;
             const suggestions = [];
             // Length
@@ -1033,22 +1034,23 @@ class SystemUtils {
             };
             const children = n.children ?? n.subFolders ?? [];
             if (children.length > 0) {
-                node.children = this._toNodes(n.children ?? n.subFolders, node);
+                node.children = this._toNodes(children, node);
             }
             nodes.push(node);
         });
         return nodes;
     }
     /**
-   * Return the flags array to be used in selections
-   * @param value : the new value
-   * @param max: the max number of flags
-   */
+     * Returns an array of individual power-of-2 flag values that are set in `value`.
+     * @param value - The bitmask to decompose.
+     * @param max   - Upper-bound exponent: checks flags from `1` up to `1 << max` (default: `30`).
+     * @returns Array of set flag values, or an empty array when `value` is `0`.
+     */
     static getFlags(value, max = 30) {
-        if (value) {
-            let items = [];
+        if (value !== 0) {
+            const items = [];
             let v = 1;
-            let m = 1 << max;
+            const m = 1 << max;
             while (v < m) {
                 if ((value & v) === v)
                     items.push(v);
@@ -1082,23 +1084,33 @@ class SystemUtils {
     }
 }
 
+/**
+ * Directive that listens to `keyup` events on a date input and debounces changes
+ * into a {@link DateInterval} model, converting shorthand strings (e.g. "d/m") to dates.
+ * Apply `[dateIntervalChange]="interval"` to the host `<input>` element.
+ */
 class DateIntervalChangeDirective {
     constructor() {
+        /** The date interval model to update when the input value changes. */
         this.dateIntervalChange = input(new DateInterval(null, null), ...(ngDevMode ? [{ debugName: "dateIntervalChange" }] : /* istanbul ignore next */ []));
+        /** When `true`, the directive updates the interval's end date; otherwise the start date. */
         this.end = input(false, ...(ngDevMode ? [{ debugName: "end" }] : /* istanbul ignore next */ []));
         this.subject = new Subject();
-    }
-    ngOnInit() {
-        this.subscription = this.subject
-            .pipe(debounceTime(100))
+        this.destroyRef = inject(DestroyRef);
+        this.subject
+            .pipe(debounceTime(100), takeUntilDestroyed(this.destroyRef))
             .subscribe((e) => {
-            const value = e.target.value;
-            SystemUtils.changeDateInterval(value, this.dateIntervalChange(), this.end(), e.key === ' ');
+            const value = e.target?.value;
+            if (value !== undefined) {
+                SystemUtils.changeDateInterval(value, this.dateIntervalChange(), this.end(), e.key === ' ');
+            }
         });
     }
-    ngOnDestroy() {
-        this.subscription.unsubscribe();
-    }
+    /**
+     * Handles `keyup` events on the host element.
+     * Prevents default browser behaviour for the space key and forwards the event to the debounce pipeline.
+     * @param e - The keyboard event emitted by the host input.
+     */
     onKeyup(e) {
         if (e.key === ' ') {
             e.preventDefault();
@@ -1115,26 +1127,36 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     selector: '[dateIntervalChange]',
                     standalone: true,
                 }]
-        }], propDecorators: { dateIntervalChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "dateIntervalChange", required: false }] }], end: [{ type: i0.Input, args: [{ isSignal: true, alias: "end", required: false }] }], onKeyup: [{
+        }], ctorParameters: () => [], propDecorators: { dateIntervalChange: [{ type: i0.Input, args: [{ isSignal: true, alias: "dateIntervalChange", required: false }] }], end: [{ type: i0.Input, args: [{ isSignal: true, alias: "end", required: false }] }], onKeyup: [{
                 type: HostListener,
                 args: ['keyup', ['$event']]
             }] } });
 
+/**
+ * Directive that copies a string payload to the clipboard when the host element is clicked.
+ * Bind `[copyClipboard]="text"` to provide the content to copy and listen to `(copied)` for confirmation.
+ */
 class CopyClipboardDirective {
     constructor() {
-        this.payload = input(undefined, { ...(ngDevMode ? { debugName: "payload" } : /* istanbul ignore next */ {}), alias: "copyClipboard" });
+        /** The text to copy to the clipboard. Bound via the `copyClipboard` attribute. */
+        this.payload = input(undefined, { ...(ngDevMode ? { debugName: "payload" } : /* istanbul ignore next */ {}), alias: 'copyClipboard' });
+        /** Emits the copied text after a successful copy operation. */
         this.copied = output({ alias: 'copied' });
     }
+    /**
+     * Handles click events on the host element and copies the payload to the clipboard.
+     * Emits `copied` with the copied text on success.
+     * @param e - The mouse click event.
+     */
     onClick(e) {
         e.preventDefault();
-        if (!this.payload())
+        const payload = this.payload();
+        if (!payload)
             return;
         if (SystemUtils.isBrowser()) {
-            const listener = (e) => {
-                const clipboard = e.clipboardData;
-                const payload = this.payload();
-                clipboard.setData('text/html', payload.toString());
-                e.preventDefault();
+            const listener = (clipEvent) => {
+                clipEvent.clipboardData?.setData('text/html', payload);
+                clipEvent.preventDefault();
                 this.copied.emit(payload);
             };
             document.addEventListener('copy', listener, false);
@@ -1156,12 +1178,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 args: ['click', ['$event']]
             }] } });
 
+/**
+ * Directive that delegates validation to an externally provided validator function.
+ * Bind `[validator]="myFn"` where `myFn` is `(c: AbstractControl) => ValidationErrors | null`.
+ */
 class ValidatorDirective {
     constructor() {
-        this.validator = input(null, ...(ngDevMode ? [{ debugName: "validator" }] : /* istanbul ignore next */ []));
+        /** The custom validator function to apply. */
+        this.validator = input(undefined, ...(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) {
-        return this.validator()(control);
+        const fn = this.validator();
+        return fn ? fn(control) : null;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", 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 }); }
@@ -1174,27 +1207,33 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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, ...(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)
+        if (!c) {
             isValid = this.validIf() === true;
+        }
         else {
             try {
                 isValid = c.isValid();
             }
             catch { }
         }
-        if (isValid) {
-            return null;
-        }
-        else {
-            return { validIf: "Non valido." };
-        }
+        return isValid ? null : { validIf: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ValidIfDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: ValidIfDirective, isStandalone: true, selector: "[validIf]", inputs: { validIf: { classPropertyName: "validIf", publicName: "validIf", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
@@ -1219,18 +1258,26 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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"`.
+ */
 class EqualsValidatorDirective {
     constructor() {
-        this.equals = input(null, ...(ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []));
+        /** The control whose value must match the host control's value. */
+        this.equals = input(undefined, ...(ngDevMode ? [{ debugName: "equals" }] : /* istanbul ignore next */ []));
     }
+    /**
+     * 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.
+     */
     validate(control) {
-        const isValid = this.equals().value === control.value;
-        if (isValid) {
+        const eq = this.equals();
+        if (!eq)
             return null;
-        }
-        else {
-            return { equals: "Non valido." };
-        }
+        return eq.value === control.value ? null : { equals: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: EqualsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: EqualsValidatorDirective, isStandalone: true, selector: "[equals]", inputs: { equals: { classPropertyName: "equals", publicName: "equals", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
@@ -1255,24 +1302,36 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     standalone: true,
                 }]
         }], 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"`.
+ */
 class NotEqualValidatorDirective {
     constructor() {
-        this.notEqual = input(null, ...(ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []));
+        /** The control whose value must differ from the host control's value. */
+        this.notEqual = input(undefined, ...(ngDevMode ? [{ debugName: "notEqual" }] : /* istanbul ignore next */ []));
     }
+    /**
+     * 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.
+     */
     validate(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 };
-        // immediate show up
-        const notEqualValue = this.notEqual();
+        const errors = isValid ? null : { notequal: true };
         if (errors) {
             control.markAsTouched();
         }
-        else if (notEqualValue.hasError('notequal')) {
-            notEqualValue.setErrors({ 'notequal': null });
-            notEqualValue.updateValueAndValidity({ onlySelf: true, emitEvent: false });
-            notEqualValue.markAsTouched();
-            notEqualValue.markAsDirty();
+        else if (notEqual.hasError('notequal')) {
+            notEqual.setErrors({ notequal: null });
+            notEqual.updateValueAndValidity({ onlySelf: true, emitEvent: false });
+            notEqual.markAsTouched();
+            notEqual.markAsDirty();
         }
         return errors;
     }
@@ -1299,27 +1358,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     standalone: true,
                 }]
         }], 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) {
-        let isValid = true;
         const input = control.value;
         if (!input || input.length === 0)
             return null;
         const parts = input.replaceAll(/\r\n/g, '').split(';');
-        for (const part of parts) {
-            if (part.length > 0) {
-                if (!SystemUtils.parseEmail(part)) {
-                    isValid = false;
-                    break;
-                }
-            }
-        }
-        if (!isValid) {
-            return { emails: "Elenco non valido." };
-        }
-        else {
-            return null;
-        }
+        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: "21.2.9", ngImport: i0, type: EmailsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: EmailsValidatorDirective, isStandalone: true, selector: "[emails]", providers: [
@@ -1344,18 +1400,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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;
-        const isValid = SystemUtils.parseUUID(input);
-        if (!isValid) {
-            return { guid: "Non valido." };
-        }
-        else {
-            return null;
-        }
+        return SystemUtils.parseUUID(input) ? null : { guid: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: GuidValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: GuidValidatorDirective, isStandalone: true, selector: "[guid]", providers: [
@@ -1380,19 +1440,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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 d = endOfDay(SystemUtils.parseDate(input));
-        const isValid = d.getFullYear() > 1750;
-        if (!isValid) {
-            return { sqlDate: "Non valido." };
-        }
-        else {
-            return null;
-        }
+        return d.getFullYear() > 1750 ? null : { sqlDate: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SqlDateValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: SqlDateValidatorDirective, isStandalone: true, selector: "[sqlDate]", providers: [
@@ -1417,20 +1481,24 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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 today = endOfDay(new Date());
         const d = endOfDay(SystemUtils.parseDate(input));
-        const isValid = d <= today;
-        if (!isValid) {
-            return { notFuture: "Non valido." };
-        }
-        else {
-            return null;
-        }
+        return d <= today ? null : { notFuture: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NotFutureValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: NotFutureValidatorDirective, isStandalone: true, selector: "[notFuture]", providers: [
@@ -1455,16 +1523,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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;
-        const isValid = SystemUtils.parseUrl(input);
-        if (!isValid) {
-            return { url: "Non valido." };
-        }
-        else {
+        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: "21.2.9", ngImport: i0, type: UrlValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: UrlValidatorDirective, isStandalone: true, selector: "[url]", providers: [
@@ -1489,25 +1563,32 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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, ...(ngDevMode ? [{ debugName: "maxSizeMb" }] : /* istanbul ignore next */ []));
+        /** Minimum required file size in megabytes. Defaults to 0. */
         this.minSizeMb = input(0, ...(ngDevMode ? [{ debugName: "minSizeMb" }] : /* istanbul ignore next */ []));
-        this.size = input(null, ...(ngDevMode ? [{ debugName: "size" }] : /* istanbul ignore next */ []));
+        /** The actual file size in megabytes to validate against the bounds. */
+        this.size = input(undefined, ...(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;
-        const size = this.size();
-        const s = size ?? 0;
         if (!input)
             return null;
+        const s = this.size() ?? 0;
         const isValid = s <= this.maxSizeMb() && s >= this.minSizeMb();
-        if (isValid) {
-            return null;
-        }
-        else {
-            return { fileSize: "Non valido." };
-        }
+        return isValid ? null : { fileSize: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: FileSizeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", 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: [
@@ -1532,22 +1613,27 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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, ...(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;
-        const isValid = terms <= this.maxTerms();
-        if (isValid) {
-            return null;
-        }
-        else {
-            return { maxTerms: "Non valido." };
-        }
+        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: "21.2.9", ngImport: i0, type: MaxTermsValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: MaxTermsValidatorDirective, isStandalone: true, selector: "[maxTerms]", inputs: { maxTerms: { classPropertyName: "maxTerms", publicName: "maxTerms", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
@@ -1572,16 +1658,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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);
-        if (!strength.isValid) {
-            return { password: "Non valido." };
-        }
-        else {
-            return null;
-        }
+        return strength.isValid ? null : { password: "Non valido." };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: PasswordValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: PasswordValidatorDirective, isStandalone: true, selector: "[password]", providers: [
@@ -1606,14 +1696,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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() {
-        this.slots = input(null, ...(ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []));
+        /** Optional pipe-separated list of allowed time ranges, e.g. `"08:00-12:00|14:00-18:00"`. */
+        this.slots = input(undefined, ...(ngDevMode ? [{ debugName: "slots" }] : /* istanbul ignore next */ []));
     }
     /**
-     * Retrieve hours as a number from a time string (e: 12:00)
-     * @param value : the time string
-     * @returns the hours as a number or -1
+     * 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(':');
@@ -1623,37 +1719,33 @@ class TimeValidatorDirective {
         if (hh < 0 || hh > 23)
             return -1;
         const mm = parseInt(p[1]);
-        if (mm < 0 || hh > 59)
+        if (mm < 0 || mm > 59)
             return -1;
         return parseInt(p[0] + p[1]);
     }
+    /**
+     * 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;
-        let isValid = false;
         const t = this.getTime(input);
-        if (t !== -1) {
-            const slotsValue = this.slots();
-            if (slotsValue) {
-                const slots = slotsValue.split('|');
-                slots.forEach(s => {
-                    const t1 = this.getTime(s.substring(0, 5));
-                    const t2 = this.getTime(s.substring(6));
-                    if (t1 !== -1 && t2 !== -1 && t1 <= t && t2 >= t) {
-                        // Good
-                        isValid = true;
-                        return;
-                    }
-                });
-            }
-        }
-        if (!isValid) {
+        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." };
         }
-        else {
-            return null;
-        }
+        return null;
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: TimeValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "21.2.9", type: TimeValidatorDirective, isStandalone: true, selector: "[time]", inputs: { slots: { classPropertyName: "slots", publicName: "slots", isSignal: true, isRequired: false, transformFunction: null } }, providers: [
@@ -1678,18 +1770,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                     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;
-        const isValid = input.trim().length > 0;
-        if (!isValid) {
-            return { notEmpty: true };
-        }
-        else {
-            return null;
-        }
+        return input.trim().length > 0 ? null : { notEmpty: true };
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: NotEmptyValidatorDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: NotEmptyValidatorDirective, isStandalone: true, selector: "[notEmpty]", providers: [
@@ -1715,29 +1811,47 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * General-purpose formatting pipe that converts a raw value to a locale-aware string
+ * based on the specified format type.
+ *
+ * Supported types: `'date'` / `'D'`, `'currency'` / `'C'`, `'number'` / `'N'`,
+ * `'number0'` / `'N0'`, `'percentage'` / `'P'`.
+ *
+ * Usage: `{{ value | format:'currency' }}`
+ */
 class FormatPipe {
-    transform(value, type = 'date', pattern = "dd/MM/yyyy") {
+    /**
+     * Formats a value according to the specified type and optional pattern.
+     * Returns `undefined` when the value is `null` or `undefined`, or when the type is unrecognised.
+     * @param value   - The raw value to format.
+     * @param type    - The format type identifier (default: `'date'`).
+     * @param pattern - The date pattern used when `type` is `'date'` (default: `'dd/MM/yyyy'`).
+     * @returns A formatted string, or `undefined` when the value cannot be formatted.
+     */
+    transform(value, type = 'date', pattern = 'dd/MM/yyyy') {
         if (value === undefined || value === null)
             return undefined;
         switch (type) {
             case 'D':
-            case 'date':
+            case 'date': {
                 const d = SystemUtils.parseDate(value, it);
                 if (d)
                     return format(d, pattern, { locale: it });
                 break;
+            }
             case 'C':
             case 'currency':
-                return new Intl.NumberFormat('it-IT', { style: 'currency', currency: 'EUR' }).format(value ?? 0);
+                return new Intl.NumberFormat('it-IT', { style: 'currency', currency: 'EUR' }).format(value);
             case 'N':
             case 'number':
-                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 2 }).format(value ?? 0);
+                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 2 }).format(value);
             case 'N0':
             case 'number0':
-                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value ?? 0);
+                return new Intl.NumberFormat('it-IT', { style: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value);
             case 'P':
             case 'percentage':
-                return new Intl.NumberFormat('it-IT', { style: 'percent', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value ?? 0);
+                return new Intl.NumberFormat('it-IT', { style: 'percent', minimumFractionDigits: 0, maximumFractionDigits: 0 }).format(value);
         }
         return undefined;
     }
@@ -1752,17 +1866,30 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Pipe that applies a global regex replacement on a string and returns the result
+ * as sanitized HTML. When `regexValue` is `'\n'` and no `replaceValue` is given,
+ * newlines are replaced with `<br>` tags.
+ *
+ * Usage: `{{ text | replace:'\n':'' }}`
+ */
 class ReplacePipe {
     constructor() {
         this.sanitizer = inject(DomSanitizer);
     }
+    /**
+     * Replaces all occurrences of `regexValue` in `value` with `replaceValue`.
+     * Returns `undefined` when `value` is empty or `undefined`.
+     * @param value        - The source string to process.
+     * @param regexValue   - The regex pattern string to match (applied with the global flag).
+     * @param replaceValue - The replacement string. Defaults to `'<br>'` when `regexValue` is `'\n'` and this is falsy.
+     * @returns A `SafeHtml` value with all matches replaced, or `undefined` when the input is empty.
+     */
     transform(value, regexValue, replaceValue) {
         if (!value)
             return undefined;
-        if (regexValue === '\n' && !replaceValue) {
-            replaceValue = '<br>';
-        }
-        return this.sanitizer.bypassSecurityTrustHtml(value.replace(new RegExp(regexValue, 'g'), replaceValue));
+        const replacement = (regexValue === '\n' && !replaceValue) ? '<br>' : replaceValue;
+        return this.sanitizer.bypassSecurityTrustHtml(value.replace(new RegExp(regexValue, 'g'), replacement));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ReplacePipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
     static { this.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "14.0.0", version: "21.2.9", ngImport: i0, type: ReplacePipe, isStandalone: true, name: "replace" }); }
@@ -1775,10 +1902,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Pipe that marks an HTML string as trusted so Angular does not escape it when
+ * bound via `[innerHTML]`.
+ *
+ * Usage: `<div [innerHTML]="html | safeHtml"></div>`
+ */
 class SafeHtmlPipe {
     constructor() {
         this.sanitizer = inject(DomSanitizer);
     }
+    /**
+     * Bypasses Angular's HTML sanitization and returns a `SafeHtml` instance.
+     * @param value - The raw HTML string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be bound to `[innerHTML]` without escaping.
+     */
     transform(value) {
         return this.sanitizer.bypassSecurityTrustHtml(value ?? '');
     }
@@ -1793,10 +1931,21 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Pipe that marks a URL string as a trusted resource URL so Angular does not block it
+ * when bound to attributes such as `[src]` or `[href]` on iframes, objects, or embeds.
+ *
+ * Usage: `<iframe [src]="url | safeUrl"></iframe>`
+ */
 class SafeUrlPipe {
     constructor() {
         this.sanitizer = inject(DomSanitizer);
     }
+    /**
+     * Bypasses Angular's resource-URL sanitization and returns a `SafeResourceUrl` instance.
+     * @param value - The URL string to trust. Treated as an empty string when `undefined`.
+     * @returns A `SafeResourceUrl` that can be bound to resource URL attributes without blocking.
+     */
     transform(value) {
         return this.sanitizer.bypassSecurityTrustResourceUrl(value ?? '');
     }
@@ -1811,11 +1960,25 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Impure pipe that filters an array using a caller-provided predicate function.
+ * Because the pipe is impure it re-evaluates on every change-detection cycle,
+ * which is necessary when the predicate's captured state changes.
+ *
+ * Usage: `*ngFor="let item of items | callback:myFilter"`
+ */
 class SearchCallbackPipe {
+    /**
+     * Filters `items` by applying `callback` to each element.
+     * Returns the original array unchanged when either argument is falsy.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param callback - A predicate function that returns `true` for items to keep.
+     * @returns A new filtered array, the original array when no callback is provided,
+     *          or `undefined` when `items` is `undefined`.
+     */
     transform(items, callback) {
-        if (!items || !callback) {
+        if (!items || !callback)
             return items;
-        }
         return items.filter(item => callback(item));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: SearchCallbackPipe, deps: [], target: i0.ɵɵFactoryTarget.Pipe }); }
@@ -1830,35 +1993,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-// ---------------------------------------------------------------------------------
-// 2023.0921 aggiunto un campo opzionale di tipo SearchFilterMetadata per i conteggi
-//
-// - nel chiamante:
-//   let items: Searchable[] = [...];
-//   let myFilterText: string = 'testo del filtro';
-//   const myFilterMetadata: SearchFilterMetadata = { total: 0, count: 0 };
-// 
-//   <div *ngFor="let item of items | search:myFilterText:myFilterMetadata">
-//   <div>Totale: {{ myFilterMetadata.total }}, Filtrati: {{ myFilterMetadata.count }}</div>
-// ---------------------------------------------------------------------------------
+/**
+ * Impure pipe that filters an array of searchable items against a text query.
+ *
+ * Each item is matched either via its `searchBag.name` property (when present)
+ * or by converting the item itself to a lowercase string. The optional `metadata`
+ * argument is updated in-place with the total item count and the filtered count,
+ * making it usable in the template alongside `*ngFor`.
+ *
+ * Usage:
+ * ```html
+ * <div *ngFor="let item of items | search:filterText:meta">...</div>
+ * <div>Showing {{ meta.count }} of {{ meta.total }}</div>
+ * ```
+ */
 class SearchFilterPipe {
+    /**
+     * Filters `items` by performing a case-insensitive substring match against `value`.
+     * When `items` or `value` is falsy the original array is returned unfiltered.
+     * @param items    - The source array to filter. May be `undefined`.
+     * @param value    - The search text to match against each item. May be `undefined`.
+     * @param metadata - Optional object that is updated with `total` and `count` after filtering.
+     * @returns The filtered array, the original array when no filter text is given,
+     *          or `undefined` when `items` is `undefined`.
+     */
     transform(items, value, metadata) {
         metadata ??= { total: 0, count: 0 };
-        if (!items || !value) {
+        if (!items || !value)
             return items;
-        }
-        let result = items.filter(item => {
-            if (item) {
-                if (item.searchBag)
-                    return item.searchBag.name
-                        .toLowerCase()
-                        .indexOf(value.toLowerCase()) !== -1;
-                else
-                    return item.toLowerCase().indexOf(value.toLowerCase()) !== -1;
-            }
-            return null;
+        const query = value.toLowerCase();
+        const result = items.filter(item => {
+            if (!item)
+                return false;
+            const text = item.searchBag?.name ?? (typeof item === 'string' ? item : undefined);
+            return text?.toLowerCase().includes(query) ?? false;
         });
-        // aggiorna i conteggi
         metadata.total = items.length;
         metadata.count = result.length;
         return result;
@@ -1874,10 +2043,22 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Pipe that converts plain-text newlines (`\r\n`, `\r`, `\n`) to HTML `<br>` tags
+ * and marks the result as trusted HTML so Angular does not escape it.
+ *
+ * Usage: `{{ text | formatHtml }}`
+ */
 class FormatHtmlPipe {
     constructor() {
         this.sanitizer = inject(DomSanitizer);
     }
+    /**
+     * Transforms a plain-text string into sanitized HTML by replacing newline characters
+     * with `<br>` tags.
+     * @param value - The input string to transform. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     */
     transform(value) {
         return this.sanitizer.bypassSecurityTrustHtml((value ?? '').replaceAll(/(?:\r\n|\r|\n)/g, '<br>'));
     }
@@ -1910,131 +2091,148 @@ const UtilsMessages = {
     UTILS_DIALOGS_SELECT_OPTIONS_CHANGED: '§utils-dialogs-select-options-changed'
 };
 
+/**
+ * Generic selection model that tracks a set of selected items identified by a lookup field.
+ * Wraps Angular CDK's `SelectionModel` and adds lookup-based add/remove logic.
+ *
+ * @typeParam T - The item type held in the selection.
+ * @typeParam V - The type of the lookup key used to identify items.
+ */
 class SelectableModel {
+    /**
+     * Snapshot of all items currently tracked by this model (selected or previously toggled).
+     * Backed by a signal — reads are always up to date.
+     */
     get all() {
-        return this._all;
+        return this._all();
     }
+    /** The underlying CDK `SelectionModel` (provides `.selected`, `.isSelected`, etc.). */
     get current() {
         return this._current;
     }
-    constructor(allowMultiSelect = true, lookupFieldName = "id") {
+    /**
+     * @param allowMultiSelect - When `true` (default), multiple items can be selected simultaneously.
+     * @param lookupFieldName  - Name of the property used as the unique key when searching the internal list (default: `'id'`).
+     */
+    constructor(allowMultiSelect = true, lookupFieldName = 'id') {
+        /**
+         * Emits whenever the selection changes.
+         * Carries the affected item, or `undefined` when the whole selection is cleared.
+         */
         this.changed = new EventEmitter();
-        this._all = [];
+        this._all = signal([], ...(ngDevMode ? [{ debugName: "_all" }] : /* istanbul ignore next */ []));
+        /** Signal that is `true` when at least one item is selected. */
+        this.hasValue = computed(() => this._all().length > 0, ...(ngDevMode ? [{ debugName: "hasValue" }] : /* istanbul ignore next */ []));
         this._current = new SelectionModel(allowMultiSelect, []);
-        this._all = [];
         this._lookupFieldName = lookupFieldName;
     }
     /**
-     * Update the view of an item
-     * @param item          : the item to update
-     * @param lookupValue   : the value
+     * Toggles the CDK selection state of an item that already exists in the tracked list.
+     * Has no effect when `lookupValue` does not match any tracked item.
+     * @param item        - The item whose selection state should be toggled.
+     * @param lookupValue - The key value used to locate the item in the internal list.
      */
     updateCurrent(item, lookupValue) {
-        const p = SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, lookupValue);
+        const p = SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, lookupValue);
         if (p !== -1) {
             this._current.toggle(item);
             this.changed.emit(item);
         }
     }
     /**
-     * Select an item
-     * @param item          : the item to update
-     * @param lookupValue   : the value
+     * Toggles an item in both the internal list and the CDK selection.
+     * Adds the item when it is not yet tracked; removes it when it is.
+     * @param item        - The item to toggle.
+     * @param lookupValue - The key value used to locate or register the item.
      */
     toggle(item, lookupValue) {
-        if (lookupValue) {
-            const p = SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, lookupValue);
-            if (p === -1) {
-                this._all.push(item);
-            }
-            else {
-                this._all.splice(p, 1);
-            }
-            this._current.toggle(item);
-            this.changed.emit(item);
+        if (lookupValue === undefined)
+            return;
+        const p = SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, lookupValue);
+        if (p === -1) {
+            this._all.update(arr => [...arr, item]);
+        }
+        else {
+            this._all.update(arr => arr.filter((_, i) => i !== p));
         }
+        this._current.toggle(item);
+        this.changed.emit(item);
     }
     /**
-     * Select an item
-     * @param item          : the item to update
-     * @param lookupValue   : the value
+     * Adds an item to the internal list (when not already present) and marks it as selected.
+     * @param item        - The item to select.
+     * @param lookupValue - The key value used to locate or register the item.
      */
     select(item, lookupValue) {
-        if (lookupValue) {
-            const p = SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, lookupValue);
-            if (p === -1) {
-                this._all.push(item);
-            }
-            this._current.select(item);
-            this.changed.emit(item);
+        if (lookupValue === undefined)
+            return;
+        const p = SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, lookupValue);
+        if (p === -1) {
+            this._all.update(arr => [...arr, item]);
         }
+        this._current.select(item);
+        this.changed.emit(item);
     }
     /**
-     * Deselect an item
-     * @param item          : the item to update
-     * @param lookupValue   : the value
+     * Removes an item from the internal list and deselects it in the CDK model.
+     * Has no effect when the item is not currently tracked.
+     * @param item        - The item to deselect.
+     * @param lookupValue - The key value used to locate the item in the internal list.
      */
     deselect(item, lookupValue) {
-        if (lookupValue) {
-            const p = SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, lookupValue);
-            if (p !== -1) {
-                this._all.splice(p, 1);
-                this._current.deselect(item);
-                this.changed.emit(item);
-            }
+        if (lookupValue === undefined)
+            return;
+        const p = SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, lookupValue);
+        if (p !== -1) {
+            this._all.update(arr => arr.filter((_, i) => i !== p));
+            this._current.deselect(item);
+            this.changed.emit(item);
         }
     }
     /**
-     * Deselect all specified item lookup values
-     * @param lookupValues : the values
+     * Deselects all items whose lookup key is contained in `lookupValues`.
+     * @param lookupValues - Array of key values identifying the items to deselect.
      */
     deselectByValues(lookupValues) {
-        if (!lookupValues || lookupValues.length === 0)
+        if (lookupValues.length === 0)
             return;
-        lookupValues.forEach(n => {
-            const p = SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, n);
+        for (const key of lookupValues) {
+            const p = SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, key);
             if (p !== -1) {
-                const item = this._all[p];
-                this._all.splice(p, 1);
+                const item = this._all()[p];
+                this._all.update(arr => arr.filter((_, i) => i !== p));
                 this._current.deselect(item);
                 this.changed.emit(item);
             }
-        });
+        }
     }
     /**
-     * Clear current view
-     * @param clearFunc : the function used to clear
+     * Runs `clearFunc` against every currently selected item, then clears the CDK selection.
+     * The internal tracked list is **not** affected; only the CDK selection is cleared.
+     * @param clearFunc - Callback invoked for each currently selected item before clearing.
      */
     clearCurrent(clearFunc) {
-        this._current.selected.forEach(n => {
-            clearFunc(n);
-        });
+        for (const item of this._current.selected) {
+            clearFunc(item);
+        }
         this._current.clear();
-        this.changed.emit();
+        this.changed.emit(undefined);
     }
     /**
-     * Deselect all items
+     * Clears both the internal tracked list and the CDK selection.
      */
     clear() {
-        this._all = [];
+        this._all.set([]);
         this._current.clear();
-        this.changed.emit();
+        this.changed.emit(undefined);
     }
     /**
-     * Checks if an item is selected using its lookup value
-     * @param lookupValue : the value
-     * @returns           : true if the value is selected
+     * Returns `true` when the item identified by `lookupValue` is present in the tracked list.
+     * @param lookupValue - The key value to look up.
      */
     isSelected(lookupValue) {
         return (lookupValue !== undefined &&
-            SystemUtils.arrayFindIndexByKey(this._all, this._lookupFieldName, lookupValue) !== -1);
-    }
-    /**
-     * Checks if a selection exists
-     * @returns : true if at least one selection exists
-     */
-    hasValue() {
-        return this._all.length > 0;
+            SystemUtils.arrayFindIndexByKey(this._all(), this._lookupFieldName, lookupValue) !== -1);
     }
 }
 
@@ -2043,37 +2241,48 @@ class SelectableModel {
  * https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
  */
 /**
- * Web Standard Broadcast Messages Manager
- * https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
+ * Wrapper around the native Web `BroadcastChannel` API that adds typed messaging,
+ * multiple named subscriptions, and a graceful disposal mechanism.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/BroadcastChannel
  */
 class BroadcastChannelManager {
     /**
-     * Get the current channel registration
+     * The name of the underlying `BroadcastChannel`, or `undefined` when the API
+     * is not supported by the current browser.
      */
     get currentBus() {
         return this.channel?.name;
     }
-    constructor(bus = "ARS-CHANNEL") {
+    /**
+     * Opens a `BroadcastChannel` with the given name (when the API is available).
+     * @param bus - The channel name to open (default: `'ARS-CHANNEL'`).
+     */
+    constructor(bus = 'ARS-CHANNEL') {
         this.subject = new Subject();
         this.subscriptions = [];
         if ('BroadcastChannel' in window) {
             this.channel = new BroadcastChannel(bus);
-            this.channel.onmessageerror = (_e) => {
-                console.error('[BroadcastChannelManager] Errore di ricezione del messaggio', _e);
+            this.channel.onmessageerror = (e) => {
+                console.error('[BroadcastChannelManager] Message receive error', e);
             };
             this.channel.onmessage = (e) => {
-                this.subject.next(e.data);
                 const bag = e.data;
-                if (bag) {
-                    const bagInfo = this.subscriptions.find(m => m.messageId === bag.messageId);
-                    bagInfo?.action(bag);
-                }
+                if (!bag)
+                    return;
+                this.subject.next(bag);
+                const info = this.subscriptions.find(m => m.messageId === bag.messageId);
+                info?.action(bag);
             };
         }
         else {
-            console.error('[BroadcastChannelManager] Non supportato');
+            console.error('[BroadcastChannelManager] BroadcastChannel API is not supported in this browser');
         }
     }
+    /**
+     * Closes the underlying channel and completes the internal subject after a short delay
+     * to allow any in-flight messages to be delivered.
+     */
     dispose() {
         setTimeout(() => {
             this.subscriptions = [];
@@ -2082,22 +2291,22 @@ class BroadcastChannelManager {
             this.subject.complete();
         }, 1000);
     }
-    /**
-     * overloads
-     */
-    sendMessage(messageIdorBag, dataOrDelay, delay) {
+    /** @internal Implementation that handles all overloads. */
+    sendMessage(messageIdOrBag, dataOrDelay, delay) {
+        const effectiveDelay = (typeof dataOrDelay === 'number' ? dataOrDelay : delay) ?? 0;
         setTimeout(() => {
-            if (typeof messageIdorBag === 'string') {
-                this.channel?.postMessage({ messageId: messageIdorBag, data: dataOrDelay });
+            if (typeof messageIdOrBag === 'string') {
+                this.channel?.postMessage({ messageId: messageIdOrBag, data: dataOrDelay });
             }
             else {
-                this.channel?.postMessage(messageIdorBag);
+                this.channel?.postMessage(messageIdOrBag);
             }
-        }, (typeof dataOrDelay === 'number' ? dataOrDelay : delay) ?? 0);
+        }, effectiveDelay);
     }
     /**
-     * Subscribe to a message
-     * @param args The subscription info, see also {@link BroadcastChannelSubscriberInfo}
+     * Registers a handler for messages with the given `messageId`.
+     * If a handler for the same `messageId` is already registered it is replaced.
+     * @param args - The subscription descriptor containing the message ID and handler.
      */
     subscribe(args) {
         const i = this.subscriptions.findIndex(m => m.messageId === args.messageId);
@@ -2109,8 +2318,8 @@ class BroadcastChannelManager {
         }
     }
     /**
-     * Remove a message subscription
-     * @param messageId The message id
+     * Removes the subscription for the given message ID, if one exists.
+     * @param messageId - The message type identifier whose subscription should be removed.
      */
     unsubscribe(messageId) {
         const i = this.subscriptions.findIndex(m => m.messageId === messageId);
@@ -2119,60 +2328,66 @@ class BroadcastChannelManager {
         }
     }
     /**
-     * Remove all the current subscriptions
+     * Removes all registered subscriptions.
      */
     unsubscribeAll() {
         this.subscriptions = [];
     }
 }
 
+/**
+ * Application-level messaging service that combines two transports:
+ * - An in-process RxJS `Subject` for same-tab communication (`sendMessage` / `getMessage`).
+ * - A native `BroadcastChannel` for cross-tab communication (`sendChannelMessage` / `subscribeChannelMessage`).
+ */
 class BroadcastService {
     constructor() {
         this.subject = new Subject();
         this.channel = new BroadcastChannelManager('ARS-CHANNEL');
     }
     /**
-     * Get a new instance of broadcast channel
+     * Creates a new standalone `BroadcastChannelManager` instance bound to the shared ARS channel.
+     * Useful when a caller needs direct channel access outside the service.
+     * @returns A new `BroadcastChannelManager` connected to `'ARS-CHANNEL'`.
      */
     static GetChannel() {
-        return new BroadcastChannelManager("ARS-CHANNEL");
+        return new BroadcastChannelManager('ARS-CHANNEL');
     }
     ngOnDestroy() {
         this.channel?.dispose();
     }
     /**
-     * Send a message
-     * @param id    : the message id
-     * @param data  : the data to send
-     * @param delay : the number of milliseconds to wait before sending the message
+     * Publishes a message to the in-process subject, optionally after a delay.
+     * @param id    - The message type identifier.
+     * @param data  - Optional payload to attach to the message.
+     * @param delay - Milliseconds to wait before publishing (default: `0`).
      */
-    sendMessage(id, data = undefined, delay = 0) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    sendMessage(id, data, delay = 0) {
         setTimeout(() => {
             this.subject.next({ id, data });
         }, delay);
     }
     /**
-   * Send a channel message
-   * @param id    : the message bag
-   * @param data  : the data bag
-   * @param delay : the number of milliseconds to wait before sending the message
-   */
+     * Publishes a typed message over the native `BroadcastChannel` (cross-tab), optionally after a delay.
+     * @param id    - The message type identifier.
+     * @param data  - Optional typed payload to send.
+     * @param delay - Milliseconds to wait before sending (forwarded to the channel manager).
+     */
     sendChannelMessage(id, data, delay) {
-        setTimeout(() => {
-            this.channel.sendMessage(id, data, delay);
-        }, delay);
+        this.channel.sendMessage(id, data, delay);
     }
     /**
-     * Subscribe channel message
-     * @param id      : the message id
-     * @param action  : the actionto perform
+     * Registers a handler that is invoked whenever a channel message with the given `id` is received.
+     * @param id     - The message type identifier to listen for.
+     * @param action - Callback invoked with the full `BroadcastChannelMessageBag` when a matching message arrives.
      */
     subscribeChannelMessage(id, action) {
-        this.channel.subscribe({ messageId: id, action: action });
+        this.channel.subscribe({ messageId: id, action });
     }
     /**
-     * Get the next message as observable
-     * @returns : the observable object
+     * Returns an `Observable` that emits every in-process message published via `sendMessage`.
+     * @returns An observable stream of `BroadcastMessageInfo` objects.
      */
     getMessage() {
         return this.subject.asObservable();
@@ -2187,37 +2402,54 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Application-wide environment configuration service.
+ * Exposes writable signals for the base URIs used throughout the application.
+ * Values should be set once during application bootstrap (e.g. in `APP_INITIALIZER`).
+ */
 class EnvironmentService {
     constructor() {
-        this._appUri = '';
-        this._appServiceUri = '';
-        this._appLoginRedirectUri = '';
-        this._appServiceLoginUri = '';
-    }
-    get appUri() {
-        return this._appUri;
-    }
-    set appUri(value) {
-        this._appUri = value;
-    }
-    get appServiceUri() {
-        return this._appServiceUri;
-    }
-    set appServiceUri(value) {
-        this._appServiceUri = value;
-    }
-    get appLoginRedirectUri() {
-        return this._appLoginRedirectUri ?? this._appUri;
-    }
-    set appLoginRedirectUri(value) {
-        this._appLoginRedirectUri = value;
-    }
-    get appServiceLoginUri() {
-        return this._appServiceLoginUri ?? this._appServiceUri;
-    }
-    set appServiceLoginUri(value) {
-        this._appServiceLoginUri = value;
-    }
+        /** Writable signal holding the base URI of the frontend application (e.g. `https://app.example.com`). */
+        this.appUriSignal = signal('', ...(ngDevMode ? [{ debugName: "appUriSignal" }] : /* istanbul ignore next */ []));
+        /** Writable signal holding the base URI of the backend API service (e.g. `https://api.example.com`). */
+        this.appServiceUriSignal = signal('', ...(ngDevMode ? [{ debugName: "appServiceUriSignal" }] : /* istanbul ignore next */ []));
+        /**
+         * Writable signal holding the redirect URI used after login.
+         * When empty, `appLoginRedirectUri` falls back to `appUri`.
+         */
+        this.appLoginRedirectUriSignal = signal('', ...(ngDevMode ? [{ debugName: "appLoginRedirectUriSignal" }] : /* istanbul ignore next */ []));
+        /**
+         * Writable signal holding the login endpoint URI of the backend service.
+         * When empty, `appServiceLoginUri` falls back to `appServiceUri`.
+         */
+        this.appServiceLoginUriSignal = signal('', ...(ngDevMode ? [{ debugName: "appServiceLoginUriSignal" }] : /* istanbul ignore next */ []));
+        // ── Computed: fallback logic ──────────────────────────────────────────────
+        this._effectiveLoginRedirectUri = computed(() => this.appLoginRedirectUriSignal() || this.appUriSignal(), ...(ngDevMode ? [{ debugName: "_effectiveLoginRedirectUri" }] : /* istanbul ignore next */ []));
+        this._effectiveServiceLoginUri = computed(() => this.appServiceLoginUriSignal() || this.appServiceUriSignal(), ...(ngDevMode ? [{ debugName: "_effectiveServiceLoginUri" }] : /* istanbul ignore next */ []));
+    }
+    // ── Getter / setter API (kept for backward compatibility) ─────────────────
+    /** Base URI of the frontend application. */
+    get appUri() { return this.appUriSignal(); }
+    /** @param value - The base URI of the frontend application. */
+    set appUri(value) { this.appUriSignal.set(value); }
+    /** Base URI of the backend API service. */
+    get appServiceUri() { return this.appServiceUriSignal(); }
+    /** @param value - The base URI of the backend API service. */
+    set appServiceUri(value) { this.appServiceUriSignal.set(value); }
+    /**
+     * Effective login redirect URI.
+     * Returns the explicitly set value, or falls back to `appUri` when empty.
+     */
+    get appLoginRedirectUri() { return this._effectiveLoginRedirectUri(); }
+    /** @param value - The redirect URI to use after login. */
+    set appLoginRedirectUri(value) { this.appLoginRedirectUriSignal.set(value); }
+    /**
+     * Effective service login URI.
+     * Returns the explicitly set value, or falls back to `appServiceUri` when empty.
+     */
+    get appServiceLoginUri() { return this._effectiveServiceLoginUri(); }
+    /** @param value - The login endpoint URI of the backend service. */
+    set appServiceLoginUri(value) { this.appServiceLoginUriSignal.set(value); }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: EnvironmentService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: EnvironmentService, providedIn: 'root' }); }
 }
@@ -2228,13 +2460,29 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Service that exposes reactive screen and device-capability information.
+ */
 class ScreenService {
     constructor() {
+        /**
+         * Writable signal that holds the current Material breakpoint alias
+         * (e.g. `'xs'`, `'sm'`, `'md'`, `'lg'`, `'xl'`).
+         * Updated externally by the breakpoint observer in the consuming component or module.
+         */
         this.mq = signal('', ...(ngDevMode ? [{ debugName: "mq" }] : /* istanbul ignore next */ []));
     }
+    /**
+     * Returns `true` when the primary input mechanism can hover over elements
+     * with coarse pointer precision (i.e. a touch screen).
+     */
     get isTouchable() {
         return SystemUtils.isTouchable();
     }
+    /**
+     * Returns `true` when the current browser is Internet Explorer or the legacy Edge (EdgeHTML).
+     * Modern Chromium-based Edge reports a different user-agent and will return `false`.
+     */
     get isIEOrEdge() {
         return /msie\s|trident\/|edge\//i.test(window.navigator.userAgent);
     }
@@ -2248,124 +2496,115 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Application-level theme management service.
+ *
+ * Responsibilities:
+ * - Persists the user's preferred theme in `localStorage`.
+ * - Applies `'light'` or `'dark'` CSS class to `<body>`.
+ * - Reacts to OS-level colour-scheme changes when the theme is set to `'auto'`.
+ * - Synchronises theme changes across browser tabs via `BroadcastChannel`.
+ * - Exposes reactive signals (`themeIcon`, `themeName`, `toggleTooltip`) for the UI.
+ */
 class ThemeService {
     constructor() {
-        // messaggi broadcast
         this.broadcastChannel = new BroadcastChannelManager('THEME-SERVICE');
         this.broadcastMessage = '$theme-changed';
-        // per intercettare il cambio di tema a livello di sistema
         this.prefersColorSchemeMediaQueryList = window.matchMedia('(prefers-color-scheme: dark)');
-        /**
-         * Theme changed e.
-         * Notify the consuming component about the incoming theme change.
-         * @example
-         * // React to theme changes
-         * this.themeService.themeChanged
-         *    .pipe(takeUntil(this.unsubscribe))
-         *    .subscribe((value: ThemeType) => {
-         *      // do the job done....
-         *    });
-         */
         this.themeChanged = new BehaviorSubject('auto');
-        // espone al consumatore un'observable
-        this.changed = this.themeChanged.asObservable();
         this.renderFactory2 = inject(RendererFactory2);
         this.renderer = this.renderFactory2.createRenderer(null, null);
-        /**
-         * Current theme
-         */
-        this.theme = signal("light", ...(ngDevMode ? [{ debugName: "theme" }] : /* istanbul ignore next */ []));
-        /**
-         * The current theme is "System default"
-         */
+        /** The currently selected `ThemeType` (may be `'auto'`). */
+        this.theme = signal('light', ...(ngDevMode ? [{ debugName: "theme" }] : /* istanbul ignore next */ []));
+        /** `true` when the theme is set to follow the system preference. */
         this.auto = computed(() => this.theme() === 'auto', ...(ngDevMode ? [{ debugName: "auto" }] : /* istanbul ignore next */ []));
-        /**
-         * Configuration schema about the icon, the text and the toggle() sequence
-         */
         this.themeInfo = {
-            ['auto']: { icon: 'routine', name: 'Tema di sistema', next: 'light', tooltip: 'Passa a tema chiaro', },
-            ['light']: { icon: 'light_mode', name: 'Tema chiaro', next: 'dark', tooltip: 'Passa a tema scuro', },
-            ['dark']: { icon: 'dark_mode', name: 'Tema scuro', next: 'auto', tooltip: 'Passa a tema di sistema', },
+            auto: { icon: 'routine', name: 'Tema di sistema', next: 'light', tooltip: 'Passa a tema chiaro' },
+            light: { icon: 'light_mode', name: 'Tema chiaro', next: 'dark', tooltip: 'Passa a tema scuro' },
+            dark: { icon: 'dark_mode', name: 'Tema scuro', next: 'auto', tooltip: 'Passa a tema di sistema' },
         };
-        /**
-         * Icon of the current theme (mat-icon code)
-         */
+        /** Reactive Material icon code for the current theme (use with `<mat-icon>`). */
         this.themeIcon = computed(() => this.themeInfo[this.theme()].icon, ...(ngDevMode ? [{ debugName: "themeIcon" }] : /* istanbul ignore next */ []));
-        /**
-         * Current theme name
-         */
+        /** Reactive human-readable name of the current theme. */
         this.themeName = computed(() => this.themeInfo[this.theme()].name, ...(ngDevMode ? [{ debugName: "themeName" }] : /* istanbul ignore next */ []));
-        /**
-         * Tooltip text on toggle
-         */
+        /** Reactive tooltip text for the theme toggle button. */
         this.toggleTooltip = computed(() => this.themeInfo[this.theme()].tooltip, ...(ngDevMode ? [{ debugName: "toggleTooltip" }] : /* istanbul ignore next */ []));
+        this.changed = this.themeChanged.asObservable();
     }
     /**
-     * Initialize
+     * Initialises the service: loads the preferred theme, registers OS-change listener,
+     * and subscribes to cross-tab broadcast messages.
+     * Call this once during application bootstrap (e.g. in `APP_INITIALIZER`).
+     * @param theme - The initial theme to apply (defaults to the value stored in `localStorage`).
      */
     initialize(theme = this.getPreferredTheme()) {
-        // React to current theme
-        this.prefersColorSchemeMediaQueryList.onchange = (_) => this.auto() ? this.setTheme(theme) : null;
-        // Support boradcast channel messaging
+        this.prefersColorSchemeMediaQueryList.onchange = () => {
+            if (this.auto())
+                this.setTheme(this.theme());
+        };
         this.broadcastChannel.subscribe({
             messageId: this.broadcastMessage,
             action: (bag) => {
-                if (this.theme() !== bag.data) {
+                if (bag.data && this.theme() !== bag.data) {
                     this.setTheme(bag.data);
                 }
             }
         });
-        // Load theme
         this.setTheme(theme);
     }
     ngOnDestroy() {
         this.broadcastChannel.dispose();
     }
     /**
-     * Get the current preferred theme
+     * Advances the theme through the cycle: `auto` → `light` → `dark` → `auto`.
      */
-    getPreferredTheme() {
-        let theme = localStorage.getItem('preferred-theme');
-        if (!this.isTheme(theme)) {
-            theme = 'auto';
+    toggleTheme() {
+        this.setTheme(this.themeInfo[this.theme()].next);
+    }
+    /**
+     * Returns the resolved effective theme (`'light'` or `'dark'`), taking the OS preference
+     * into account when the current mode is `'auto'`.
+     * @returns `'light'` or `'dark'` — never `'auto'`.
+     */
+    getTheme() {
+        if (this.auto()) {
+            return this.prefersColorSchemeMediaQueryList.matches ? 'dark' : 'light';
         }
-        return theme;
+        return this.getPreferredTheme();
     }
     /**
-     * Check if a value string is a theme type
-     * @param value : th string value
-     * @returns true if the the value is a valid theme type
+     * Reads the theme stored in `localStorage` and validates it.
+     * Falls back to `'auto'` when the stored value is missing or invalid.
+     * @returns The persisted `ThemeType`, or `'auto'` as default.
+     */
+    getPreferredTheme() {
+        const stored = localStorage.getItem('preferred-theme');
+        return stored && this.isTheme(stored) ? stored : 'auto';
+    }
+    /**
+     * Returns `true` when `value` is a valid `ThemeType` string.
+     * Acts as a TypeScript type guard.
+     * @param value - The string to check.
      */
     isTheme(value) {
-        return ['auto', 'light', 'dark'].includes(value);
+        return value === 'auto' || value === 'light' || value === 'dark';
     }
     /**
-     * Set the new theme
-     * @param theme the new theme
+     * Applies the given theme to `<body>` (CSS class), persists it to `localStorage`,
+     * notifies the `changed` observable, and broadcasts the change to other tabs.
+     * @param theme - The `ThemeType` to apply (defaults to `'auto'`).
      */
     setTheme(theme = 'auto') {
         this.renderer.removeClass(document.body, 'light');
         this.renderer.removeClass(document.body, 'dark');
         this.theme.set(theme);
-        localStorage.setItem("preferred-theme", this.theme());
-        this.renderer.addClass(document.body, this.auto() ? (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light") : theme);
-        // Notify that current theme has changed
+        localStorage.setItem('preferred-theme', theme);
+        const effectiveClass = this.auto()
+            ? (this.prefersColorSchemeMediaQueryList.matches ? 'dark' : 'light')
+            : theme;
+        this.renderer.addClass(document.body, effectiveClass);
         this.themeChanged.next(this.getTheme());
-        this.broadcastChannel.sendMessage(this.broadcastMessage, this.theme());
-    }
-    /**
-     * Toggle theme
-     */
-    toggleTheme() {
-        this.setTheme(this.themeInfo[this.theme()].next);
-    }
-    /**
-     * Get current real theme: light or dark
-     */
-    getTheme() {
-        return (this.auto()
-            ? (window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light")
-            : this.getPreferredTheme());
+        this.broadcastChannel.sendMessage(this.broadcastMessage, theme);
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ThemeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
     static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ThemeService, providedIn: "root" }); }
@@ -2375,7 +2614,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
             args: [{
                     providedIn: "root",
                 }]
-        }] });
+        }], ctorParameters: () => [] });
 
 class ArsCoreModule {
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: ArsCoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
@@ -2495,7 +2734,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
-/** Creates an array and fills it with values. */
+/**
+ * Creates an array of the given length, filling each slot with the result of `valueFunction`.
+ * @param length        - Number of elements to create.
+ * @param valueFunction - Factory called with each index to produce the element value.
+ * @returns Typed array of `length` elements.
+ */
 function range(length, valueFunction) {
     const valuesArray = Array(length);
     for (let i = 0; i < length; i++) {
@@ -2526,32 +2770,61 @@ const MAT_DATE_FNS_FORMATS = {
         monthYearA11yLabel: 'LLLL uuuu',
     },
 };
-/** Adds date-fns support to Angular Material. */
+/**
+ * date-fns adapter that integrates Angular Material's date picker with the date-fns library,
+ * applying `Europe/Rome` timezone for all parsed and created dates.
+ */
 class DateFnsAdapter extends DateAdapter {
     constructor() {
         super();
         const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
-        this.setLocale(matDateLocale);
+        if (matDateLocale) {
+            this.setLocale(matDateLocale);
+        }
     }
+    /**
+     * Returns the year component of the given date.
+     * @param date - The source date.
+     */
     getYear(date) {
         return getYear(date);
     }
+    /**
+     * Returns the zero-based month index of the given date (0 = January).
+     * @param date - The source date.
+     */
     getMonth(date) {
         return getMonth(date);
     }
+    /**
+     * Returns the day-of-month of the given date (1-based).
+     * @param date - The source date.
+     */
     getDate(date) {
         return getDate(date);
     }
+    /**
+     * Returns the day-of-week of the given date (0 = Sunday).
+     * @param date - The source date.
+     */
     getDayOfWeek(date) {
         return getDay(date);
     }
+    /**
+     * Returns an array of 12 month name strings formatted for the active locale.
+     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
+     */
     getMonthNames(style) {
         const pattern = MONTH_FORMATS[style];
         return range(12, i => this.format(new Date(2017, i, 1), pattern));
     }
+    /**
+     * Returns an array of 31 day-of-month label strings formatted using `Intl.DateTimeFormat`
+     * when available, falling back to plain numeric strings.
+     */
     getDateNames() {
         const dtf = typeof Intl !== 'undefined'
-            ? new Intl.DateTimeFormat(this.locale.code, {
+            ? new Intl.DateTimeFormat(this.locale?.code, {
                 day: 'numeric',
                 timeZone: 'utc',
             })
@@ -2565,28 +2838,52 @@ class DateFnsAdapter extends DateAdapter {
                 date.setUTCHours(0, 0, 0, 0);
                 return dtf.format(date).replace(/[\u200e\u200f]/g, '');
             }
-            return i + '';
+            return String(i + 1);
         });
     }
+    /**
+     * Returns an array of 7 day-of-week name strings formatted for the active locale.
+     * @param style - One of `'long'`, `'short'`, or `'narrow'`.
+     */
     getDayOfWeekNames(style) {
         const pattern = DAY_OF_WEEK_FORMATS[style];
         return range(7, i => this.format(new Date(2017, 0, i + 1), pattern));
     }
+    /**
+     * Returns the four-digit year string for the given date.
+     * @param date - The source date.
+     */
     getYearName(date) {
         return this.format(date, 'y');
     }
+    /**
+     * Returns the first day of the week for the active locale (0 = Sunday, 1 = Monday, …).
+     */
     getFirstDayOfWeek() {
-        return this.locale.options?.weekStartsOn ?? 0;
+        return this.locale?.options?.weekStartsOn ?? 0;
     }
+    /**
+     * Returns the number of days in the month of the given date.
+     * @param date - The source date.
+     */
     getNumDaysInMonth(date) {
         return getDaysInMonth(date);
     }
+    /**
+     * Creates an independent copy of the given date.
+     * @param date - The date to clone.
+     */
     clone(date) {
         return new Date(date.getTime());
     }
+    /**
+     * Creates a `Date` in the `Europe/Rome` timezone for the given year, month, and day.
+     * Throws an `Error` when any component is out of range.
+     * @param year  - Full four-digit year.
+     * @param month - Zero-based month index (0 = January, 11 = December).
+     * @param date  - Day-of-month (1-based).
+     */
     createDate(year, month, date) {
-        // Check for invalid month and date (except upper bound on date which we have to check after
-        // creating the Date).
         if (month < 0 || month > 11) {
             throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
         }
@@ -2598,32 +2895,41 @@ class DateFnsAdapter extends DateAdapter {
         const result = new Date();
         result.setFullYear(year, month, date);
         result.setHours(0, 0, 0, 0);
-        const result2 = new TZDate(result, "Europe/Rome");
-        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        const result2 = new TZDate(result, 'Europe/Rome');
         if (result2.getMonth() !== month) {
             throw Error(`Invalid date "${date}" for month with index "${month}".`);
         }
         return result2;
     }
+    /**
+     * Returns today's date in the local timezone.
+     */
     today() {
         return new Date();
     }
+    /**
+     * Parses a value into a `Date`.
+     * - Strings are first attempted as ISO 8601, then matched against each format in `parseFormat`.
+     * - Numbers are treated as Unix timestamps (milliseconds).
+     * - Existing `Date` instances are cloned.
+     * @param value       - The value to parse.
+     * @param parseFormat - A format string or an array of format strings (date-fns tokens).
+     * @returns A valid `Date` in `Europe/Rome`, an invalid sentinel, or `null` for unrecognised input.
+     */
     parse(value, parseFormat) {
         if (typeof value === 'string' && value.length > 0) {
-            let iso8601Date = parseISO(value);
+            const iso8601Date = parseISO(value);
             if (this.isValid(iso8601Date)) {
-                iso8601Date = new TZDate(iso8601Date, "Europe/Rome");
-                return iso8601Date;
+                return new TZDate(iso8601Date, 'Europe/Rome');
             }
             const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
-            if (!parseFormat.length) {
+            if (!formats.length) {
                 throw Error('Formats array must not be empty.');
             }
             for (const currentFormat of formats) {
-                let fromFormat = parse(value, currentFormat, new Date(), { locale: this.locale });
+                const fromFormat = parse(value, currentFormat, new Date(), { locale: this.locale });
                 if (this.isValid(fromFormat)) {
-                    fromFormat = new TZDate(fromFormat, "Europe/Rome");
-                    return fromFormat;
+                    return new TZDate(fromFormat, 'Europe/Rome');
                 }
             }
             return this.invalid();
@@ -2634,30 +2940,56 @@ class DateFnsAdapter extends DateAdapter {
         else if (value instanceof Date) {
             return this.clone(value);
         }
-        return undefined;
+        return null;
     }
+    /**
+     * Formats a `Date` using the given date-fns display format string.
+     * Throws an `Error` when `date` is not valid.
+     * @param date          - The date to format.
+     * @param displayFormat - A date-fns format string (e.g. `'P'`, `'LLL uuuu'`).
+     */
     format(date, displayFormat) {
         if (!this.isValid(date)) {
             throw Error('DateFnsAdapter: Cannot format invalid date.');
         }
         return format(date, displayFormat, { locale: this.locale });
     }
+    /**
+     * Adds the given number of whole years to a date.
+     * @param date  - The base date.
+     * @param years - Number of years to add (can be negative).
+     */
     addCalendarYears(date, years) {
         return addYears(date, years);
     }
+    /**
+     * Adds the given number of whole months to a date.
+     * @param date   - The base date.
+     * @param months - Number of months to add (can be negative).
+     */
     addCalendarMonths(date, months) {
         return addMonths(date, months);
     }
+    /**
+     * Adds the given number of whole days to a date.
+     * @param date - The base date.
+     * @param days - Number of days to add (can be negative).
+     */
     addCalendarDays(date, days) {
         return addDays(date, days);
     }
+    /**
+     * Serialises a date to an ISO 8601 date string (`yyyy-MM-dd`).
+     * @param date - The date to serialise.
+     */
     toIso8601(date) {
         return formatISO(date, { representation: 'date' });
     }
     /**
-     * Returns the given value if given a valid Date or undefined. Deserializes valid ISO 8601 strings
-     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into undefined. Returns an
-     * invalid date for all other values.
+     * Returns the given value when it is a valid `Date`, or `null` for an empty string.
+     * Deserialises valid ISO 8601 strings into `Date` instances.
+     * Delegates all other values to the base-class implementation.
+     * @param value - The raw value to deserialise.
      */
     deserialize(value) {
         if (typeof value === 'string') {
@@ -2671,12 +3003,23 @@ class DateFnsAdapter extends DateAdapter {
         }
         return super.deserialize(value);
     }
+    /**
+     * Returns `true` when `obj` is an instance of `Date`.
+     * @param obj - The object to test.
+     */
     isDateInstance(obj) {
         return isDate(obj);
     }
+    /**
+     * Returns `true` when `date` represents a valid point in time.
+     * @param date - The date to validate.
+     */
     isValid(date) {
         return isValid(date);
     }
+    /**
+     * Returns a sentinel `Date` that represents an invalid date (`new Date(NaN)`).
+     */
     invalid() {
         return new Date(NaN);
     }
@@ -2712,21 +3055,27 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }] });
 
+/**
+ * Directive that removes focus from the host element after it is clicked,
+ * preventing the browser from keeping a visible focus ring post-interaction.
+ * Apply `removeFocus` to any focusable element (e.g. a button).
+ */
 class RemoveFocusDirective {
     constructor() {
         this.elementRef = inject(ElementRef);
     }
-    onClick(_event) {
-        // Controllo null safety
-        if (this.elementRef?.nativeElement && typeof this.elementRef.nativeElement.blur === 'function') {
-            // Piccolo delay per permettere al click di completarsi
-            setTimeout(() => {
-                this.elementRef.nativeElement.blur();
-            }, 0);
+    /**
+     * Handles click events on the host element and blurs it on the next event-loop tick
+     * so that the click action completes before focus is removed.
+     */
+    onClick() {
+        const el = this.elementRef.nativeElement;
+        if (el && typeof el.blur === 'function') {
+            setTimeout(() => el.blur(), 0);
         }
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RemoveFocusDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
-    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RemoveFocusDirective, isStandalone: true, selector: "[removeFocus]", host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "21.2.9", type: RemoveFocusDirective, isStandalone: true, selector: "[removeFocus]", host: { listeners: { "click": "onClick()" } }, ngImport: i0 }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImport: i0, type: RemoveFocusDirective, decorators: [{
             type: Directive,
@@ -2736,13 +3085,23 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.9", ngImpor
                 }]
         }], propDecorators: { onClick: [{
                 type: HostListener,
-                args: ['click', ['$event']]
+                args: ['click']
             }] } });
 
+/**
+ * Pipe that converts a Markdown string to sanitized HTML using `SystemUtils.markdownToHtml`.
+ *
+ * Usage: `{{ text | formatMarkdown }}`
+ */
 class FormatMarkdownPipe {
     constructor() {
         this.sanitizer = inject(DomSanitizer);
     }
+    /**
+     * Transforms a Markdown string into sanitized HTML.
+     * @param value - The Markdown input to convert. Treated as an empty string when `undefined`.
+     * @returns A `SafeHtml` value that can be rendered with `[innerHTML]`.
+     */
     transform(value) {
         return this.sanitizer.bypassSecurityTrustHtml(SystemUtils.markdownToHtml(value ?? ''));
     }