@gipisistemas/ng-core 1.1.0 → 1.1.1

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/native-date-adapter.js

@@ -0,0 +1,294 @@
+import { __decorate, __metadata, __param } from "tslib";
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { Inject, Injectable, Optional, PLATFORM_ID } from '@angular/core';
+import { DateAdapter, MAT_DATE_LOCALE } from './date-adapter';
+import { Platform } from './platform';
+// TODO(mmalerba): Remove when we no longer support safari 9.
+/** Whether the browser supports the Intl API. */
+let SUPPORTS_INTL_API;
+// We need a try/catch around the reference to `Intl`, because accessing it in some cases can
+// cause IE to throw. These cases are tied to particular versions of Windows and can happen if
+// the consumer is providing a polyfilled `Map`. See:
+// https://github.com/Microsoft/ChakraCore/issues/3189
+// https://github.com/angular/components/issues/15687
+try {
+    SUPPORTS_INTL_API = typeof Intl != 'undefined';
+}
+catch (_a) {
+    SUPPORTS_INTL_API = false;
+}
+/** The default month names to use if Intl API is not available. */
+const DEFAULT_MONTH_NAMES = {
+    'long': [
+        'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',
+        'October', 'November', 'December'
+    ],
+    'short': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
+    'narrow': ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']
+};
+const ɵ0 = i => String(i + 1);
+/** The default date names to use if Intl API is not available. */
+const DEFAULT_DATE_NAMES = range(31, ɵ0);
+/** The default day of the week names to use if Intl API is not available. */
+const DEFAULT_DAY_OF_WEEK_NAMES = {
+    'long': ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+    'short': ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    'narrow': ['S', 'M', 'T', 'W', 'T', 'F', 'S']
+};
+/**
+ * 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 an with out 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}))?)?$/;
+/** 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. */
+let NativeDateAdapter = class NativeDateAdapter extends DateAdapter {
+    constructor(matDateLocale, _platformId) {
+        super();
+        this._platformId = _platformId;
+        /**
+         * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.
+         * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off
+         * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`
+         * will produce `'8/13/1800'`.
+         *
+         * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now
+         * getting the string representation of a Date object from its utc representation. We're keeping
+         * it here for sometime, just for precaution, in case we decide to revert some of these changes
+         * though.
+         */
+        this.useUtcForDisplay = true;
+        super.setLocale(matDateLocale);
+        const platform = new Platform(this._platformId);
+        if (platform) {
+            // IE does its own time zone correction, so we disable this on IE.
+            this.useUtcForDisplay = !platform.TRIDENT;
+            this._clampDate = platform.TRIDENT || platform.EDGE;
+        }
+        else {
+            this.useUtcForDisplay = true;
+            this._clampDate = false;
+        }
+    }
+    getYear(date) {
+        return date.getFullYear();
+    }
+    getMonth(date) {
+        return date.getMonth();
+    }
+    getDate(date) {
+        return date.getDate();
+    }
+    getDayOfWeek(date) {
+        return date.getDay();
+    }
+    getMonthNames(style) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });
+            return range(12, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1))));
+        }
+        return DEFAULT_MONTH_NAMES[style];
+    }
+    getDateNames() {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });
+            return range(31, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
+        }
+        return DEFAULT_DATE_NAMES;
+    }
+    getDayOfWeekNames(style) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });
+            return range(7, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
+        }
+        return DEFAULT_DAY_OF_WEEK_NAMES[style];
+    }
+    getYearName(date) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });
+            return this._stripDirectionalityCharacters(this._format(dtf, date));
+        }
+        return String(this.getYear(date));
+    }
+    getFirstDayOfWeek() {
+        // We can't tell using native JS Date what the first day of the week is, we default to Sunday.
+        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) {
+        // 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) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    today() {
+        return new Date();
+    }
+    parse(value) {
+        // 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.');
+        }
+        if (SUPPORTS_INTL_API) {
+            // On IE and Edge the i18n API will throw a hard error that can crash the entire app
+            // if we attempt to format a date whose year is less than 1 or greater than 9999.
+            if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {
+                date = this.clone(date);
+                date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));
+            }
+            displayFormat = Object.assign(Object.assign({}, displayFormat), { timeZone: 'utc' });
+            const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);
+            return this._stripDirectionalityCharacters(this._format(dtf, date));
+        }
+        return this._stripDirectionalityCharacters(date.toDateString());
+    }
+    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);
+    }
+    /** 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);
+    }
+    /**
+     * 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, '');
+    }
+    /**
+     * When converting 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, containg 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);
+    }
+};
+NativeDateAdapter.ctorParameters = () => [
+    { type: String, decorators: [{ type: Optional }, { type: Inject, args: [MAT_DATE_LOCALE,] }] },
+    { type: Object, decorators: [{ type: Inject, args: [PLATFORM_ID,] }] }
+];
+NativeDateAdapter = __decorate([
+    Injectable(),
+    __param(0, Optional()), __param(0, Inject(MAT_DATE_LOCALE)),
+    __param(1, Inject(PLATFORM_ID)),
+    __metadata("design:paramtypes", [String, Object])
+], NativeDateAdapter);
+export { NativeDateAdapter };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-date-adapter.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/shared/adapter/native-date-adapter.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nimport { Inject, Injectable, Optional, PLATFORM_ID } from '@angular/core';\nimport { DateAdapter, MAT_DATE_LOCALE } from './date-adapter';\nimport { Platform } from './platform';\n\n// TODO(mmalerba): Remove when we no longer support safari 9.\n/** Whether the browser supports the Intl API. */\nlet SUPPORTS_INTL_API: boolean;\n\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n    SUPPORTS_INTL_API = typeof Intl != 'undefined';\n} catch {\n    SUPPORTS_INTL_API = false;\n}\n\n/** The default month names to use if Intl API is not available. */\nconst DEFAULT_MONTH_NAMES = {\n    'long': [\n        'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September',\n        'October', 'November', 'December'\n    ],\n    'short': ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],\n    'narrow': ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']\n};\n\n\n/** The default date names to use if Intl API is not available. */\nconst DEFAULT_DATE_NAMES = range(31, i => String(i + 1));\n\n\n/** The default day of the week names to use if Intl API is not available. */\nconst DEFAULT_DAY_OF_WEEK_NAMES = {\n    'long': ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],\n    'short': ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n    'narrow': ['S', 'M', 'T', 'W', 'T', 'F', 'S']\n};\n\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings an with out of bounds month, date, etc.\n */\nconst ISO_8601_REGEX = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n\n\n/** Creates an array and fills it with values. */\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/** Adapts the native JS Date for use with cdk-based components that work with dates. */\n@Injectable()\nexport class NativeDateAdapter extends DateAdapter<Date> {\n\n    /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */\n    private readonly _clampDate: boolean;\n\n    /**\n     * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.\n     * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off\n     * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`\n     * will produce `'8/13/1800'`.\n     *\n     * TODO(mmalerba): drop this variable. It's not being used in the code right now. We're now\n     * getting the string representation of a Date object from its utc representation. We're keeping\n     * it here for sometime, just for precaution, in case we decide to revert some of these changes\n     * though.\n     */\n    useUtcForDisplay: boolean = true;\n\n    constructor(\n        @Optional() @Inject(MAT_DATE_LOCALE) matDateLocale: string,\n        @Inject(PLATFORM_ID) private _platformId: Object\n    ) {\n        super();\n        super.setLocale(matDateLocale);\n        const platform: Platform = new Platform(this._platformId);\n\n        if (platform) {\n            // IE does its own time zone correction, so we disable this on IE.\n            this.useUtcForDisplay = !platform.TRIDENT;\n            this._clampDate = platform.TRIDENT || platform.EDGE;\n        } else {\n            this.useUtcForDisplay = true;\n            this._clampDate = false;\n        }\n    }\n\n    getYear(date: Date): number {\n        return date.getFullYear();\n    }\n\n    getMonth(date: Date): number {\n        return date.getMonth();\n    }\n\n    getDate(date: Date): number {\n        return date.getDate();\n    }\n\n    getDayOfWeek(date: Date): number {\n        return date.getDay();\n    }\n\n    getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n        if (SUPPORTS_INTL_API) {\n            const dtf = new Intl.DateTimeFormat(this.locale, { month: style, timeZone: 'utc' });\n            return range(12, i => this._stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1))));\n        }\n        return DEFAULT_MONTH_NAMES[style];\n    }\n\n    getDateNames(): string[] {\n        if (SUPPORTS_INTL_API) {\n            const dtf = new Intl.DateTimeFormat(this.locale, { day: 'numeric', timeZone: 'utc' });\n            return range(31, i => this._stripDirectionalityCharacters(\n                this._format(dtf, new Date(2017, 0, i + 1))));\n        }\n        return DEFAULT_DATE_NAMES;\n    }\n\n    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n        if (SUPPORTS_INTL_API) {\n            const dtf = new Intl.DateTimeFormat(this.locale, { weekday: style, timeZone: 'utc' });\n            return range(7, i => this._stripDirectionalityCharacters(\n                this._format(dtf, new Date(2017, 0, i + 1))));\n        }\n        return DEFAULT_DAY_OF_WEEK_NAMES[style];\n    }\n\n    getYearName(date: Date): string {\n        if (SUPPORTS_INTL_API) {\n            const dtf = new Intl.DateTimeFormat(this.locale, { year: 'numeric', timeZone: 'utc' });\n            return this._stripDirectionalityCharacters(this._format(dtf, date));\n        }\n        return String(this.getYear(date));\n    }\n\n    getFirstDayOfWeek(): number {\n        // We can't tell using native JS Date what the first day of the week is, we default to Sunday.\n        return 0;\n    }\n\n    getNumDaysInMonth(date: Date): number {\n        return this.getDate(this._createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0));\n    }\n\n    clone(date: Date): Date {\n        return new Date(date.getTime());\n    }\n\n    createDate(year: number, month: number, date: 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        let result = this._createDateWithOverflow(year, month, date);\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    today(): Date {\n        return new Date();\n    }\n\n    parse(value: any): Date | null {\n        // We have no way using the native JS Date to set the parse format or locale, so we ignore these\n        // parameters.\n        if (typeof value == 'number') {\n            return new Date(value);\n        }\n        return value ? new Date(Date.parse(value)) : null;\n    }\n\n    format(date: Date, displayFormat: Object): string {\n        if (!this.isValid(date)) {\n            throw Error('NativeDateAdapter: Cannot format invalid date.');\n        }\n\n        if (SUPPORTS_INTL_API) {\n            // On IE and Edge the i18n API will throw a hard error that can crash the entire app\n            // if we attempt to format a date whose year is less than 1 or greater than 9999.\n            if (this._clampDate && (date.getFullYear() < 1 || date.getFullYear() > 9999)) {\n                date = this.clone(date);\n                date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));\n            }\n\n            displayFormat = { ...displayFormat, timeZone: 'utc' };\n\n            const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);\n            return this._stripDirectionalityCharacters(this._format(dtf, date));\n        }\n        return this._stripDirectionalityCharacters(date.toDateString());\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), this.getMonth(date) + months, this.getDate(date));\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);\n        }\n\n        return newDate;\n    }\n\n    addCalendarDays(date: Date, days: number): Date {\n        return this._createDateWithOverflow(this.getYear(date), this.getMonth(date), this.getDate(date) + days);\n    }\n\n    toIso8601(date: Date): string {\n        return [\n            date.getUTCFullYear(),\n            this._2digit(date.getUTCMonth() + 1),\n            this._2digit(date.getUTCDate())\n        ].join('-');\n    }\n\n    /**\n     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\n     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\n     * invalid date for all other values.\n     */\n    deserialize(value: any): Date | null {\n        if (typeof value === 'string') {\n            if (!value) {\n                return null;\n            }\n            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n            // string is the right format first.\n            if (ISO_8601_REGEX.test(value)) {\n                let date = new Date(value);\n                if (this.isValid(date)) {\n                    return date;\n                }\n            }\n        }\n        return super.deserialize(value);\n    }\n\n    isDateInstance(obj: any) {\n        return obj instanceof Date;\n    }\n\n    isValid(date: Date) {\n        return !isNaN(date.getTime());\n    }\n\n    invalid(): Date {\n        return new Date(NaN);\n    }\n\n    /** Creates a date but allows the month and date to overflow. */\n    private _createDateWithOverflow(year: number, month: number, date: number) {\n        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.\n        // To work around this we use `setFullYear` and `setHours` instead.\n        const d = new Date();\n        d.setFullYear(year, month, date);\n        d.setHours(0, 0, 0, 0);\n        return d;\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    /**\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     * When converting Date object to string, javascript built-in functions may return wrong\n     * results because it applies its internal DST rules. The DST rules around the world change\n     * very frequently, and the current valid rule is not always valid in previous years though.\n     * We work around this problem building a new Date object which has its internal UTC\n     * representation with the local date and time.\n     * @param dtf Intl.DateTimeFormat object, containg the desired string format. It must have\n     *    timeZone set to 'utc' to work fine.\n     * @param date Date from which we want to get the string representation according to dtf\n     * @returns A Date object with its UTC representation based on the passed in date info\n     */\n    private _format(dtf: Intl.DateTimeFormat, date: Date) {\n        // Passing the year to the constructor causes year numbers <100 to be converted to 19xx.\n        // To work around this we use `setUTCFullYear` and `setUTCHours` instead.\n        const d = new Date();\n        d.setUTCFullYear(date.getFullYear(), date.getMonth(), date.getDate());\n        d.setUTCHours(date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());\n        return dtf.format(d);\n    }\n}\n"]}

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/native-date-formats.js

@@ -0,0 +1,19 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export const MAT_NATIVE_DATE_FORMATS = {
+    parse: {
+        dateInput: null,
+    },
+    display: {
+        dateInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
+        monthYearLabel: { year: 'numeric', month: 'short' },
+        dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+        monthYearA11yLabel: { year: 'numeric', month: 'long' },
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlLWRhdGUtZm9ybWF0cy5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BnaXBpc2lzdGVtYXMvbmctY29yZS8iLCJzb3VyY2VzIjpbInNoYXJlZC9naXBpLWNvbXBvbmVudHMvZGF0ZXBpY2tlci9tYXQtZGF0ZXBpY2tlci9zaGFyZWQvYWRhcHRlci9uYXRpdmUtZGF0ZS1mb3JtYXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUtILE1BQU0sQ0FBQyxNQUFNLHVCQUF1QixHQUFtQjtJQUNuRCxLQUFLLEVBQUU7UUFDSCxTQUFTLEVBQUUsSUFBSTtLQUNsQjtJQUNELE9BQU8sRUFBRTtRQUNMLFNBQVMsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFNBQVMsRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFO1FBQ2hFLGNBQWMsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRTtRQUNuRCxhQUFhLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRTtRQUNqRSxrQkFBa0IsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRTtLQUN6RDtDQUNKLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgR29vZ2xlIExMQyBBbGwgUmlnaHRzIFJlc2VydmVkLlxuICpcbiAqIFVzZSBvZiB0aGlzIHNvdXJjZSBjb2RlIGlzIGdvdmVybmVkIGJ5IGFuIE1JVC1zdHlsZSBsaWNlbnNlIHRoYXQgY2FuIGJlXG4gKiBmb3VuZCBpbiB0aGUgTElDRU5TRSBmaWxlIGF0IGh0dHBzOi8vYW5ndWxhci5pby9saWNlbnNlXG4gKi9cblxuaW1wb3J0IHsgTWF0RGF0ZUZvcm1hdHMgfSBmcm9tICcuL2RhdGUtZm9ybWF0cyc7XG5cblxuZXhwb3J0IGNvbnN0IE1BVF9OQVRJVkVfREFURV9GT1JNQVRTOiBNYXREYXRlRm9ybWF0cyA9IHtcbiAgICBwYXJzZToge1xuICAgICAgICBkYXRlSW5wdXQ6IG51bGwsXG4gICAgfSxcbiAgICBkaXNwbGF5OiB7XG4gICAgICAgIGRhdGVJbnB1dDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnbnVtZXJpYycsIGRheTogJ251bWVyaWMnIH0sXG4gICAgICAgIG1vbnRoWWVhckxhYmVsOiB7IHllYXI6ICdudW1lcmljJywgbW9udGg6ICdzaG9ydCcgfSxcbiAgICAgICAgZGF0ZUExMXlMYWJlbDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnbG9uZycsIGRheTogJ251bWVyaWMnIH0sXG4gICAgICAgIG1vbnRoWWVhckExMXlMYWJlbDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnbG9uZycgfSxcbiAgICB9XG59O1xuIl19

package/esm2015/shared/gipi-components/datepicker/mat-datepicker/shared/adapter/platform.js

@@ -0,0 +1,81 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, PLATFORM_ID } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+// Whether the current platform supports the V8 Break Iterator. The V8 check
+// is necessary to detect all Blink based browsers.
+let hasV8BreakIterator;
+// We need a try/catch around the reference to `Intl`, because accessing it in some cases can
+// cause IE to throw. These cases are tied to particular versions of Windows and can happen if
+// the consumer is providing a polyfilled `Map`. See:
+// https://github.com/Microsoft/ChakraCore/issues/3189
+// https://github.com/angular/components/issues/15687
+try {
+    hasV8BreakIterator = typeof Intl !== 'undefined' && Intl.v8BreakIterator;
+}
+catch (_a) {
+    hasV8BreakIterator = false;
+}
+/**
+ * Service to detect the current platform by comparing the userAgent strings and
+ * checking browser-specific global properties.
+ */
+let Platform = class Platform {
+    constructor(_platformId) {
+        this._platformId = _platformId;
+        // We want to use the Angular platform check because if the Document is shimmed
+        // without the navigator, the following checks will fail. This is preferred because
+        // sometimes the Document may be shimmed without the user's knowledge or intention
+        /** Whether the Angular application is being rendered in the browser. */
+        this.isBrowser = this._platformId
+            ? isPlatformBrowser(this._platformId)
+            : typeof document === 'object' && !!document;
+        /** Whether the current browser is Microsoft Edge. */
+        this.EDGE = this.isBrowser && /(edge)/i.test(navigator.userAgent);
+        /** Whether the current rendering engine is Microsoft Trident. */
+        this.TRIDENT = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);
+        // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.
+        /** Whether the current rendering engine is Blink. */
+        this.BLINK = this.isBrowser &&
+            !!(window.chrome || hasV8BreakIterator) &&
+            typeof CSS !== 'undefined' &&
+            !this.EDGE &&
+            !this.TRIDENT;
+        // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to
+        // ensure that Webkit runs standalone and is not used as another engine's base.
+        /** Whether the current rendering engine is WebKit. */
+        this.WEBKIT = this.isBrowser &&
+            /AppleWebKit/i.test(navigator.userAgent) &&
+            !this.BLINK &&
+            !this.EDGE &&
+            !this.TRIDENT;
+        /** Whether the current platform is Apple iOS. */
+        this.IOS = this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);
+        // It's difficult to detect the plain Gecko engine, because most of the browsers identify
+        // them self as Gecko-like browsers and modify the userAgent's according to that.
+        // Since we only cover one explicit Firefox case, we can simply check for Firefox
+        // instead of having an unstable check for Gecko.
+        /** Whether the current browser is Firefox. */
+        this.FIREFOX = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);
+        /** Whether the current platform is Android. */
+        // Trident on mobile adds the android platform to the userAgent to trick detections.
+        this.ANDROID = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;
+        // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake
+        // this and just place the Safari keyword in the userAgent. To be more safe about Safari every
+        // Safari browser should also use Webkit as its layout engine.
+        /** Whether the current browser is Safari. */
+        this.SAFARI = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;
+    }
+};
+Platform = __decorate([
+    __param(0, Inject(PLATFORM_ID)),
+    __metadata("design:paramtypes", [Object])
+], Platform);
+export { Platform };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"platform.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datepicker/mat-datepicker/shared/adapter/platform.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;;AAEH,OAAO,EAAE,MAAM,EAAc,WAAW,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAEpD,4EAA4E;AAC5E,mDAAmD;AACnD,IAAI,kBAA2B,CAAC;AAEhC,6FAA6F;AAC7F,8FAA8F;AAC9F,qDAAqD;AACrD,sDAAsD;AACtD,qDAAqD;AACrD,IAAI;IACA,kBAAkB,GAAG,OAAO,IAAI,KAAK,WAAW,IAAK,IAAY,CAAC,eAAe,CAAC;CACrF;AAAC,WAAM;IACJ,kBAAkB,GAAG,KAAK,CAAC;CAC9B;AAED;;;GAGG;AACH,IAAa,QAAQ,GAArB,MAAa,QAAQ;IAuDjB,YAAyC,WAAmB;QAAnB,gBAAW,GAAX,WAAW,CAAQ;QAtD5D,+EAA+E;QAC/E,mFAAmF;QACnF,kFAAkF;QAClF,wEAAwE;QACxE,cAAS,GAAY,IAAI,CAAC,WAAW;YACjC,CAAC,CAAC,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC;YACrC,CAAC,CAAC,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,CAAC,QAAQ,CAAC;QAEjD,qDAAqD;QACrD,SAAI,GAAY,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEtE,iEAAiE;QACjE,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEjF,2FAA2F;QAC3F,qDAAqD;QACrD,UAAK,GACD,IAAI,CAAC,SAAS;YACd,CAAC,CAAC,CAAE,MAAc,CAAC,MAAM,IAAI,kBAAkB,CAAC;YAChD,OAAO,GAAG,KAAK,WAAW;YAC1B,CAAC,IAAI,CAAC,IAAI;YACV,CAAC,IAAI,CAAC,OAAO,CAAC;QAElB,uFAAuF;QACvF,+EAA+E;QAC/E,sDAAsD;QACtD,WAAM,GACF,IAAI,CAAC,SAAS;YACd,cAAc,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;YACxC,CAAC,IAAI,CAAC,KAAK;YACX,CAAC,IAAI,CAAC,IAAI;YACV,CAAC,IAAI,CAAC,OAAO,CAAC;QAElB,iDAAiD;QACjD,QAAG,GACC,IAAI,CAAC,SAAS,IAAI,kBAAkB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,UAAU,IAAI,MAAM,CAAC,CAAC;QAE9F,yFAAyF;QACzF,iFAAiF;QACjF,iFAAiF;QACjF,iDAAiD;QACjD,8CAA8C;QAC9C,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAEtF,+CAA+C;QAC/C,oFAAoF;QACpF,YAAO,GAAY,IAAI,CAAC,SAAS,IAAI,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC;QAE3F,6FAA6F;QAC7F,8FAA8F;QAC9F,8DAA8D;QAC9D,6CAA6C;QAC7C,WAAM,GAAY,IAAI,CAAC,SAAS,IAAI,SAAS,CAAC,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,CAAC;IAEvB,CAAC;CACpE,CAAA;AAxDY,QAAQ;IAuDJ,WAAA,MAAM,CAAC,WAAW,CAAC,CAAA;qCAAsB,MAAM;GAvDnD,QAAQ,CAwDpB;SAxDY,QAAQ","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport { Inject, Injectable, PLATFORM_ID } from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\n\n// Whether the current platform supports the V8 Break Iterator. The V8 check\n// is necessary to detect all Blink based browsers.\nlet hasV8BreakIterator: boolean;\n\n// We need a try/catch around the reference to `Intl`, because accessing it in some cases can\n// cause IE to throw. These cases are tied to particular versions of Windows and can happen if\n// the consumer is providing a polyfilled `Map`. See:\n// https://github.com/Microsoft/ChakraCore/issues/3189\n// https://github.com/angular/components/issues/15687\ntry {\n    hasV8BreakIterator = typeof Intl !== 'undefined' && (Intl as any).v8BreakIterator;\n} catch {\n    hasV8BreakIterator = false;\n}\n\n/**\n * Service to detect the current platform by comparing the userAgent strings and\n * checking browser-specific global properties.\n */\nexport class Platform {\n    // We want to use the Angular platform check because if the Document is shimmed\n    // without the navigator, the following checks will fail. This is preferred because\n    // sometimes the Document may be shimmed without the user's knowledge or intention\n    /** Whether the Angular application is being rendered in the browser. */\n    isBrowser: boolean = this._platformId\n        ? isPlatformBrowser(this._platformId)\n        : typeof document === 'object' && !!document;\n\n    /** Whether the current browser is Microsoft Edge. */\n    EDGE: boolean = this.isBrowser && /(edge)/i.test(navigator.userAgent);\n\n    /** Whether the current rendering engine is Microsoft Trident. */\n    TRIDENT: boolean = this.isBrowser && /(msie|trident)/i.test(navigator.userAgent);\n\n    // EdgeHTML and Trident mock Blink specific things and need to be excluded from this check.\n    /** Whether the current rendering engine is Blink. */\n    BLINK: boolean =\n        this.isBrowser &&\n        !!((window as any).chrome || hasV8BreakIterator) &&\n        typeof CSS !== 'undefined' &&\n        !this.EDGE &&\n        !this.TRIDENT;\n\n    // Webkit is part of the userAgent in EdgeHTML, Blink and Trident. Therefore we need to\n    // ensure that Webkit runs standalone and is not used as another engine's base.\n    /** Whether the current rendering engine is WebKit. */\n    WEBKIT: boolean =\n        this.isBrowser &&\n        /AppleWebKit/i.test(navigator.userAgent) &&\n        !this.BLINK &&\n        !this.EDGE &&\n        !this.TRIDENT;\n\n    /** Whether the current platform is Apple iOS. */\n    IOS: boolean =\n        this.isBrowser && /iPad|iPhone|iPod/.test(navigator.userAgent) && !('MSStream' in window);\n\n    // It's difficult to detect the plain Gecko engine, because most of the browsers identify\n    // them self as Gecko-like browsers and modify the userAgent's according to that.\n    // Since we only cover one explicit Firefox case, we can simply check for Firefox\n    // instead of having an unstable check for Gecko.\n    /** Whether the current browser is Firefox. */\n    FIREFOX: boolean = this.isBrowser && /(firefox|minefield)/i.test(navigator.userAgent);\n\n    /** Whether the current platform is Android. */\n    // Trident on mobile adds the android platform to the userAgent to trick detections.\n    ANDROID: boolean = this.isBrowser && /android/i.test(navigator.userAgent) && !this.TRIDENT;\n\n    // Safari browsers will include the Safari keyword in their userAgent. Some browsers may fake\n    // this and just place the Safari keyword in the userAgent. To be more safe about Safari every\n    // Safari browser should also use Webkit as its layout engine.\n    /** Whether the current browser is Safari. */\n    SAFARI: boolean = this.isBrowser && /safari/i.test(navigator.userAgent) && this.WEBKIT;\n\n    constructor(@Inject(PLATFORM_ID) private _platformId: Object) { }\n}\n"]}