@cute-widgets/base 20.0.1

package/fesm2022/cute-widgets-base-core-datetime.mjs

@@ -0,0 +1,568 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, LOCALE_ID, isDevMode, Injectable, NgModule } from '@angular/core';
+import { Subject } from 'rxjs';
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/** InjectionToken for datepicker that can be used to override default locale code. */
+const CUTE_DATE_LOCALE = new InjectionToken('CUTE_DATE_LOCALE', {
+    providedIn: 'root',
+    factory: CUTE_DATE_LOCALE_FACTORY,
+});
+/**
+ * @docs-private
+ * @deprecated No longer used, will be removed.
+ * @breaking-change 21.0.0
+ */
+function CUTE_DATE_LOCALE_FACTORY() {
+    return inject(LOCALE_ID);
+}
+const NOT_IMPLEMENTED = 'Method not implemented';
+/** Adapts type `D` to be usable as a date by cdk-based components that work with dates. */
+class DateAdapter {
+    constructor() {
+        this._localeChanges = new Subject();
+        /** A stream that emits when the locale changes. */
+        this.localeChanges = this._localeChanges;
+    }
+    /**
+     * Sets the time of one date to the time of another.
+     * @param target Date whose time will be set.
+     * @param hours New hours to set on the date object.
+     * @param minutes New minutes to set on the date object.
+     * @param seconds New seconds to set on the date object.
+     */
+    setTime(target, hours, minutes, seconds) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the hours component of the given date.
+     * @param date The date to extract the hours from.
+     */
+    getHours(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the minutes component of the given date.
+     * @param date The date to extract the minutes from.
+     */
+    getMinutes(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Gets the seconds component of the given date.
+     * @param date The date to extract the seconds from.
+     */
+    getSeconds(date) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Parses a date with a specific time from a user-provided value.
+     * @param value The value to parse.
+     * @param parseFormat The expected format of the value being parsed
+     *     (type is implementation-dependent).
+     */
+    parseTime(value, parseFormat) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Adds an amount of seconds to the specified date.
+     * @param date Date to which to add the seconds.
+     * @param amount Amount of seconds to add to the date.
+     */
+    addSeconds(date, amount) {
+        throw new Error(NOT_IMPLEMENTED);
+    }
+    /**
+     * Given a potential date object, returns that same date object if it is
+     * a valid date, or `null` if it's not a valid date.
+     * @param obj The object to check.
+     * @returns A date or `null`.
+     */
+    getValidDateOrNull(obj) {
+        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
+    }
+    /**
+     * Attempts to deserialize a value to a valid date object. This is different from parsing in that
+     * deserialize should only accept non-ambiguous, locale-independent formats (e.g. a ISO 8601
+     * string). The default implementation does not allow any deserialization, it simply checks that
+     * the given value is already a valid date object or null. The `<mat-datepicker>` will call this
+     * method on all of its `@Input()` properties that accept dates. It is therefore possible to
+     * support passing values from your backend directly to these properties by overriding this method
+     * to also deserialize the format used by your backend.
+     * @param value The value to be deserialized into a date object.
+     * @returns The deserialized date object, either a valid date, null if the value can be
+     *     deserialized into a null date (e.g. the empty string), or an invalid date.
+     */
+    deserialize(value) {
+        if (value == null || (this.isDateInstance(value) && this.isValid(value))) {
+            return value;
+        }
+        return this.invalid();
+    }
+    /**
+     * Sets the locale used for all dates.
+     * @param locale The new locale.
+     */
+    setLocale(locale) {
+        this.locale = locale;
+        this._localeChanges.next();
+    }
+    /**
+     * Compares two dates.
+     * @param first The first date to compare.
+     * @param second The second date to compare.
+     * @returns 0 if the dates are equal, a number less than 0 if the first date is earlier,
+     *     a number greater than 0 if the first date is later.
+     */
+    compareDate(first, second) {
+        return (this.getYear(first) - this.getYear(second) ||
+            this.getMonth(first) - this.getMonth(second) ||
+            this.getDate(first) - this.getDate(second));
+    }
+    /**
+     * Compares the time values of two dates.
+     * @param first First date to compare.
+     * @param second Second date to compare.
+     * @returns 0 if the times are equal, a number less than 0 if the first time is earlier,
+     *     a number greater than 0 if the first time is later.
+     */
+    compareTime(first, second) {
+        return (this.getHours(first) - this.getHours(second) ||
+            this.getMinutes(first) - this.getMinutes(second) ||
+            this.getSeconds(first) - this.getSeconds(second));
+    }
+    /**
+     * Checks if two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    sameDate(first, second) {
+        if (first && second) {
+            let firstValid = this.isValid(first);
+            let secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareDate(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    }
+    /**
+     * Checks if the times of two dates are equal.
+     * @param first The first date to check.
+     * @param second The second date to check.
+     * @returns Whether the times of the two dates are equal.
+     *     Null dates are considered equal to other null dates.
+     */
+    sameTime(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareTime(first, second);
+            }
+            return firstValid == secondValid;
+        }
+        return first == second;
+    }
+    /**
+     * Clamp the given date between min and max dates.
+     * @param date The date to clamp.
+     * @param min The minimum value to allow. If null or omitted, no min is enforced.
+     * @param max The maximum value to allow. If null or omitted, no max is enforced.
+     * @returns `min` if `date` is less than `min`, `max` if date is greater than `max`,
+     *     otherwise `date`.
+     */
+    clampDate(date, min, max) {
+        if (min && this.compareDate(date, min) < 0) {
+            return min;
+        }
+        if (max && this.compareDate(date, max) > 0) {
+            return max;
+        }
+        return date;
+    }
+}
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+const CUTE_DATE_FORMATS = new InjectionToken('cute-date-formats');
+
+/**
+ * @license Apache-2.0
+ *
+ * Copyright (c) 2025 CuteWidgets Team. All Rights Reserved.
+ *
+ * You may not use this file except in compliance with the License
+ * that can be found at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * This code is a modification of the `@angular/material` original
+ * code licensed under MIT-style License (https://angular.dev/license).
+ */
+/**
+ * Matches strings that have the form of a valid RFC 3339 string
+ * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
+ * because the regex will match strings and without of bounds month, date, etc.
+ */
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+/**
+ * Matches a time string. Supported formats:
+ * - {{hours}}:{{minutes}}
+ * - {{hours}}:{{minutes}}:{{seconds}}
+ * - {{hours}}:{{minutes}} AM/PM
+ * - {{hours}}:{{minutes}}:{{seconds}} AM/PM
+ * - {{hours}}.{{minutes}}
+ * - {{hours}}.{{minutes}}.{{seconds}}
+ * - {{hours}}.{{minutes}} AM/PM
+ * - {{hours}}.{{minutes}}.{{seconds}} AM/PM
+ */
+const TIME_REGEX = /^(\d?\d)[:.](\d?\d)(?:[:.](\d?\d))?\s*(AM|PM)?$/i;
+/** Creates an array and fills it with values. */
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+/** Adapts the native JS Date for use with cdk-based components that work with dates. */
+class NativeDateAdapter extends DateAdapter {
+    constructor() {
+        super();
+        /** The injected locale. */
+        this._cuteDateLocale = inject(CUTE_DATE_LOCALE, { optional: true });
+        const cuteDateLocale = inject(CUTE_DATE_LOCALE, { optional: true });
+        if (cuteDateLocale !== undefined) {
+            this._cuteDateLocale = cuteDateLocale;
+        }
+        super.setLocale(this._cuteDateLocale);
+    }
+    getYear(date) { return date.getFullYear(); }
+    getMonth(date) { return date.getMonth(); }
+    getDate(date) { return date.getDate(); }
+    getDayOfWeek(date) { return date.getDay(); }
+    getMonthNames(style) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });
+        return range(12, i => this._format(dtf, new Date(2017, i, 1)));
+    }
+    getDateNames() {
+        const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });
+        return range(31, i => this._format(dtf, new Date(2017, 0, i + 1)));
+    }
+    getDayOfWeekNames(style) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });
+        return range(7, i => this._format(dtf, new Date(2017, 0, i + 1)));
+    }
+    getYearName(date) {
+        const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });
+        return this._format(dtf, date);
+    }
+    getFirstDayOfWeek() {
+        // At the time of writing `Intl.Locale` isn't available
+        // in the internal types, so we need to cast to `any`.
+        if (typeof Intl !== 'undefined' && Intl.Locale) {
+            const locale = new Intl.Locale(this.locale);
+            // Some browsers implement a `getWeekInfo` method while others have a `weekInfo` getter.
+            // Note that this isn't supported in all browsers, so we need to null check it.
+            const firstDay = (locale.getWeekInfo?.() || locale.weekInfo)?.firstDay ?? 0;
+            // `weekInfo.firstDay` is a number between 1 and 7 where, starting from Monday,
+            // whereas our representation is 0 to 6 where 0 is Sunday, so we need to normalize it.
+            return firstDay === 7 ? 0 : firstDay;
+        }
+        // Default to Sunday if the browser doesn't provide the week information.
+        return 0;
+    }
+    getNumDaysInMonth(date) {
+        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));
+    }
+    clone(date) {
+        return new Date(date.getTime());
+    }
+    createDate(year, month, date) {
+        if (isDevMode()) {
+            // 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.`);
+            }
+            if (date < 1) {
+                throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+            }
+        }
+        let result = this._createDateWithOverflow(year, month, date);
+        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        if (result.getMonth() != month && isDevMode()) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    today() {
+        return new Date();
+    }
+    parse(value, parseFormat) {
+        // We have no way using the native JS Date to set the parse format or locale, so we ignore these
+        // parameters.
+        if (typeof value == 'number') {
+            return new Date(value);
+        }
+        return value ? new Date(Date.parse(value)) : null;
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('NativeDateAdapter: Cannot format invalid date.');
+        }
+        const dtf = new Intl.DateTimeFormat(this.locale, { ...displayFormat, timeZone: 'utc' });
+        return this._format(dtf, date);
+    }
+    addCalendarYears(date, years) {
+        return this.addCalendarMonths(date, years * 12);
+    }
+    addCalendarMonths(date, months) {
+        let newDate = this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + months, this.getDate(date));
+        // It's possible to wind up in the wrong month if the original month has more days than the new
+        // month. In this case we want to go to the last day of the desired month.
+        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't
+        // guarantee this.
+        if (this.getMonth(newDate) != (((this.getMonth(date) + months) % 12) + 12) % 12) {
+            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0);
+        }
+        return newDate;
+    }
+    addCalendarDays(date, days) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);
+    }
+    toIso8601(date) {
+        return [
+            date.getUTCFullYear(),
+            this._2digit(date.getUTCMonth() + 1),
+            this._2digit(date.getUTCDate()),
+        ].join('-');
+    }
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value) {
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the
+            // string is the right format first.
+            if (ISO_8601_REGEX.test(value)) {
+                let date = new Date(value);
+                if (this.isValid(date)) {
+                    return date;
+                }
+            }
+        }
+        return super.deserialize(value);
+    }
+    isDateInstance(obj) {
+        return obj instanceof Date;
+    }
+    isValid(date) {
+        return !isNaN(date.getTime());
+    }
+    invalid() {
+        return new Date(NaN);
+    }
+    setTime(target, hours, minutes, seconds) {
+        if (isDevMode()) {
+            if (!inRange(hours, 0, 23)) {
+                throw Error(`Invalid hours "${hours}". Hours value must be between 0 and 23.`);
+            }
+            if (!inRange(minutes, 0, 59)) {
+                throw Error(`Invalid minutes "${minutes}". Minutes value must be between 0 and 59.`);
+            }
+            if (!inRange(seconds, 0, 59)) {
+                throw Error(`Invalid seconds "${seconds}". Seconds value must be between 0 and 59.`);
+            }
+        }
+        const clone = this.clone(target);
+        clone.setHours(hours, minutes, seconds, 0);
+        return clone;
+    }
+    getHours(date) {
+        return date.getHours();
+    }
+    getMinutes(date) {
+        return date.getMinutes();
+    }
+    getSeconds(date) {
+        return date.getSeconds();
+    }
+    parseTime(userValue, parseFormat) {
+        if (typeof userValue !== 'string') {
+            return userValue instanceof Date ? new Date(userValue.getTime()) : null;
+        }
+        const value = userValue.trim();
+        if (value.length === 0) {
+            return null;
+        }
+        // Attempt to parse the value directly.
+        let result = this._parseTimeString(value);
+        // Some locales add extra characters around the time, but are otherwise parseable
+        // (e.g. `00:05 ч.` in bg-BG). Try replacing all non-number and non-colon characters.
+        if (result === null) {
+            const withoutExtras = value.replace(/[^0-9:(AM|PM)]/gi, '').trim();
+            if (withoutExtras.length > 0) {
+                result = this._parseTimeString(withoutExtras);
+            }
+        }
+        return result || this.invalid();
+    }
+    addSeconds(date, amount) {
+        return new Date(date.getTime() + amount * 1000);
+    }
+    /** Creates a date but allows the month and date to overflow. */
+    _createDateWithOverflow(year, month, date) {
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this, we use `setFullYear` and `setHours` instead.
+        const d = new Date();
+        d.setFullYear(year, month, date);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    /**
+     * Pads a number to make it two digits.
+     * @param n The number to pad.
+     * @returns The padded number.
+     */
+    _2digit(n) {
+        return ('00' + n).slice(-2);
+    }
+    /**
+     * When converting a Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     * @param dtf Intl.DateTimeFormat object, containing the desired string format. It must have
+     *    timeZone set to 'utc' to work fine.
+     * @param date Date from which we want to get the string representation according to dtf
+     * @returns A Date object with its UTC representation based on the passed in date info
+     */
+    _format(dtf, date) {
+        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.
+        // To work around this, we use `setUTCFullYear` and `setUTCHours` instead.
+        const d = new Date();
+        d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());
+        d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
+        return dtf.format(d);
+    }
+    /**
+     * Attempts to parse a time string into a date object. Returns null if it cannot be parsed.
+     * @param value Time string to parse.
+     */
+    _parseTimeString(value) {
+        // Note: we can technically rely on the browser for the time parsing by generating
+        // an ISO string and appending the string to the end of it. We don't do it, because
+        // browsers aren't consistent in what they support. Some examples:
+        // - Safari doesn't support AM/PM.
+        // - Firefox produces a valid date object if the time string has overflows (e.g. 12:75) while
+        //   other browsers produce an invalid date.
+        // - Safari doesn't allow padded numbers.
+        const parsed = value.toUpperCase().match(TIME_REGEX);
+        if (parsed) {
+            let hours = parseInt(parsed[1]);
+            const minutes = parseInt(parsed[2]);
+            let seconds = parsed[3] == null ? undefined : parseInt(parsed[3]);
+            const amPm = parsed[4];
+            if (hours === 12) {
+                hours = amPm === 'AM' ? 0 : hours;
+            }
+            else if (amPm === 'PM') {
+                hours += 12;
+            }
+            if (inRange(hours, 0, 23) &&
+                inRange(minutes, 0, 59) &&
+                (seconds == null || inRange(seconds, 0, 59))) {
+                return this.setTime(this.today(), hours, minutes, seconds || 0);
+            }
+        }
+        return null;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+/** Checks whether a number is within a certain range. */
+function inRange(value, min, max) {
+    return !isNaN(value) && value >= min && value <= max;
+}
+
+const CUTE_NATIVE_DATE_FORMATS = {
+    parse: {
+        dateInput: null,
+        timeInput: null,
+    },
+    display: {
+        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
+        timeInput: { hour: 'numeric', minute: 'numeric' },
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+        timeOptionLabel: { hour: 'numeric', minute: 'numeric' },
+    },
+};
+
+class NativeDateModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: NativeDateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [{ provide: DateAdapter, useClass: NativeDateAdapter }],
+                }]
+        }] });
+class CuteNativeDateModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, providers: [provideNativeDateAdapter()] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: CuteNativeDateModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    providers: [provideNativeDateAdapter()],
+                }]
+        }] });
+function provideNativeDateAdapter(formats = CUTE_NATIVE_DATE_FORMATS) {
+    return [
+        { provide: DateAdapter, useClass: NativeDateAdapter },
+        { provide: CUTE_DATE_FORMATS, useValue: formats },
+    ];
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CUTE_DATE_FORMATS, CUTE_DATE_LOCALE, CUTE_DATE_LOCALE_FACTORY, CUTE_NATIVE_DATE_FORMATS, CuteNativeDateModule, DateAdapter, NativeDateAdapter, NativeDateModule, provideNativeDateAdapter };
+//# sourceMappingURL=cute-widgets-base-core-datetime.mjs.map