@arsedizioni/ars-utils 22.6.85 → 22.6.88

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

@@ -1,738 +1,357 @@
-import * as i0 from '@angular/core';
-import { inject, Injectable, makeEnvironmentProviders, InjectionToken } 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 } from 'date-fns';
-import { HttpResponse, HTTP_INTERCEPTORS } from '@angular/common/http';
-import { map } from 'rxjs';
-
-/**
- * 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.
- */
+import * as i0 from "@angular/core";
+import { Injectable, InjectionToken, inject, makeEnvironmentProviders } from "@angular/core";
+import { DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE } from "@angular/material/core";
+import { TZDate } from "@date-fns/tz";
+import { addDays, addMonths, addSeconds, addYears, format, getDate, getDay, getDaysInMonth, getMonth, getYear, isDate, isValid, parse, parseISO } from "date-fns";
+import { HTTP_INTERCEPTORS, HttpResponse } from "@angular/common/http";
+import { map } from "rxjs";
 function range(length, valueFunction) {
-    const valuesArray = Array(length);
-    for (let i = 0; i < length; i++) {
-        valuesArray[i] = valueFunction(i);
-    }
-    return valuesArray;
+	const valuesArray = Array(length);
+	for (let i = 0; i < length; i++) valuesArray[i] = valueFunction(i);
+	return valuesArray;
 }
-// date-fns doesn't have a way to read/print month names or days of the week directly,
-// so we get them by formatting a date with a format that produces the desired month/day.
 const MONTH_FORMATS = {
-    long: 'LLLL',
-    short: 'LLL',
-    narrow: 'LLLLL',
+	long: "LLLL",
+	short: "LLL",
+	narrow: "LLLLL"
 };
 const DAY_OF_WEEK_FORMATS = {
-    long: 'EEEE',
-    short: 'EEE',
-    narrow: 'EEEEE',
+	long: "EEEE",
+	short: "EEE",
+	narrow: "EEEEE"
 };
 const MAT_DATE_FNS_FORMATS = {
-    parse: {
-        dateInput: 'P',
-        timeInput: ['p', 'HH:mm', 'H:mm'],
-    },
-    display: {
-        dateInput: 'P',
-        monthYearLabel: 'LLL uuuu',
-        dateA11yLabel: 'PP',
-        monthYearA11yLabel: 'LLLL uuuu',
-        timeInput: 'p',
-        timeOptionLabel: 'p',
-    },
+	parse: {
+		dateInput: "P",
+		timeInput: [
+			"p",
+			"HH:mm",
+			"H:mm"
+		]
+	},
+	display: {
+		dateInput: "P",
+		monthYearLabel: "LLL uuuu",
+		dateA11yLabel: "PP",
+		monthYearA11yLabel: "LLLL uuuu",
+		timeInput: "p",
+		timeOptionLabel: "p"
+	}
 };
-/**
- * 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 });
-        if (matDateLocale && typeof matDateLocale === 'object') {
-            this.setLocale(matDateLocale);
-        }
-    }
-    /**
-     * Wraps a date/instant into a Europe/Rome TZDate whose JSON serialisation emits a
-     * naive local datetime string ("yyyy-MM-dd'T'HH:mm:ss") instead of a UTC instant,
-     * so the wall-clock value the user entered is preserved end-to-end (no timezone shift).
-     * @param value - The source Date or Unix timestamp in milliseconds.
-     * @returns a Europe/Rome TZDate whose toJSON yields a naive local datetime string.
-     */
-    static toLocal(value) {
-        const ms = typeof value === 'number' ? value : value.getTime();
-        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;
-    }
-    /**
-     * 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, {
-                day: 'numeric',
-                timeZone: 'utc',
-            })
-            : null;
-        return range(31, i => {
-            if (dtf) {
-                // date-fns doesn't appear to support this functionality.
-                // Fall back to `Intl` on supported browsers.
-                const date = new Date();
-                date.setUTCFullYear(2017, 0, i + 1);
-                date.setUTCHours(0, 0, 0, 0);
-                return dtf.format(date).replace(/[\u200e\u200f]/g, '');
-            }
-            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;
-    }
-    /**
-     * 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 DateFnsAdapter.toLocal(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) {
-        if (month < 0 || month > 11) {
-            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
-        }
-        if (date < 1) {
-            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
-        }
-        if (month < 0 || month > 11) {
-            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
-        }
-        const result = new TZDate(year, month, date, 0, 0, 0, 0, 'Europe/Rome');
-        if (result.getMonth() !== month) {
-            throw Error(`Invalid date "${date}" for month with index "${month}".`);
-        }
-        return DateFnsAdapter.toLocal(result);
-    }
-    /**
-     * Returns the current date and time in the Europe/Rome timezone, preserving the wall-clock value.
-     */
-    today() {
-        return DateFnsAdapter.toLocal(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 (value === null || value === undefined) {
-            return null;
-        }
-        if (typeof value === 'string') {
-            const trimmedValue = value.trim();
-            if (trimmedValue.length === 0) {
-                return null;
-            }
-            const iso8601Date = parseISO(trimmedValue);
-            if (this.isValid(iso8601Date)) {
-                return DateFnsAdapter.toLocal(iso8601Date);
-            }
-            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
-            if (!formats.length) {
-                throw Error('Formats array must not be empty.');
-            }
-            for (const currentFormat of formats) {
-                const fromFormat = parse(trimmedValue, currentFormat, new TZDate(new Date(), 'Europe/Rome'), {
-                    locale: this.locale
-                });
-                if (this.isValid(fromFormat)) {
-                    return DateFnsAdapter.toLocal(fromFormat);
-                }
-            }
-            return this.invalid();
-        }
-        else if (typeof value === 'number') {
-            return DateFnsAdapter.toLocal(value);
-        }
-        else if (value instanceof Date) {
-            return this.clone(value);
-        }
-        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 DateFnsAdapter.toLocal(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 DateFnsAdapter.toLocal(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 DateFnsAdapter.toLocal(addDays(date, days));
-    }
-    /**
-     * Serialises a date to an ISO 8601 date-only string (`yyyy-MM-dd`) using its Europe/Rome calendar day,
-     * independent of the browser timezone.
-     * @param date - The date to serialise.
-     * @returns the yyyy-MM-dd string for the date in Europe/Rome.
-     */
-    toIso8601(date) {
-        return format(new TZDate(date, 'Europe/Rome'), 'yyyy-MM-dd');
-    }
-    /**
-     * 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 (value === null || value === undefined) {
-            return null;
-        }
-        if (typeof value === 'string') {
-            const trimmedValue = value.trim();
-            if (trimmedValue.length === 0) {
-                return null;
-            }
-            const date = parseISO(trimmedValue);
-            if (this.isValid(date)) {
-                return DateFnsAdapter.toLocal(date);
-            }
-        }
-        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);
-    }
-    /**
-     * Returns the hours component (0-23) of the given date.
-     * @param date - The source date.
-     */
-    getHours(date) {
-        return date.getHours();
-    }
-    /**
-     * Returns the minutes component (0-59) of the given date.
-     * @param date - The source date.
-     */
-    getMinutes(date) {
-        return date.getMinutes();
-    }
-    /**
-     * Returns the seconds component (0-59) of the given date.
-     * @param date - The source date.
-     */
-    getSeconds(date) {
-        return date.getSeconds();
-    }
-    /**
-     * Returns a clone of `target` with its time-of-day set to the given hours/minutes/seconds,
-     * keeping the date part unchanged.
-     * @param target  - The date whose time should be set.
-     * @param hours   - New hours (0-23).
-     * @param minutes - New minutes (0-59).
-     * @param seconds - New seconds (0-59).
-     */
-    setTime(target, hours, minutes, seconds) {
-        const clone = this.clone(target);
-        clone.setHours(hours, minutes, seconds, 0);
-        return clone;
-    }
-    /**
-     * Adds the given number of seconds to a date.
-     * @param date   - The base date.
-     * @param amount - Number of seconds to add (can be negative).
-     */
-    addSeconds(date, amount) {
-        return DateFnsAdapter.toLocal(addSeconds(date, amount));
-    }
-    /**
-     * Parses a time-only value into a `Date` (today's date, in `Europe/Rome`, with the parsed
-     * time-of-day set). The wall-clock time is preserved exactly as entered.
-     * @param value       - The value to parse (a string, or an existing `Date`).
-     * @param parseFormat - A format string or an array of format strings (date-fns tokens).
-     * @returns the parsed Date, an invalid sentinel, or null for unrecognised input.
-     */
-    parseTime(value, parseFormat) {
-        if (typeof value === 'string' && value.length > 0) {
-            const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
-            if (!formats.length) {
-                throw Error('Formats array must not be empty.');
-            }
-            const referenceDate = new TZDate(new Date(), 'Europe/Rome');
-            for (const currentFormat of formats) {
-                const fromFormat = parse(value, currentFormat, referenceDate, { locale: this.locale });
-                if (this.isValid(fromFormat)) {
-                    return DateFnsAdapter.toLocal(fromFormat);
-                }
-            }
-            return this.invalid();
-        }
-        else if (value instanceof Date) {
-            return this.clone(value);
-        }
-        return null;
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: DateFnsAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: DateFnsAdapter }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: DateFnsAdapter, decorators: [{
-            type: Injectable
-        }], ctorParameters: () => [] });
-/**
- * Standalone providers for the ARS date-fns adapter.
- *
- * Configures Angular Material to use {@link DateFnsAdapter} (Europe/Rome timezone)
- * and the matching {@link MAT_DATE_FNS_FORMATS}. Also supports `mat-timepicker` since
- * {@link DateFnsAdapter} implements the time-related `DateAdapter` methods.
- *
- * @example
- * bootstrapApplication(AppComponent, {
- *   providers: [provideArsDateFns()]
- * });
- */
+var DateFnsAdapter = class DateFnsAdapter extends DateAdapter {
+	constructor() {
+		super();
+		const matDateLocale = inject(MAT_DATE_LOCALE, { optional: true });
+		if (matDateLocale && typeof matDateLocale === "object") this.setLocale(matDateLocale);
+	}
+	static toLocal(value) {
+		const ms = typeof value === "number" ? value : value.getTime();
+		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;
+	}
+	getYear(date) {
+		return getYear(date);
+	}
+	getMonth(date) {
+		return getMonth(date);
+	}
+	getDate(date) {
+		return getDate(date);
+	}
+	getDayOfWeek(date) {
+		return getDay(date);
+	}
+	getMonthNames(style) {
+		const pattern = MONTH_FORMATS[style];
+		return range(12, (i) => this.format(new Date(2017, i, 1), pattern));
+	}
+	getDateNames() {
+		const dtf = typeof Intl !== "undefined" ? new Intl.DateTimeFormat(this.locale?.code, {
+			day: "numeric",
+			timeZone: "utc"
+		}) : null;
+		return range(31, (i) => {
+			if (dtf) {
+				const date = /* @__PURE__ */ new Date();
+				date.setUTCFullYear(2017, 0, i + 1);
+				date.setUTCHours(0, 0, 0, 0);
+				return dtf.format(date).replace(/[\u200e\u200f]/g, "");
+			}
+			return String(i + 1);
+		});
+	}
+	getDayOfWeekNames(style) {
+		const pattern = DAY_OF_WEEK_FORMATS[style];
+		return range(7, (i) => this.format(new Date(2017, 0, i + 1), pattern));
+	}
+	getYearName(date) {
+		return this.format(date, "y");
+	}
+	getFirstDayOfWeek() {
+		return this.locale?.options?.weekStartsOn ?? 0;
+	}
+	getNumDaysInMonth(date) {
+		return getDaysInMonth(date);
+	}
+	clone(date) {
+		return DateFnsAdapter.toLocal(date.getTime());
+	}
+	createDate(year, month, date) {
+		if (month < 0 || month > 11) throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+		if (date < 1) throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+		if (month < 0 || month > 11) throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+		const result = new TZDate(year, month, date, 0, 0, 0, 0, "Europe/Rome");
+		if (result.getMonth() !== month) throw Error(`Invalid date "${date}" for month with index "${month}".`);
+		return DateFnsAdapter.toLocal(result);
+	}
+	today() {
+		return DateFnsAdapter.toLocal(/* @__PURE__ */ new Date());
+	}
+	parse(value, parseFormat) {
+		if (value === null || value === void 0) return null;
+		if (typeof value === "string") {
+			const trimmedValue = value.trim();
+			if (trimmedValue.length === 0) return null;
+			const iso8601Date = parseISO(trimmedValue);
+			if (this.isValid(iso8601Date)) return DateFnsAdapter.toLocal(iso8601Date);
+			const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+			if (!formats.length) throw Error("Formats array must not be empty.");
+			for (const currentFormat of formats) {
+				const fromFormat = parse(trimmedValue, currentFormat, new TZDate(/* @__PURE__ */ new Date(), "Europe/Rome"), { locale: this.locale });
+				if (this.isValid(fromFormat)) return DateFnsAdapter.toLocal(fromFormat);
+			}
+			return this.invalid();
+		} else if (typeof value === "number") return DateFnsAdapter.toLocal(value);
+		else if (value instanceof Date) return this.clone(value);
+		return null;
+	}
+	format(date, displayFormat) {
+		if (!this.isValid(date)) throw Error("DateFnsAdapter: Cannot format invalid date.");
+		return format(date, displayFormat, { locale: this.locale });
+	}
+	addCalendarYears(date, years) {
+		return DateFnsAdapter.toLocal(addYears(date, years));
+	}
+	addCalendarMonths(date, months) {
+		return DateFnsAdapter.toLocal(addMonths(date, months));
+	}
+	addCalendarDays(date, days) {
+		return DateFnsAdapter.toLocal(addDays(date, days));
+	}
+	toIso8601(date) {
+		return format(new TZDate(date, "Europe/Rome"), "yyyy-MM-dd");
+	}
+	deserialize(value) {
+		if (value === null || value === void 0) return null;
+		if (typeof value === "string") {
+			const trimmedValue = value.trim();
+			if (trimmedValue.length === 0) return null;
+			const date = parseISO(trimmedValue);
+			if (this.isValid(date)) return DateFnsAdapter.toLocal(date);
+		}
+		return super.deserialize(value);
+	}
+	isDateInstance(obj) {
+		return isDate(obj);
+	}
+	isValid(date) {
+		return isValid(date);
+	}
+	invalid() {
+		return /* @__PURE__ */ new Date(NaN);
+	}
+	getHours(date) {
+		return date.getHours();
+	}
+	getMinutes(date) {
+		return date.getMinutes();
+	}
+	getSeconds(date) {
+		return date.getSeconds();
+	}
+	setTime(target, hours, minutes, seconds) {
+		const clone = this.clone(target);
+		clone.setHours(hours, minutes, seconds, 0);
+		return clone;
+	}
+	addSeconds(date, amount) {
+		return DateFnsAdapter.toLocal(addSeconds(date, amount));
+	}
+	parseTime(value, parseFormat) {
+		if (typeof value === "string" && value.length > 0) {
+			const formats = Array.isArray(parseFormat) ? parseFormat : [parseFormat];
+			if (!formats.length) throw Error("Formats array must not be empty.");
+			const referenceDate = new TZDate(/* @__PURE__ */ new Date(), "Europe/Rome");
+			for (const currentFormat of formats) {
+				const fromFormat = parse(value, currentFormat, referenceDate, { locale: this.locale });
+				if (this.isValid(fromFormat)) return DateFnsAdapter.toLocal(fromFormat);
+			}
+			return this.invalid();
+		} else if (value instanceof Date) return this.clone(value);
+		return null;
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: DateFnsAdapter,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: DateFnsAdapter
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: DateFnsAdapter,
+	decorators: [{ type: Injectable }],
+	ctorParameters: () => []
+});
 function provideArsDateFns() {
-    return makeEnvironmentProviders([
-        {
-            provide: DateAdapter,
-            useClass: DateFnsAdapter
-        },
-        { provide: MAT_DATE_FORMATS, useValue: MAT_DATE_FNS_FORMATS }
-    ]);
+	return makeEnvironmentProviders([{
+		provide: DateAdapter,
+		useClass: DateFnsAdapter
+	}, {
+		provide: MAT_DATE_FORMATS,
+		useValue: MAT_DATE_FNS_FORMATS
+	}]);
 }
-
-/** 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,
+const DEFAULT_TIME_ZONE = "Europe/Rome";
+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";
-/**
- * What a string has to look like to be read back as a date: an ISO 8601 calendar date, optionally
- * followed by a time and by `Z` or an offset. Anchored at both ends, so a string that merely
- * *contains* a date ("Circolare del 2026-09-07") is left alone.
- */
 const ISO_DATE_PATTERN = /^(\d{4})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d{1,7}))?)?(Z|[+-]\d{2}:?\d{2})?)?$/;
-/** Shortest string that can be a date (`2026-09-07`), and the longest one worth testing. */
 const MIN_ISO_LENGTH = 10;
 const MAX_ISO_LENGTH = 33;
-/**
- * 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');
+	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;
+	if (value instanceof Date) {
+		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;
+	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()) });
+	const body = req.body;
+	if (body === null || body === void 0 || isOpaqueBody(body)) return req;
+	return req.clone({ body: normalizeDates(body, timeZone, /* @__PURE__ */ new WeakSet()) });
 }
-/**
- * Reads an ISO string back into a `Date`, or returns `undefined` when it is not one.
- *
- * The mirror image of {@link normalizeDates}. A value that carries `Z` or an offset names an
- * instant and is parsed as it stands; a naive one is a wall-clock value in `timeZone` — that is
- * what the request side wrote, and what `System.Text.Json` emits for a `DateTime` with
- * `Kind = Unspecified` — so it is rebuilt component by component through {@link TZDate}.
- *
- * Reading a naive value with `new Date(s)` instead would be right for a datetime and wrong for a
- * bare date: the ECMAScript spec reads `2026-09-07` as UTC midnight and `2026-09-07T00:00:00` as
- * local midnight. That difference is the off-by-one-day this file exists to prevent, arriving from
- * the other direction.
- *
- * @param value    - The string to read.
- * @param timeZone - IANA timezone the naive values are expressed in.
- * @returns The date, or `undefined` when the string is not an ISO date.
- */
 function parseLocalDate(value, timeZone) {
-    const m = ISO_DATE_PATTERN.exec(value);
-    if (!m)
-        return undefined;
-    const [, year, month, day, hours, minutes, seconds, fraction, zone] = m;
-    const date = zone
-        ? new Date(value)
-        : new Date(new TZDate(+year, +month - 1, +day, hours ? +hours : 0, minutes ? +minutes : 0, seconds ? +seconds : 0, fraction ? +fraction.slice(0, 3).padEnd(3, '0') : 0, timeZone).getTime());
-    if (isNaN(date.getTime()))
-        return undefined;
-    // "2026-02-31" matches the pattern and rolls over to March: a day that does not exist was not a
-    // date to begin with, and the original string says more than a wrong Date would.
-    if (!zone) {
-        const check = new TZDate(date.getTime(), timeZone);
-        if (check.getFullYear() !== +year || check.getMonth() !== +month - 1 || check.getDate() !== +day) {
-            return undefined;
-        }
-    }
-    return date;
+	const m = ISO_DATE_PATTERN.exec(value);
+	if (!m) return void 0;
+	const [, year, month, day, hours, minutes, seconds, fraction, zone] = m;
+	const date = zone ? new Date(value) : new Date(new TZDate(+year, +month - 1, +day, hours ? +hours : 0, minutes ? +minutes : 0, seconds ? +seconds : 0, fraction ? +fraction.slice(0, 3).padEnd(3, "0") : 0, timeZone).getTime());
+	if (isNaN(date.getTime())) return void 0;
+	if (!zone) {
+		const check = new TZDate(date.getTime(), timeZone);
+		if (check.getFullYear() !== +year || check.getMonth() !== +month - 1 || check.getDate() !== +day) return;
+	}
+	return date;
 }
-/**
- * Recursively replaces every ISO date string found in `value` with a `Date`, returning a NEW
- * structure, exactly as {@link normalizeDates} does on the way out.
- *
- * Only whole strings are considered, and only inside an object or an array: a top-level string
- * body — a rendered document, a plain-text answer — is never touched.
- *
- * @param value    - The value to revive (object, array or primitive).
- * @param timeZone - IANA timezone the naive values are expressed in.
- * @param seen     - Guard against circular references.
- * @returns The revived value.
- */
 function reviveDates(value, timeZone, seen) {
-    if (typeof value === 'string') {
-        if (value.length < MIN_ISO_LENGTH || value.length > MAX_ISO_LENGTH)
-            return value;
-        return parseLocalDate(value, timeZone) ?? value;
-    }
-    if (value === null || typeof value !== 'object')
-        return value;
-    if (value instanceof Date || isOpaqueBody(value))
-        return value;
-    // Circular reference: leave it as is rather than looping forever.
-    if (seen.has(value))
-        return value;
-    seen.add(value);
-    if (Array.isArray(value)) {
-        return value.map(item => reviveDates(item, timeZone, seen));
-    }
-    const source = value;
-    const result = {};
-    for (const key of Object.keys(source)) {
-        result[key] = reviveDates(source[key], timeZone, seen);
-    }
-    return result;
+	if (typeof value === "string") {
+		if (value.length < MIN_ISO_LENGTH || value.length > MAX_ISO_LENGTH) return value;
+		return parseLocalDate(value, timeZone) ?? value;
+	}
+	if (value === null || typeof value !== "object") return value;
+	if (value instanceof Date || isOpaqueBody(value)) return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) return value.map((item) => reviveDates(item, timeZone, seen));
+	const source = value;
+	const result = {};
+	for (const key of Object.keys(source)) result[key] = reviveDates(source[key], timeZone, seen);
+	return result;
 }
-/**
- * Rewrites a response body, if any, replacing ISO date strings with Dates.
- * Shared by the functional and the class-based interceptor.
- * @param event    - The event coming back from the chain.
- * @param timeZone - IANA timezone the naive values are expressed in.
- * @returns The original event when there is nothing to convert, a clone otherwise.
- */
 function localizeResponse(event, timeZone) {
-    if (!(event instanceof HttpResponse))
-        return event;
-    const body = event.body;
-    if (body === null || typeof body !== 'object' || isOpaqueBody(body))
-        return event;
-    return event.clone({ body: reviveDates(body, timeZone, new WeakSet()) });
+	if (!(event instanceof HttpResponse)) return event;
+	const body = event.body;
+	if (body === null || typeof body !== "object" || isOpaqueBody(body)) return event;
+	return event.clone({ body: reviveDates(body, timeZone, /* @__PURE__ */ new WeakSet()) });
 }
-/**
- * Functional interceptor that closes the date serialisation boundary of the application, in both
- * directions: it writes the dates of every request and reads back those of every response.
- *
- * ON THE WAY OUT every `Date` of the request body is serialised as a naive local datetime string
- * (`yyyy-MM-ddTHH:mm:ss`: no `Z`, no offset). `JSON.stringify` would otherwise call
- * `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". Sending the wall-clock value instead makes System.Text.Json produce a
- * `DateTime` with `Kind = Unspecified` and the exact day/time the user selected.
- *
- * ON THE WAY BACK every ISO date string of the response body is read into a `Date`. Models declare
- * `Date`, but `HttpClient` only runs `JSON.parse`, which has no notion of dates, so without this
- * every one of those properties holds a `string` at runtime and the declared type is a promise
- * nobody keeps. It goes unnoticed for a long time — the `date` pipe accepts strings and
- * {@link DateFnsAdapter.deserialize} parses them for the datepickers — until somebody calls a
- * method of `Date` on one and gets a `TypeError`, or writes `x.someDate = new Date(x.someDate)` to
- * work around it one call site at a time.
- *
- * With both halves here no call site has to convert anything, in either direction, and dates that
- * lost a per-instance `toJSON` along the way (after a `structuredClone`, say) are covered too.
- *
- * Both halves are idempotent — a body already normalised holds no `Date`, a body already revived
- * holds no ISO string — so registering this twice, or over a chain that has already converted,
- * changes nothing.
- *
- * REGISTER IT FIRST in `withInterceptors([...])`. The first interceptor of the array is the first
- * to see the request and the LAST to see the response, which is what this one wants in both
- * directions: every other interceptor keeps seeing the body exactly as the server sent it.
- *
- * If you would rather have the library register it for you, use {@link provideArsLocalDates}.
- *
- * @example
- * provideHttpClient(withInterceptors([
- *   arsLocalDateInterceptor,
- *   evolutionAuthInterceptor(...),
- * ]));
- */
 const arsLocalDateInterceptor = (req, next) => {
-    const timeZone = inject(ARS_TIME_ZONE);
-    return next(localizeRequest(req, timeZone)).pipe(map(event => localizeResponse(event, timeZone)));
+	const timeZone = inject(ARS_TIME_ZONE);
+	return next(localizeRequest(req, timeZone)).pipe(map((event) => localizeResponse(event, timeZone)));
 };
-/**
- * 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 dates of the request and revives those of the response.
-     * @param req  - The outgoing request.
-     * @param next - The next handler in the chain.
-     * @returns The stream of events, with the dates of the response body revived.
-     */
-    intercept(req, next) {
-        return next.handle(localizeRequest(req, this.timeZone))
-            .pipe(map(event => localizeResponse(event, this.timeZone)));
-    }
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ArsLocalDateInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
-    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ArsLocalDateInterceptor }); }
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.1.7", ngImport: i0, type: ArsLocalDateInterceptor, decorators: [{
-            type: Injectable
-        }] });
-/**
- * Standalone providers for date conversion towards and from the backend.
- *
- * Registers {@link ArsLocalDateInterceptor}, so that every `Date` of a request body travels as a
- * naive local datetime string instead of a UTC instant, and every ISO date string of a response
- * body comes back as the `Date` the model declares.
- *
- * 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`).
- * @returns The environment providers to add to the application configuration.
- *
- * @example
- * providers: [
- *   provideArsLocalDates(),
- *   provideHttpClient(withInterceptors([evolutionAuthInterceptor(...)]), withInterceptorsFromDi()),
- * ]
- */
+var ArsLocalDateInterceptor = class ArsLocalDateInterceptor {
+	constructor() {
+		this.timeZone = inject(ARS_TIME_ZONE);
+	}
+	intercept(req, next) {
+		return next.handle(localizeRequest(req, this.timeZone)).pipe(map((event) => localizeResponse(event, this.timeZone)));
+	}
+	static {
+		this.ɵfac = i0.ɵɵngDeclareFactory({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ArsLocalDateInterceptor,
+			deps: [],
+			target: i0.ɵɵFactoryTarget.Injectable
+		});
+	}
+	static {
+		this.ɵprov = i0.ɵɵngDeclareInjectable({
+			minVersion: "12.0.0",
+			version: "22.2.1",
+			ngImport: i0,
+			type: ArsLocalDateInterceptor
+		});
+	}
+};
+i0.ɵɵngDeclareClassMetadata({
+	minVersion: "12.0.0",
+	version: "22.2.1",
+	ngImport: i0,
+	type: ArsLocalDateInterceptor,
+	decorators: [{ type: Injectable }]
+});
 function provideArsLocalDates(timeZone = DEFAULT_TIME_ZONE) {
-    return makeEnvironmentProviders([
-        { provide: ARS_TIME_ZONE, useValue: timeZone },
-        { provide: HTTP_INTERCEPTORS, useClass: ArsLocalDateInterceptor, multi: true },
-    ]);
+	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');
+	if (!value || isNaN(value.getTime())) return void 0;
+	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);
+	if (!value || isNaN(value.getTime())) return void 0;
+	return format(new TZDate(value.getTime(), timeZone), NAIVE_PATTERN);
 }
-
-/*
- * Public API Surface of @arsedizioni/ars-utils/core.date
- */
-
-/**
- * Generated bundle index. Do not edit.
- */
-
 export { ARS_TIME_ZONE, ArsLocalDateInterceptor, DEFAULT_TIME_ZONE, DateFnsAdapter, MAT_DATE_FNS_FORMATS, arsLocalDateInterceptor, provideArsDateFns, provideArsLocalDates, toLocalDateOnlyString, toLocalDateTimeString };
-//# sourceMappingURL=arsedizioni-ars-utils-core.date.mjs.map
+
+//# sourceMappingURL=arsedizioni-ars-utils-core.date.mjs.map