@gipisistemas/ng-core 1.1.11 → 1.1.12

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/datetime-adapter.js

@@ -0,0 +1,139 @@
+import { DateAdapter } from '@angular/material/core';
+export class GIPIDatetimeAdapter extends DateAdapter {
+    constructor(_delegate) {
+        super();
+        this._delegate = _delegate;
+    }
+    getValidDateOrNull(obj) {
+        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;
+    }
+    compareDatetime(first, second, respectMinutePart = true) {
+        return (this.compareDate(first, second) ||
+            this.getHour(first) - this.getHour(second) ||
+            (respectMinutePart && this.getMinute(first) - this.getMinute(second)));
+    }
+    sameDatetime(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !this.compareDatetime(first, second);
+            }
+            return firstValid === secondValid;
+        }
+        return first === second;
+    }
+    sameYear(first, second) {
+        return first && second && this.getYear(first) === this.getYear(second);
+    }
+    sameDay(first, second) {
+        return (first &&
+            second &&
+            this.getDate(first) === this.getDate(second) &&
+            this.sameMonthAndYear(first, second));
+    }
+    sameHour(first, second) {
+        return (first &&
+            second &&
+            this.getHour(first) === this.getHour(second) &&
+            this.sameDay(first, second));
+    }
+    sameMinute(first, second) {
+        return (first &&
+            second &&
+            this.getMinute(first) === this.getMinute(second) &&
+            this.sameHour(first, second));
+    }
+    sameMonthAndYear(first, second) {
+        if (first && second) {
+            const firstValid = this.isValid(first);
+            const secondValid = this.isValid(second);
+            if (firstValid && secondValid) {
+                return !(this.getYear(first) - this.getYear(second) ||
+                    this.getMonth(first) - this.getMonth(second));
+            }
+            return firstValid === secondValid;
+        }
+        return first === second;
+    }
+    // delegate
+    deserialize(value) {
+        return this._delegate.deserialize(value);
+    }
+    clone(date) {
+        return this._delegate.clone(date);
+    }
+    addCalendarYears(date, years) {
+        return this._delegate.addCalendarYears(date, years);
+    }
+    addCalendarMonths(date, months) {
+        return this._delegate.addCalendarMonths(date, months);
+    }
+    addCalendarDays(date, days) {
+        return this._delegate.addCalendarDays(date, days);
+    }
+    getYear(date) {
+        return this._delegate.getYear(date);
+    }
+    getMonth(date) {
+        return this._delegate.getMonth(date);
+    }
+    getDate(date) {
+        return this._delegate.getDate(date);
+    }
+    getDayOfWeek(date) {
+        return this._delegate.getDayOfWeek(date);
+    }
+    getMonthNames(style) {
+        return this._delegate.getMonthNames(style);
+    }
+    getDateNames() {
+        return this._delegate.getDateNames();
+    }
+    getDayOfWeekNames(style) {
+        return this._delegate.getDayOfWeekNames(style);
+    }
+    getYearName(date) {
+        return this._delegate.getYearName(date);
+    }
+    getFirstDayOfWeek() {
+        return this._delegate.getFirstDayOfWeek();
+    }
+    getNumDaysInMonth(date) {
+        return this._delegate.getNumDaysInMonth(date);
+    }
+    createDate(year, month, date) {
+        return this._delegate.createDate(year, month, date);
+    }
+    today() {
+        return this._delegate.today();
+    }
+    parse(value, parseFormat) {
+        return this._delegate.parse(value, parseFormat);
+    }
+    format(date, displayFormat) {
+        return this._delegate.format(date, displayFormat);
+    }
+    toIso8601(date) {
+        return this._delegate.toIso8601(date);
+    }
+    isDateInstance(obj) {
+        return this._delegate.isDateInstance(obj);
+    }
+    isValid(date) {
+        return this._delegate.isValid(date);
+    }
+    invalid() {
+        return this._delegate.invalid();
+    }
+    clampDate(date, min, max) {
+        if (min && this.compareDatetime(date, min) < 0) {
+            return min;
+        }
+        if (max && this.compareDatetime(date, max) > 0) {
+            return max;
+        }
+        return date;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime-adapter.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/datetime-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { DateAdapter } from '@angular/material/core';\n\nexport abstract class GIPIDatetimeAdapter<D> extends DateAdapter<D> {\n\n    constructor(protected _delegate: DateAdapter<D>) {\n        super();\n    }\n\n    abstract getHour(date: D): number;\n\n    abstract getMinute(date: D): number;\n\n    abstract getFirstDateOfMonth(date: D): D;\n\n    abstract isInNextMonth(startDate: D, endDate: D): boolean;\n\n    abstract getHourNames(): string[];\n\n    abstract getMinuteNames(): string[];\n\n    abstract addCalendarHours(date: D, months: number): D;\n\n    abstract addCalendarMinutes(date: D, months: number): D;\n\n    abstract createDatetime(year: number, month: number, date: number, hour: number, minute: number): D;\n\n    getValidDateOrNull(obj: any): D | null {\n        return this.isDateInstance(obj) && this.isValid(obj) ? obj : null;\n    }\n\n    compareDatetime(first: D, second: D, respectMinutePart: boolean = true): number {\n        return (\n            this.compareDate(first, second) ||\n            this.getHour(first) - this.getHour(second) ||\n            (respectMinutePart && this.getMinute(first) - this.getMinute(second))\n        );\n    }\n\n    sameDatetime(first: D | null, second: D | null): boolean {\n        if (first && second) {\n            const firstValid = this.isValid(first);\n            const secondValid = this.isValid(second);\n            if (firstValid && secondValid) {\n                return !this.compareDatetime(first, second);\n            }\n            return firstValid === secondValid;\n        }\n        return first === second;\n    }\n\n    sameYear(first: D, second: D) {\n        return first && second && this.getYear(first) === this.getYear(second);\n    }\n\n    sameDay(first: D, second: D) {\n        return (\n            first &&\n            second &&\n            this.getDate(first) === this.getDate(second) &&\n            this.sameMonthAndYear(first, second)\n        );\n    }\n\n    sameHour(first: D, second: D) {\n        return (\n            first &&\n            second &&\n            this.getHour(first) === this.getHour(second) &&\n            this.sameDay(first, second)\n        );\n    }\n\n    sameMinute(first: D, second: D) {\n        return (\n            first &&\n            second &&\n            this.getMinute(first) === this.getMinute(second) &&\n            this.sameHour(first, second)\n        );\n    }\n\n    sameMonthAndYear(first: D | null, second: D | null): boolean {\n        if (first && second) {\n            const firstValid = this.isValid(first);\n            const secondValid = this.isValid(second);\n            if (firstValid && secondValid) {\n                return !(\n                    this.getYear(first) - this.getYear(second) ||\n                    this.getMonth(first) - this.getMonth(second)\n                );\n            }\n            return firstValid === secondValid;\n        }\n        return first === second;\n    }\n\n    // delegate\n    deserialize(value: any): D | null {\n        return this._delegate.deserialize(value);\n    }\n\n    clone(date: D): D {\n        return this._delegate.clone(date);\n    }\n\n    addCalendarYears(date: D, years: number): D {\n        return this._delegate.addCalendarYears(date, years);\n    }\n\n    addCalendarMonths(date: D, months: number): D {\n        return this._delegate.addCalendarMonths(date, months);\n    }\n\n    addCalendarDays(date: D, days: number): D {\n        return this._delegate.addCalendarDays(date, days);\n    }\n\n    getYear(date: D): number {\n        return this._delegate.getYear(date);\n    }\n\n    getMonth(date: D): number {\n        return this._delegate.getMonth(date);\n    }\n\n    getDate(date: D): number {\n        return this._delegate.getDate(date);\n    }\n\n    getDayOfWeek(date: D): number {\n        return this._delegate.getDayOfWeek(date);\n    }\n\n    getMonthNames(style): string[] {\n        return this._delegate.getMonthNames(style);\n    }\n\n    getDateNames(): string[] {\n        return this._delegate.getDateNames();\n    }\n\n    getDayOfWeekNames(style): string[] {\n        return this._delegate.getDayOfWeekNames(style);\n    }\n\n    getYearName(date: D): string {\n        return this._delegate.getYearName(date);\n    }\n\n    getFirstDayOfWeek(): number {\n        return this._delegate.getFirstDayOfWeek();\n    }\n\n    getNumDaysInMonth(date: D): number {\n        return this._delegate.getNumDaysInMonth(date);\n    }\n\n    createDate(year: number, month: number, date: number): D {\n        return this._delegate.createDate(year, month, date);\n    }\n\n    today(): D {\n        return this._delegate.today();\n    }\n\n    parse(value: any, parseFormat: any): D | null {\n        return this._delegate.parse(value, parseFormat);\n    }\n\n    format(date: D, displayFormat: any): string {\n        return this._delegate.format(date, displayFormat);\n    }\n\n    toIso8601(date: D): string {\n        return this._delegate.toIso8601(date);\n    }\n\n    isDateInstance(obj: any): boolean {\n        return this._delegate.isDateInstance(obj);\n    }\n\n    isValid(date: D): boolean {\n        return this._delegate.isValid(date);\n    }\n\n    invalid(): D {\n        return this._delegate.invalid();\n    }\n\n    clampDate(date: D, min?: D | null, max?: D | null): D {\n        if (min && this.compareDatetime(date, min) < 0) {\n            return min;\n        }\n        if (max && this.compareDatetime(date, max) > 0) {\n            return max;\n        }\n        return date;\n    }\n}\n"]}

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/datetime-formats.js

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@angular/core';
+export const GIPI_DATETIME_FORMATS = new InjectionToken('mat-datetime-formats');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXRpbWUtZm9ybWF0cy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvZGF0ZXRpbWUtcGlja2VyL21hdC1kYXRldGltZS1waWNrZXIvc2hhcmVkL2FkYXB0ZXIvZGF0ZXRpbWUtZm9ybWF0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBcUIvQyxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxJQUFJLGNBQWMsQ0FBc0Isc0JBQXNCLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgR0lQSURhdGV0aW1lRm9ybWF0cyB7XG4gICAgcGFyc2U6IHtcbiAgICAgICAgZGF0ZUlucHV0PzogYW55O1xuICAgICAgICBtb250aElucHV0PzogYW55O1xuICAgICAgICB0aW1lSW5wdXQ/OiBhbnk7XG4gICAgICAgIGRhdGV0aW1lSW5wdXQ/OiBhbnk7XG4gICAgfTtcbiAgICBkaXNwbGF5OiB7XG4gICAgICAgIGRhdGVJbnB1dDogYW55O1xuICAgICAgICBtb250aElucHV0OiBhbnk7XG4gICAgICAgIHRpbWVJbnB1dDogYW55O1xuICAgICAgICBkYXRldGltZUlucHV0OiBhbnk7XG4gICAgICAgIG1vbnRoWWVhckxhYmVsOiBhbnk7XG4gICAgICAgIGRhdGVBMTF5TGFiZWw6IGFueTtcbiAgICAgICAgbW9udGhZZWFyQTExeUxhYmVsOiBhbnk7XG4gICAgICAgIHBvcHVwSGVhZGVyRGF0ZUxhYmVsOiBhbnk7XG4gICAgfTtcbn1cblxuZXhwb3J0IGNvbnN0IEdJUElfREFURVRJTUVfRk9STUFUUyA9IG5ldyBJbmplY3Rpb25Ub2tlbjxHSVBJRGF0ZXRpbWVGb3JtYXRzPignbWF0LWRhdGV0aW1lLWZvcm1hdHMnKTtcbiJdfQ==

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/native-datetime-adapter.js

@@ -0,0 +1,138 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, Injectable, Optional } from '@angular/core';
+import { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';
+import { GIPIDatetimeAdapter } from './datetime-adapter';
+const ɵ0 = (i) => String(i);
+/** The default hour names to use if Intl API is not available. */
+const DEFAULT_HOUR_NAMES = range(24, ɵ0);
+const ɵ1 = (i) => String(i);
+/** The default minute names to use if Intl API is not available. */
+const DEFAULT_MINUTE_NAMES = range(60, ɵ1);
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+let GIPINativeDatetimeAdapter = class GIPINativeDatetimeAdapter extends GIPIDatetimeAdapter {
+    constructor(matDateLocale, _delegate) {
+        super(_delegate);
+        this.setLocale(matDateLocale);
+    }
+    clone(date) {
+        return this.createDatetime(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date), this.getMinute(date));
+    }
+    getHour(date) {
+        return date.getHours();
+    }
+    getMinute(date) {
+        return date.getMinutes();
+    }
+    isInNextMonth(startDate, endDate) {
+        const nextMonth = this.getDateInNextMonth(startDate);
+        return this.sameMonthAndYear(nextMonth, endDate);
+    }
+    createDatetime(year, month, date, hour, minute) {
+        // 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.`);
+        }
+        if (hour < 0 || hour > 23) {
+            throw Error(`Invalid hour "${hour}". Hour has to be between 0 and 23.`);
+        }
+        if (minute < 0 || minute > 59) {
+            throw Error(`Invalid minute "${minute}". Minute has to be between 0 and 59.`);
+        }
+        const result = this._createDateWithOverflow(year, month, date, hour, minute);
+        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        if (result.getMonth() !== month) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    getFirstDateOfMonth(date) {
+        const result = new Date();
+        result.setFullYear(date.getFullYear(), date.getMonth(), 1);
+        return result;
+    }
+    getHourNames() {
+        return DEFAULT_HOUR_NAMES;
+    }
+    getMinuteNames() {
+        return DEFAULT_MINUTE_NAMES;
+    }
+    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), this.getHour(date), this.getMinute(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, this.getHour(date), this.getMinute(date));
+        }
+        return newDate;
+    }
+    addCalendarDays(date, days) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days, this.getHour(date), this.getMinute(date));
+    }
+    addCalendarHours(date, hours) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date) + hours, this.getMinute(date));
+    }
+    addCalendarMinutes(date, minutes) {
+        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHour(date), this.getMinute(date) + minutes);
+    }
+    toIso8601(date) {
+        return (super.toIso8601(date) + 'T' + [this._2digit(date.getUTCHours()), this._2digit(date.getUTCMinutes()),].join(':'));
+    }
+    getDateInNextMonth(date) {
+        return new Date(date.getFullYear(), date.getMonth() + 1, 1, date.getHours(), date.getMinutes());
+    }
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     * @param str The string to strip direction characters from.
+     * @returns The stripped string.
+     */
+    _stripDirectionalityCharacters(str) {
+        return str.replace(/[\u200e\u200f]/g, '');
+    }
+    /**
+     * 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);
+    }
+    /** Creates a date but allows the month and date to overflow. */
+    _createDateWithOverflow(year, month, date, hours, minutes) {
+        const result = new Date(year, month, date, hours, minutes);
+        // We need to correct for the fact that JS native Date treats years in range [0, 99] as
+        // abbreviations for 19xx.
+        if (year >= 0 && year < 100) {
+            result.setFullYear(this.getYear(result) - 1900);
+        }
+        return result;
+    }
+};
+GIPINativeDatetimeAdapter.ctorParameters = () => [
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },
+    { type: DateAdapter }
+];
+GIPINativeDatetimeAdapter = __decorate([
+    Injectable(),
+    __param(0, Optional()), __param(0, Inject(MAT_DATE_LOCALE)),
+    __metadata("design:paramtypes", [String, DateAdapter])
+], GIPINativeDatetimeAdapter);
+export { GIPINativeDatetimeAdapter };
+export { ɵ0, ɵ1 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-datetime-adapter.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/native-datetime-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable, Optional } from '@angular/core';\nimport { DateAdapter, MAT_DATE_LOCALE } from '@angular/material/core';\nimport { GIPIDatetimeAdapter } from './datetime-adapter';\n\n/** The default hour names to use if Intl API is not available. */\nconst DEFAULT_HOUR_NAMES = range(24, (i) => String(i));\n\n/** The default minute names to use if Intl API is not available. */\nconst DEFAULT_MINUTE_NAMES = range(60, (i) => String(i));\n\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\n    const valuesArray = Array(length);\n    for (let i = 0; i < length; i++) {\n        valuesArray[i] = valueFunction(i);\n    }\n    return valuesArray;\n}\n\n@Injectable()\nexport class GIPINativeDatetimeAdapter extends GIPIDatetimeAdapter<Date> {\n\n    constructor(\n        @Optional() @Inject(MAT_DATE_LOCALE) matDateLocale: string,\n        _delegate: DateAdapter<Date>\n    ) {\n        super(_delegate);\n        this.setLocale(matDateLocale);\n    }\n\n    clone(date: Date): Date {\n        return this.createDatetime(\n            this.getYear(date),\n            this.getMonth(date),\n            this.getDate(date),\n            this.getHour(date),\n            this.getMinute(date)\n        );\n    }\n\n    getHour(date: Date): number {\n        return date.getHours();\n    }\n\n    getMinute(date: Date): number {\n        return date.getMinutes();\n    }\n\n    isInNextMonth(startDate: Date, endDate: Date): boolean {\n        const nextMonth = this.getDateInNextMonth(startDate);\n        return this.sameMonthAndYear(nextMonth, endDate);\n    }\n\n    createDatetime(year: number, month: number, date: number, hour: number, minute: number): Date {\n        // Check for invalid month and date (except upper bound on date which we have to check after\n        // creating the Date).\n        if (month < 0 || month > 11) {\n            throw Error(`Invalid month index \"${month}\". Month index has to be between 0 and 11.`);\n        }\n\n        if (date < 1) {\n            throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n        }\n\n        if (hour < 0 || hour > 23) {\n            throw Error(`Invalid hour \"${hour}\". Hour has to be between 0 and 23.`);\n        }\n\n        if (minute < 0 || minute > 59) {\n            throw Error(`Invalid minute \"${minute}\". Minute has to be between 0 and 59.`);\n        }\n\n        const result = this._createDateWithOverflow(year, month, date, hour, minute);\n\n        // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n        if (result.getMonth() !== month) {\n            throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n        }\n\n        return result;\n    }\n\n    getFirstDateOfMonth(date: Date): Date {\n        const result = new Date();\n        result.setFullYear(date.getFullYear(), date.getMonth(), 1);\n        return result;\n    }\n\n    getHourNames(): string[] {\n        return DEFAULT_HOUR_NAMES;\n    }\n\n    getMinuteNames(): string[] {\n        return DEFAULT_MINUTE_NAMES;\n    }\n\n    addCalendarYears(date: Date, years: number): Date {\n        return this.addCalendarMonths(date, years * 12);\n    }\n\n    addCalendarMonths(date: Date, months: number): Date {\n        let newDate = this._createDateWithOverflow(\n            this.getYear(date),\n            this.getMonth(date) + months,\n            this.getDate(date),\n            this.getHour(date),\n            this.getMinute(date)\n        );\n\n        // It's possible to wind up in the wrong month if the original month has more days than the new\n        // month. In this case we want to go to the last day of the desired month.\n        // Note: the additional + 12 % 12 ensures we end up with a positive number, since JS % doesn't\n        // guarantee this.\n        if (this.getMonth(newDate) !== (((this.getMonth(date) + months) % 12) + 12) % 12) {\n            newDate = this._createDateWithOverflow(this.getYear(newDate), this.getMonth(newDate), 0, this.getHour(date), this.getMinute(date));\n        }\n\n        return newDate;\n    }\n\n    addCalendarDays(date: Date, days: number): Date {\n        return this._createDateWithOverflow(\n            this.getYear(date),\n            this.getMonth(date),\n            this.getDate(date) + days,\n            this.getHour(date),\n            this.getMinute(date)\n        );\n    }\n\n    addCalendarHours(date: Date, hours: number): Date {\n        return this._createDateWithOverflow(\n            this.getYear(date),\n            this.getMonth(date),\n            this.getDate(date),\n            this.getHour(date) + hours,\n            this.getMinute(date)\n        );\n    }\n\n    addCalendarMinutes(date: Date, minutes: number): Date {\n        return this._createDateWithOverflow(\n            this.getYear(date),\n            this.getMonth(date),\n            this.getDate(date),\n            this.getHour(date),\n            this.getMinute(date) + minutes\n        );\n    }\n\n    toIso8601(date: Date): string {\n        return (super.toIso8601(date) + 'T' + [this._2digit(date.getUTCHours()), this._2digit(date.getUTCMinutes()),].join(':'));\n    }\n\n    private getDateInNextMonth(date: Date) {\n        return new Date(date.getFullYear(), date.getMonth() + 1, 1, date.getHours(), date.getMinutes());\n    }\n\n    /**\n     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while\n     * other browsers do not. We remove them to make output consistent and because they interfere with\n     * date parsing.\n     * @param str The string to strip direction characters from.\n     * @returns The stripped string.\n     */\n    private _stripDirectionalityCharacters(str: string) {\n        return str.replace(/[\\u200e\\u200f]/g, '');\n    }\n\n    /**\n     * Pads a number to make it two digits.\n     * @param n The number to pad.\n     * @returns The padded number.\n     */\n    private _2digit(n: number) {\n        return ('00' + n).slice(-2);\n    }\n\n    /** Creates a date but allows the month and date to overflow. */\n    private _createDateWithOverflow(year: number, month: number, date: number, hours: number, minutes: number) {\n        const result = new Date(year, month, date, hours, minutes);\n\n        // We need to correct for the fact that JS native Date treats years in range [0, 99] as\n        // abbreviations for 19xx.\n        if (year >= 0 && year < 100) {\n            result.setFullYear(this.getYear(result) - 1900);\n        }\n        return result;\n    }\n}\n"]}

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/native-datetime-formats.js

@@ -0,0 +1,20 @@
+export const GIPI_NATIVE_DATETIME_FORMATS = {
+    parse: {},
+    display: {
+        dateInput: { year: 'numeric', month: '2-digit', day: '2-digit' },
+        monthInput: { month: 'long' },
+        datetimeInput: {
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+        },
+        timeInput: { hour: '2-digit', minute: '2-digit' },
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+        popupHeaderDateLabel: { weekday: 'short', month: 'short', day: '2-digit' },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/year-view.js

@@ -0,0 +1,141 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, ViewEncapsulation, } from '@angular/core';
+import { GIPIDatetimepickerCalendarCell } from './calendar-body';
+import { slideCalendar } from './datetimepicker-animations';
+import { createMissingDateImplError } from './datetimepicker-errors';
+import { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';
+import { GIPI_DATETIME_FORMATS, } from './shared/adapter/datetime-formats';
+/**
+ * An internal component used to display a single year in the datepicker.
+ * @docs-private
+ */
+let GIPIDatetimepickerYearViewComponent = class GIPIDatetimepickerYearViewComponent {
+    constructor(_adapter, _dateFormats) {
+        this._adapter = _adapter;
+        this._dateFormats = _dateFormats;
+        this.type = 'date';
+        /** Emits when a new month is selected. */
+        this.selectedChange = new EventEmitter();
+        this._userSelection = new EventEmitter();
+        if (!this._adapter) {
+            throw createMissingDateImplError('DatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');
+        }
+        this._activeDate = this._adapter.today();
+    }
+    get activeDate() {
+        return this._activeDate;
+    }
+    set activeDate(value) {
+        let oldActiveDate = this._activeDate;
+        this._activeDate = value || this._adapter.today();
+        if (oldActiveDate && this._activeDate && !this._adapter.sameYear(oldActiveDate, this._activeDate)) {
+            this._init();
+        }
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this._selectedMonth = this._getMonthInCurrentYear(this.selected);
+    }
+    ngAfterContentInit() {
+        this._init();
+    }
+    /** Handles when a new month is selected. */
+    _monthSelected(month) {
+        const normalizedDate = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, 1, 0, 0);
+        this.selectedChange.emit(this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, Math.min(this._adapter.getDate(this.activeDate), this._adapter.getNumDaysInMonth(normalizedDate)), this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)));
+        if (this.type === 'month') {
+            this._userSelection.emit();
+        }
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Initializes this month view. */
+    _init() {
+        this._selectedMonth = this._getMonthInCurrentYear(this.selected);
+        this._todayMonth = this._getMonthInCurrentYear(this._adapter.today());
+        this._yearLabel = this._adapter.getYearName(this.activeDate);
+        let monthNames = this._adapter.getMonthNames('short');
+        // First row of months only contains 5 elements so we can fit the year label on the same row.
+        this._months = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]].map((row) => row.map((month) => this._createCellForMonth(month, monthNames[month])));
+    }
+    /**
+     * Gets the month in this year that the given Date falls on.
+     * Returns null if the given Date is in another year.
+     */
+    _getMonthInCurrentYear(date) {
+        return this._adapter.sameYear(date, this.activeDate)
+            ? this._adapter.getMonth(date)
+            : null;
+    }
+    /** Creates an MdCalendarCell for the given month. */
+    _createCellForMonth(month, monthName) {
+        let ariaLabel = this._adapter.format(this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)), this._dateFormats.display.monthYearA11yLabel);
+        return new GIPIDatetimepickerCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._isMonthEnabled(month));
+    }
+    /** Whether the given month is enabled. */
+    _isMonthEnabled(month) {
+        if (!this.dateFilter) {
+            return true;
+        }
+        let firstOfMonth = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate));
+        // If any date in the month is enabled count the month as enabled.
+        for (let date = firstOfMonth; this._adapter.getMonth(date) == month; date = this._adapter.addCalendarDays(date, 1)) {
+            if (this.dateFilter(date)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+GIPIDatetimepickerYearViewComponent.ctorParameters = () => [
+    { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [GIPI_DATETIME_FORMATS,] }] }
+];
+__decorate([
+    Input(),
+    __metadata("design:type", String)
+], GIPIDatetimepickerYearViewComponent.prototype, "type", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Function)
+], GIPIDatetimepickerYearViewComponent.prototype, "dateFilter", void 0);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerYearViewComponent.prototype, "activeDate", null);
+__decorate([
+    Input(),
+    __metadata("design:type", Object),
+    __metadata("design:paramtypes", [Object])
+], GIPIDatetimepickerYearViewComponent.prototype, "selected", null);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerYearViewComponent.prototype, "selectedChange", void 0);
+__decorate([
+    Output(),
+    __metadata("design:type", Object)
+], GIPIDatetimepickerYearViewComponent.prototype, "_userSelection", void 0);
+GIPIDatetimepickerYearViewComponent = __decorate([
+    Component({
+        selector: 'gipi-mat-datetime-picker-year-view',
+        template: "<table class=\"gipi-mat-datetime-picker-calendar-table\"\n       role=\"presentation\">\n    <thead class=\"gipi-mat-datetime-picker-calendar-table-header\">\n        <tr>\n            <th class=\"gipi-mat-datetime-picker-calendar-table-header-divider\"\n                colspan=\"4\">\n            </th>\n        </tr>\n    </thead>\n    <tbody gipiMatDatetimePickerCalendarBody\n           allowDisabledSelection=\"true\"\n           role=\"grid\"\n           [label]=\"_yearLabel\"\n           [rows]=\"_months\"\n           [todayValue]=\"_todayMonth\"\n           [labelMinRequiredCells]=\"2\"\n           [numCols]=\"4\"\n           [cellAspectRatio]=\"4 / 7\"\n           [activeCell]=\"_adapter.getMonth(activeDate)\"\n           [selectedValue]=\"_selectedMonth\"\n           [@slideCalendar]=\"_calendarState\"\n           (@slideCalendar.done)=\"_calendarStateDone()\"\n           (selectedValueChange)=\"_monthSelected($event)\">\n    </tbody>\n</table>\n",
+        animations: [slideCalendar],
+        encapsulation: ViewEncapsulation.None,
+        changeDetection: ChangeDetectionStrategy.OnPush
+    }),
+    __param(0, Optional()),
+    __param(1, Optional()),
+    __param(1, Inject(GIPI_DATETIME_FORMATS)),
+    __metadata("design:paramtypes", [GIPIDatetimeAdapter, Object])
+], GIPIDatetimepickerYearViewComponent);
+export { GIPIDatetimepickerYearViewComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"year-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/year-view.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ChangeDetectionStrategy, Component, EventEmitter, Inject, Input, Optional, Output, ViewEncapsulation, } from '@angular/core';\n\nimport { GIPIDatetimepickerCalendarCell } from './calendar-body';\nimport { slideCalendar } from './datetimepicker-animations';\nimport { createMissingDateImplError } from './datetimepicker-errors';\nimport { GIPIDatetimepickerType } from './datetimepicker-type';\nimport { GIPIDatetimeAdapter } from './shared/adapter/datetime-adapter';\nimport { GIPI_DATETIME_FORMATS, GIPIDatetimeFormats, } from './shared/adapter/datetime-formats';\n\n/**\n * An internal component used to display a single year in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datetime-picker-year-view',\n    templateUrl: 'year-view.html',\n    animations: [slideCalendar],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class GIPIDatetimepickerYearViewComponent<D> implements AfterContentInit {\n\n    /** Grid of calendar cells representing the months of the year. */\n    _months: GIPIDatetimepickerCalendarCell[][];\n\n    /** The label for this year (e.g. \"2017\"). */\n    _yearLabel: string;\n\n    /** The month in this year that today falls on. Null if today is in a different year. */\n    _todayMonth: number;\n\n    /** The month in this year that the selected Date falls on. Null if the selected Date is in a different year. */\n    _selectedMonth: number;\n\n    _calendarState: string;\n\n    @Input() type: GIPIDatetimepickerType = 'date';\n\n    /** A function used to filter which dates are selectable. */\n    @Input() dateFilter: (date: D) => boolean;\n\n    /** The date to display in this year view (everything other than the year is ignored). */\n    private _activeDate: D;\n    @Input() get activeDate(): D {\n        return this._activeDate;\n    }\n    set activeDate(value: D) {\n        let oldActiveDate = this._activeDate;\n        this._activeDate = value || this._adapter.today();\n        if (oldActiveDate && this._activeDate && !this._adapter.sameYear(oldActiveDate, this._activeDate)) {\n            this._init();\n        }\n    }\n\n    /** The currently selected date. */\n    private _selected: D;\n    @Input() get selected(): D {\n        return this._selected;\n    }\n    set selected(value: D) {\n        this._selected = value;\n        this._selectedMonth = this._getMonthInCurrentYear(this.selected);\n    }\n\n    /** Emits when a new month is selected. */\n    @Output() selectedChange = new EventEmitter<D>();\n    @Output() _userSelection = new EventEmitter<void>();\n\n    constructor(\n        @Optional() public _adapter: GIPIDatetimeAdapter<D>,\n        @Optional()\n        @Inject(GIPI_DATETIME_FORMATS)\n        private _dateFormats: GIPIDatetimeFormats\n    ) {\n        if (!this._adapter) {\n            throw createMissingDateImplError('DatetimeAdapter');\n        }\n\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');\n        }\n\n        this._activeDate = this._adapter.today();\n    }\n\n    ngAfterContentInit() {\n        this._init();\n    }\n\n    /** Handles when a new month is selected. */\n    _monthSelected(month: number) {\n        const normalizedDate = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, 1, 0, 0);\n\n        this.selectedChange.emit(\n            this._adapter.createDatetime(\n                this._adapter.getYear(this.activeDate),\n                month,\n                Math.min(this._adapter.getDate(this.activeDate), this._adapter.getNumDaysInMonth(normalizedDate)),\n                this._adapter.getHour(this.activeDate),\n                this._adapter.getMinute(this.activeDate)\n            )\n        );\n        if (this.type === 'month') {\n            this._userSelection.emit();\n        }\n    }\n\n    _calendarStateDone() {\n        this._calendarState = '';\n    }\n\n    /** Initializes this month view. */\n    private _init() {\n        this._selectedMonth = this._getMonthInCurrentYear(this.selected);\n        this._todayMonth = this._getMonthInCurrentYear(this._adapter.today());\n        this._yearLabel = this._adapter.getYearName(this.activeDate);\n\n        let monthNames = this._adapter.getMonthNames('short');\n        // First row of months only contains 5 elements so we can fit the year label on the same row.\n        this._months = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]].map((row) => row.map((month) => this._createCellForMonth(month, monthNames[month])));\n    }\n\n    /**\n     * Gets the month in this year that the given Date falls on.\n     * Returns null if the given Date is in another year.\n     */\n    private _getMonthInCurrentYear(date: D) {\n        return this._adapter.sameYear(date, this.activeDate)\n            ? this._adapter.getMonth(date)\n            : null;\n    }\n\n    /** Creates an MdCalendarCell for the given month. */\n    private _createCellForMonth(month: number, monthName: string) {\n        let ariaLabel = this._adapter.format(\n            this._adapter.createDatetime(this._adapter.getYear(this.activeDate), month, 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)),\n            this._dateFormats.display.monthYearA11yLabel\n        );\n        return new GIPIDatetimepickerCalendarCell(month, monthName.toLocaleUpperCase(), ariaLabel, this._isMonthEnabled(month));\n    }\n\n    /** Whether the given month is enabled. */\n    private _isMonthEnabled(month: number) {\n        if (!this.dateFilter) {\n            return true;\n        }\n\n        let firstOfMonth = this._adapter.createDatetime(\n            this._adapter.getYear(this.activeDate),\n            month,\n            1,\n            this._adapter.getHour(this.activeDate),\n            this._adapter.getMinute(this.activeDate)\n        );\n\n        // If any date in the month is enabled count the month as enabled.\n        for (let date = firstOfMonth; this._adapter.getMonth(date) == month; date = this._adapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n}\n"]}

package/esm2015/shared/gipi-components/dropdown-menu/dropdown-menu.component.js

@@ -176,7 +176,7 @@ GIPIDropdownMenuComponent = GIPIDropdownMenuComponent_1 = __decorate([
             'class': 'gipi-dropdown-menu',
         },
         changeDetection: ChangeDetectionStrategy.OnPush,
-        styles: [".dropdown-menu-container{display:flex;flex-direction:column;gap:1rem;width:100%}.dropdown-menu-container .dropdown-menu-label{color:#131313;font-size:1.4rem;line-height:100%}.dropdown-menu-container .dropdown-menu-label>span{color:#d14014;font-size:inherit;line-height:inherit}.dropdown-menu-container .dropdown-menu-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;gap:1rem;width:100%;max-height:4rem;border-radius:5px;cursor:pointer;background-color:#fff;border:1px solid rgba(0,0,0,.12);color:#696969;transition:.2s}.dropdown-menu-container .dropdown-menu-content:focus-within,.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:active),.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.dropdown-menu-container .dropdown-menu-content:focus-within,.dropdown-menu-container .dropdown-menu-content:hover{border-color:#bfbfbf!important;background-color:#f5f5f5}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled){background-color:#e0e1e2!important;border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-input,.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-suffix .dropdown-menu-button{cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-suffix .dropdown-menu-trigger{border-color:#e0e1e2!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) mat-icon{color:#d1d2d4!important;fill:#d1d2d4!important;cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-input{cursor:pointer;height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1;max-width:90%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix{display:flex;flex-direction:row;align-items:center;gap:16px}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-trigger{display:flex;flex-direction:column;align-items:center;justify-content:center;padding-inline:8px;border-radius:40px;border:1px solid transparent;color:#131313;background-color:#f0f0f0;font-size:1.2rem;line-height:1.4rem}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-button{display:flex;align-items:center;justify-content:center;outline:0;border:none;cursor:pointer;background-color:transparent}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-button:hover:not(:disabled)>mat-icon{transform:scale(1.08)}.dropdown-menu-icon{width:1.6rem;height:1.6rem;font-size:1.6rem;color:#131313;fill:#131313}.btn-popover-content{background-color:#fff;border-radius:4px;box-shadow:0 2px 4px -1px rgba(0,0,0,.2),0 4px 5px 0 rgba(0,0,0,.14),0 1px 10px 0 rgba(0,0,0,.12);padding:8px}"]
+        styles: [".dropdown-menu-container{display:flex;flex-direction:column;gap:1rem;width:100%}.dropdown-menu-container .dropdown-menu-label{color:#131313;font-size:1.4rem;line-height:100%}.dropdown-menu-container .dropdown-menu-label>span{color:#d14014;font-size:inherit;line-height:inherit}.dropdown-menu-container .dropdown-menu-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;gap:1rem;width:100%;max-height:4rem;border-radius:5px;cursor:pointer;background-color:#fff;border:1px solid #0000001f;color:#696969;transition:.2s}.dropdown-menu-container .dropdown-menu-content:focus-within,.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:active),.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.dropdown-menu-container .dropdown-menu-content:focus-within,.dropdown-menu-container .dropdown-menu-content:hover{border-color:#bfbfbf!important;background-color:#f5f5f5}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled){background-color:#e0e1e2!important;border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-input,.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-suffix .dropdown-menu-button{cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) .dropdown-menu-suffix .dropdown-menu-trigger{border-color:#e0e1e2!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content:has(.dropdown-menu-input:disabled) mat-icon{color:#d1d2d4!important;fill:#d1d2d4!important;cursor:not-allowed!important;pointer-events:none!important}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-input{cursor:pointer;height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1;max-width:90%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix{display:flex;flex-direction:row;align-items:center;gap:16px}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-trigger{display:flex;flex-direction:column;align-items:center;justify-content:center;padding-inline:8px;border-radius:40px;border:1px solid transparent;color:#131313;background-color:#f0f0f0;font-size:1.2rem;line-height:1.4rem}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-button{display:flex;align-items:center;justify-content:center;outline:0;border:none;cursor:pointer;background-color:transparent}.dropdown-menu-container .dropdown-menu-content .dropdown-menu-suffix .dropdown-menu-button:hover:not(:disabled)>mat-icon{transform:scale(1.08)}.dropdown-menu-icon{width:1.6rem;height:1.6rem;font-size:1.6rem;color:#131313;fill:#131313}.btn-popover-content{background-color:#fff;border-radius:4px;box-shadow:0 2px 4px -1px rgba(0,0,0,.2),0 4px 5px 0 rgba(0,0,0,.14),0 1px 10px 0 rgba(0,0,0,.12);padding:8px}"]
     }),
     __metadata("design:paramtypes", [ChangeDetectorRef,
         ElementRef])

package/esm2015/shared/gipi-components/form-field/form-field.component.js

@@ -253,7 +253,7 @@ GIPIFormFieldComponent = GIPIFormFieldComponent_1 = __decorate([
             'class': 'gipi-form-field',
         },
         changeDetection: ChangeDetectionStrategy.OnPush,
-        styles: [":host{display:block;min-width:0;max-width:100%;flex:1}.form-field-container{display:flex;flex-direction:column;gap:1rem;width:100%}.form-field-container .form-field-label{color:#131313;font-size:1.4rem;line-height:100%}.form-field-container .form-field-label>span{color:#d14014;font-size:inherit;line-height:inherit}.form-field-container .form-field-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:1.2rem;gap:1rem;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid rgba(0,0,0,.12);color:#696969;caret-color:#9a9da2;transition:.2s}.form-field-container .form-field-content:focus-within,.form-field-container .form-field-content:has(.form-field-input:active),.form-field-container .form-field-content:has(.form-field-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.form-field-container .form-field-content:focus-within,.form-field-container .form-field-content:hover{border-color:#bfbfbf!important}.form-field-container .form-field-content:has(.form-field-input:invalid){border-color:#d14014!important;color:#d14014!important;caret-color:#d14014!important}.form-field-container .form-field-content:has(.form-field-input:invalid):focus-within{box-shadow:0 0 0 .2rem #f1c4b6!important}.form-field-container .form-field-content:has(.form-field-input:disabled){border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;caret-color:#d1d2d4!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-input,.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-suffix .form-field-button{cursor:not-allowed!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-suffix .form-field-trigger{border-color:#e0e1e2!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) mat-icon{color:#d1d2d4!important;fill:#d1d2d4!important;cursor:not-allowed!important;pointer-events:none!important}.form-field-container .form-field-content.form-field-select,.form-field-container .form-field-content.form-field-select .form-field-input{box-shadow:none!important;cursor:pointer!important}.form-field-container .form-field-content .form-field-input{height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1;max-width:85%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.form-field-container .form-field-content .form-field-suffix{display:flex;flex-direction:row;align-items:center;gap:1.6rem}.form-field-container .form-field-content .form-field-suffix .form-field-trigger{display:flex;flex-direction:column;align-items:center;justify-content:center;padding-inline:8px;border-radius:40px;border:1px solid transparent;color:#131313;background-color:#f0f0f0;font-size:1.2rem;line-height:1.4rem}.form-field-container .form-field-content .form-field-suffix .form-field-button{display:flex;align-items:center;justify-content:center;outline:0;border:none;cursor:pointer;background-color:transparent}.form-field-container .form-field-content .form-field-suffix .form-field-button:hover:not(:disabled)>mat-icon{transform:scale(1.08)}.form-field-icon{width:1.6rem;height:1.6rem;font-size:1.6rem;color:#131313;fill:#131313}.form-field-icon-arrow{border:solid #131313;border-width:0 2px 2px 0;display:inline-block;padding:3px;transform:rotate(45deg);margin:-5px 4px 0}"]
+        styles: [":host{display:block;min-width:0;max-width:100%;flex:1}.form-field-container{display:flex;flex-direction:column;gap:1rem;width:100%}.form-field-container .form-field-label{color:#131313;font-size:1.4rem;line-height:100%}.form-field-container .form-field-label>span{color:#d14014;font-size:inherit;line-height:inherit}.form-field-container .form-field-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:1.2rem;gap:1rem;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid #0000001f;color:#696969;caret-color:#9a9da2;transition:.2s}.form-field-container .form-field-content:focus-within,.form-field-container .form-field-content:has(.form-field-input:active),.form-field-container .form-field-content:has(.form-field-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.form-field-container .form-field-content:focus-within,.form-field-container .form-field-content:hover{border-color:#bfbfbf!important}.form-field-container .form-field-content:has(.form-field-input:invalid){border-color:#d14014!important;color:#d14014!important;caret-color:#d14014!important}.form-field-container .form-field-content:has(.form-field-input:invalid):focus-within{box-shadow:0 0 0 .2rem #f1c4b6!important}.form-field-container .form-field-content:has(.form-field-input:disabled){border-color:#e0e1e2!important;color:#d1d2d4!important;box-shadow:none!important;cursor:not-allowed!important;caret-color:#d1d2d4!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-input,.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-suffix .form-field-button{cursor:not-allowed!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) .form-field-suffix .form-field-trigger{border-color:#e0e1e2!important;pointer-events:none!important}.form-field-container .form-field-content:has(.form-field-input:disabled) mat-icon{color:#d1d2d4!important;fill:#d1d2d4!important;cursor:not-allowed!important;pointer-events:none!important}.form-field-container .form-field-content.form-field-select,.form-field-container .form-field-content.form-field-select .form-field-input{box-shadow:none!important;cursor:pointer!important}.form-field-container .form-field-content .form-field-input{height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1;max-width:85%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.form-field-container .form-field-content .form-field-suffix{display:flex;flex-direction:row;align-items:center;gap:1.6rem}.form-field-container .form-field-content .form-field-suffix .form-field-trigger{display:flex;flex-direction:column;align-items:center;justify-content:center;padding-inline:8px;border-radius:40px;border:1px solid transparent;color:#131313;background-color:#f0f0f0;font-size:1.2rem;line-height:1.4rem}.form-field-container .form-field-content .form-field-suffix .form-field-button{display:flex;align-items:center;justify-content:center;outline:0;border:none;cursor:pointer;background-color:transparent}.form-field-container .form-field-content .form-field-suffix .form-field-button:hover:not(:disabled)>mat-icon{transform:scale(1.08)}.form-field-icon{width:1.6rem;height:1.6rem;font-size:1.6rem;color:#131313;fill:#131313}.form-field-icon-arrow{border:solid #131313;border-width:0 2px 2px 0;display:inline-block;padding:3px;transform:rotate(45deg);margin:-5px 4px 0}"]
     }),
     __metadata("design:paramtypes", [ChangeDetectorRef,
         ElementRef])

package/esm2015/shared/gipi-components/input-currency/input-currency.component.js

@@ -188,7 +188,7 @@ GIPIInputCurrencyComponent = GIPIInputCurrencyComponent_1 = __decorate([
             'class': 'gipi-input-currency',
         },
         changeDetection: ChangeDetectionStrategy.OnPush,
-        styles: [":host{display:block;min-width:0;max-width:100%;flex:1}.input-currency-container{display:flex;flex-direction:column;gap:1rem;width:100%}.input-currency-container .input-currency-label{color:#131313;font-size:1.4rem;line-height:100%}.input-currency-container .input-currency-label>span{color:#d14014;font-size:inherit;line-height:inherit}.input-currency-container .input-currency-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid rgba(0,0,0,.12);color:#696969;caret-color:#9a9da2;transition:.2s}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:has(.input-currency-input:active),.input-currency-container .input-currency-content:has(.input-currency-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:hover{border-color:#bfbfbf!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid){border-color:#d14014!important;color:#d14014!important;caret-color:#d14014!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid):focus-within{box-shadow:0 0 0 .2rem #f1c4b6!important}.input-currency-container .input-currency-content:has(.input-currency-input:disabled){color:#bbbdc1!important;border-color:#e0e1e2!important;background-color:#f5f5f6!important;cursor:not-allowed!important;box-shadow:none!important;pointer-events:none!important}.input-currency-container .input-currency-content .input-currency-input{height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1}"]
+        styles: [":host{display:block;min-width:0;max-width:100%;flex:1}.input-currency-container{display:flex;flex-direction:column;gap:1rem;width:100%}.input-currency-container .input-currency-label{color:#131313;font-size:1.4rem;line-height:100%}.input-currency-container .input-currency-label>span{color:#d14014;font-size:inherit;line-height:inherit}.input-currency-container .input-currency-content{display:flex;flex-direction:row;align-items:center;justify-content:space-between;padding:12px;width:100%;max-height:4rem;border-radius:5px;cursor:text;background-color:#fff;border:1px solid #0000001f;color:#696969;caret-color:#9a9da2;transition:.2s}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:has(.input-currency-input:active),.input-currency-container .input-currency-content:has(.input-currency-input:focus){box-shadow:0 0 0 .2rem #f0f0f0}.input-currency-container .input-currency-content:focus-within,.input-currency-container .input-currency-content:hover{border-color:#bfbfbf!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid){border-color:#d14014!important;color:#d14014!important;caret-color:#d14014!important}.input-currency-container .input-currency-content:has(.input-currency-input:invalid):focus-within{box-shadow:0 0 0 .2rem #f1c4b6!important}.input-currency-container .input-currency-content:has(.input-currency-input:disabled){color:#bbbdc1!important;border-color:#e0e1e2!important;background-color:#f5f5f6!important;cursor:not-allowed!important;box-shadow:none!important;pointer-events:none!important}.input-currency-container .input-currency-content .input-currency-input{height:16px;outline:0;border:none;background-color:transparent;color:inherit;flex:1}"]
     }),
     __metadata("design:paramtypes", [ChangeDetectorRef,
         ElementRef])