@arsedizioni/ars-utils 22.0.82 → 22.0.84

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

@@ -1,8 +1,9 @@
 import * as i0 from '@angular/core';
-import { inject, Injectable, makeEnvironmentProviders, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, effect, Pipe, EventEmitter, signal, computed, Service, PLATFORM_ID, RendererFactory2 } from '@angular/core';
+import { InjectionToken, inject, Injectable, makeEnvironmentProviders, ElementRef, afterNextRender, Directive, input, DestroyRef, HostListener, output, forwardRef, effect, Pipe, EventEmitter, signal, computed, Service, PLATFORM_ID, RendererFactory2 } from '@angular/core';
 import { DateAdapter, MAT_DATE_LOCALE, MAT_DATE_FORMATS } from '@angular/material/core';
 import { TZDate } from '@date-fns/tz';
 import { format, getYear, getMonth, getDate, getDay, getDaysInMonth, parseISO, parse, addYears, addMonths, addDays, isDate, isValid, addSeconds, endOfDay } from 'date-fns';
+import { HTTP_INTERCEPTORS } from '@angular/common/http';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
 import { Subject, filter as filter$1, map as map$1, BehaviorSubject } from 'rxjs';
 import { debounceTime, filter, map } from 'rxjs/operators';
@@ -12,6 +13,189 @@ import { DomSanitizer } from '@angular/platform-browser';
 import { SelectionModel } from '@angular/cdk/collections';
 import { isPlatformBrowser } from '@angular/common';
 
+/** Default application timezone: all dates are serialised as Europe/Rome wall-clock values. */
+const DEFAULT_TIME_ZONE = 'Europe/Rome';
+/**
+ * IANA timezone used to serialise dates towards the backend.
+ * Override it in the application providers to run the same code in another zone:
+ * `{ provide: ARS_TIME_ZONE, useValue: 'Europe/Zurich' }`.
+ */
+const ARS_TIME_ZONE = new InjectionToken('ARS_TIME_ZONE', {
+    providedIn: 'root',
+    factory: () => DEFAULT_TIME_ZONE,
+});
+/** Naive local datetime pattern (no timezone designator): the server reads it as DateTimeKind.Unspecified. */
+const NAIVE_PATTERN = "yyyy-MM-dd'T'HH:mm:ss";
+/**
+ * Returns `true` for payloads that must be forwarded untouched
+ * (binary or already-encoded bodies).
+ * @param body - The request body to test.
+ */
+function isOpaqueBody(body) {
+    return (body instanceof FormData ||
+        body instanceof Blob ||
+        body instanceof ArrayBuffer ||
+        ArrayBuffer.isView(body) ||
+        body instanceof URLSearchParams ||
+        typeof body === 'string');
+}
+/**
+ * Recursively replaces every `Date` found in `value` with its naive local
+ * datetime string, returning a NEW structure: the original object graph — and
+ * therefore any bound form model — is never mutated.
+ *
+ * @param value    - The value to normalise (object, array, Date or primitive).
+ * @param timeZone - IANA timezone used to compute the wall-clock value.
+ * @param seen     - Guard against circular references.
+ * @returns The normalised value, safe to hand over to `JSON.stringify`.
+ */
+function normalizeDates(value, timeZone, seen) {
+    if (value instanceof Date) {
+        // Invalid dates would make format() throw a RangeError: send null instead.
+        if (isNaN(value.getTime()))
+            return null;
+        return format(new TZDate(value.getTime(), timeZone), NAIVE_PATTERN);
+    }
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (isOpaqueBody(value))
+        return value;
+    // Circular reference: leave it as is, JSON.stringify will report it anyway.
+    if (seen.has(value))
+        return value;
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return value.map(item => normalizeDates(item, timeZone, seen));
+    }
+    const source = value;
+    const result = {};
+    for (const key of Object.keys(source)) {
+        result[key] = normalizeDates(source[key], timeZone, seen);
+    }
+    return result;
+}
+/**
+ * Rewrites the request body, if any, replacing Dates with naive local strings.
+ * Shared by the functional and the class-based interceptor.
+ * @param req      - The outgoing request.
+ * @param timeZone - IANA timezone used to compute the wall-clock value.
+ * @returns The original request when there is nothing to convert, a clone otherwise.
+ */
+function localizeRequest(req, timeZone) {
+    const body = req.body;
+    if (body === null || body === undefined || isOpaqueBody(body))
+        return req;
+    return req.clone({ body: normalizeDates(body, timeZone, new WeakSet()) });
+}
+/**
+ * Functional interceptor that serialises every `Date` in an outgoing request
+ * body as a naive local datetime string (`yyyy-MM-ddTHH:mm:ss`: no `Z`, no offset).
+ *
+ * WHY: `JSON.stringify` calls `Date.prototype.toJSON`, which emits a UTC instant.
+ * A date picked as 29/07/2026 00:00 in Rome (UTC+2) becomes
+ * `2026-07-28T22:00:00.000Z`, so the server stores the 28th — the classic
+ * "off by one day" bug. Sending the wall-clock value instead makes
+ * System.Text.Json produce a `DateTime` with `Kind = Unspecified` and the exact
+ * day/time the user selected.
+ *
+ * This is the single serialisation boundary of the application: no call site has
+ * to convert anything, and it also covers dates that lost a per-instance
+ * `toJSON` along the way (e.g. after `structuredClone`).
+ *
+ * Register it explicitly in `provideHttpClient(withInterceptors([...]))`.
+ * If you would rather have the library register it for you, use
+ * {@link provideArsLocalDates} instead.
+ *
+ * @example
+ * provideHttpClient(withInterceptors([
+ *   arsLocalDateInterceptor,
+ *   evolutionAuthInterceptor(...),
+ * ]));
+ */
+const arsLocalDateInterceptor = (req, next) => next(localizeRequest(req, inject(ARS_TIME_ZONE)));
+/**
+ * Class-based twin of {@link arsLocalDateInterceptor}.
+ *
+ * Exists because a functional `HttpInterceptorFn` can ONLY be registered inside
+ * `provideHttpClient(withInterceptors([...]))`, while a class registered on the
+ * `HTTP_INTERCEPTORS` multi-token can be contributed by any `EnvironmentProviders` —
+ * which is what lets {@link provideArsLocalDates} (and `provideArsDateFns`) wire it up
+ * on their own.
+ *
+ * REQUIRES `withInterceptorsFromDi()` in the application's `provideHttpClient()`:
+ * without it Angular never reads `HTTP_INTERCEPTORS` and this interceptor is
+ * silently skipped.
+ */
+class ArsLocalDateInterceptor {
+    constructor() {
+        this.timeZone = inject(ARS_TIME_ZONE);
+    }
+    /**
+     * Normalises the request body before handing it to the next handler.
+     * @param req  - The outgoing request.
+     * @param next - The next handler in the chain.
+     */
+    intercept(req, next) {
+        return next.handle(localizeRequest(req, this.timeZone));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ArsLocalDateInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ArsLocalDateInterceptor }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: ArsLocalDateInterceptor, decorators: [{
+            type: Injectable
+        }] });
+/**
+ * Standalone providers for date serialisation towards the backend.
+ *
+ * Registers {@link ArsLocalDateInterceptor} so that every `Date` in a request
+ * body travels as a naive local datetime string instead of a UTC instant.
+ *
+ * IMPORTANT: the application MUST call `withInterceptorsFromDi()`, otherwise
+ * these providers have no effect at all (no error is raised).
+ *
+ * @param timeZone - IANA timezone name (default: `Europe/Rome`).
+ *
+ * @example
+ * providers: [
+ *   provideArsLocalDates(),
+ *   provideHttpClient(withInterceptors([evolutionAuthInterceptor(...)]), withInterceptorsFromDi()),
+ * ]
+ */
+function provideArsLocalDates(timeZone = DEFAULT_TIME_ZONE) {
+    return makeEnvironmentProviders([
+        { provide: ARS_TIME_ZONE, useValue: timeZone },
+        { provide: HTTP_INTERCEPTORS, useClass: ArsLocalDateInterceptor, multi: true },
+    ]);
+}
+/**
+ * Formats a date as a date-only ISO string (`yyyy-MM-dd`) using its wall-clock
+ * calendar day in the given timezone. Use it for query-string parameters and for
+ * DTO fields mapped to a .NET `DateOnly`, which the interceptor cannot detect.
+ *
+ * @param value    - The date to serialise.
+ * @param timeZone - IANA timezone name (default: `Europe/Rome`).
+ * @returns The `yyyy-MM-dd` string, or `undefined` for empty/invalid input.
+ */
+function toLocalDateOnlyString(value, timeZone = DEFAULT_TIME_ZONE) {
+    if (!value || isNaN(value.getTime()))
+        return undefined;
+    return format(new TZDate(value.getTime(), timeZone), 'yyyy-MM-dd');
+}
+/**
+ * Formats a date as a naive local datetime string (`yyyy-MM-ddTHH:mm:ss`), the
+ * same representation produced by the interceptor. Useful for query-string
+ * parameters, which never pass through the request body.
+ *
+ * @param value    - The date to serialise.
+ * @param timeZone - IANA timezone name (default: `Europe/Rome`).
+ * @returns The naive datetime string, or `undefined` for empty/invalid input.
+ */
+function toLocalDateTimeString(value, timeZone = DEFAULT_TIME_ZONE) {
+    if (!value || isNaN(value.getTime()))
+        return undefined;
+    return format(new TZDate(value.getTime(), timeZone), NAIVE_PATTERN);
+}
+
 /**
  * Creates an array of the given length, filling each slot with the result of `valueFunction`.
  * @param length        - Number of elements to create.
@@ -411,13 +595,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImpor
  *   providers: [provideArsDateFns()]
  * });
  */
-function provideArsDateFns() {
+function provideArsDateFns(options = {}) {
+    const { timeZone = 'Europe/Rome', httpSerialization = true } = options;
     return makeEnvironmentProviders([
-        {
-            provide: DateAdapter,
-            useClass: DateFnsAdapter
-        },
-        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS }
+        { provide: DateAdapter, useClass: DateFnsAdapter },
+        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS },
+        ...(httpSerialization ? [provideArsLocalDates(timeZone)] : []),
     ]);
 }
 
@@ -1748,22 +1931,30 @@ class SystemUtils {
         }
     }
     /**
-     * Return an italian local date
-     * @param value  : the date
-     * @returns     : the new date
+     * Converts a Date, timestamp or ISO string into a Europe/Rome Date whose JSON serialisation
+     * emits a naive local datetime string ("yyyy-MM-dd'T'HH:mm:ss"), with no timezone designator,
+     * so the wall-clock value round-trips to the server unchanged. Use this instead of `new Date(...)`
+     * when reviving dates received from the API, to stay consistent with the DateFnsAdapter (values
+     * entered through the datepicker already behave this way).
+     * @param value : the source Date, Unix timestamp (ms) or ISO string
+     * @returns     : a Europe/Rome Date serialising as naive local time, or undefined for empty/invalid input
      */
     static toLocalDate(value) {
-        // No value at all
-        if (!value)
+        if (value == null || value === '')
             return undefined;
-        // A string
-        if (typeof value === 'string' || value instanceof String)
-            value = this.parseDate(value);
-        // Not a date
-        if (!this.isValidDate(value))
+        const ms = value instanceof Date ? value.getTime()
+            : typeof value === 'number' ? value
+                : new Date(value).getTime();
+        if (isNaN(ms))
             return undefined;
-        // Update date
-        return new TZDate(value, "Europe/Rome");
+        const t = new TZDate(ms, 'Europe/Rome');
+        Object.defineProperty(t, 'toJSON', {
+            value: () => format(t, "yyyy-MM-dd'T'HH:mm:ss"),
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        return t;
     }
     /**
      * Update a DateInterval object according to a string