@gipisistemas/ng-core 1.1.10 → 1.1.12

package/esm5/shared/gipi-components/datetime-picker/mat-datetime-picker/month-view.js

@@ -0,0 +1,160 @@
+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';
+var DAYS_PER_WEEK = 7;
+/**
+ * An internal component used to display a single month in the datepicker.
+ * @docs-private
+ */
+var GIPIDatetimepickerMonthViewComponent = /** @class */ (function () {
+    function GIPIDatetimepickerMonthViewComponent(_adapter, _dateFormats) {
+        this._adapter = _adapter;
+        this._dateFormats = _dateFormats;
+        this.type = 'date';
+        /** Emits when a new date is selected. */
+        this.selectedChange = new EventEmitter();
+        this._userSelection = new EventEmitter();
+        if (!this._adapter) {
+            throw createMissingDateImplError('GIPIDatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');
+        }
+        var firstDayOfWeek = this._adapter.getFirstDayOfWeek();
+        var narrowWeekdays = this._adapter.getDayOfWeekNames('narrow');
+        var longWeekdays = this._adapter.getDayOfWeekNames('long');
+        // Rotate the labels for days of the week based on the configured first day of the week.
+        var weekdays = longWeekdays.map(function (long, i) { return { long: long, narrow: narrowWeekdays[i] }; });
+        this._weekdays = weekdays
+            .slice(firstDayOfWeek)
+            .concat(weekdays.slice(0, firstDayOfWeek));
+        this._activeDate = this._adapter.today();
+    }
+    Object.defineProperty(GIPIDatetimepickerMonthViewComponent.prototype, "activeDate", {
+        get: function () {
+            return this._activeDate;
+        },
+        set: function (value) {
+            var oldActiveDate = this._activeDate;
+            this._activeDate = value || this._adapter.today();
+            if (oldActiveDate && this._activeDate && !this._adapter.sameMonthAndYear(oldActiveDate, this._activeDate)) {
+                this._init();
+                if (this._adapter.isInNextMonth(oldActiveDate, this._activeDate)) {
+                    this.calendarState('right');
+                }
+                else {
+                    this.calendarState('left');
+                }
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerMonthViewComponent.prototype, "selected", {
+        get: function () {
+            return this._selected;
+        },
+        set: function (value) {
+            this._selected = value;
+            this._selectedDate = this._getDateInCurrentMonth(this.selected);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerMonthViewComponent.prototype.ngAfterContentInit = function () {
+        this._init();
+    };
+    /** Handles when a new date is selected. */
+    GIPIDatetimepickerMonthViewComponent.prototype._dateSelected = function (date) {
+        this.selectedChange.emit(this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), date, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate)));
+        if (this.type === 'date') {
+            this._userSelection.emit();
+        }
+    };
+    GIPIDatetimepickerMonthViewComponent.prototype._calendarStateDone = function () {
+        this._calendarState = '';
+    };
+    /** Initializes this month view. */
+    GIPIDatetimepickerMonthViewComponent.prototype._init = function () {
+        this._selectedDate = this._getDateInCurrentMonth(this.selected);
+        this._todayDate = this._getDateInCurrentMonth(this._adapter.today());
+        var firstOfMonth = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate));
+        this._firstWeekOffset = (DAYS_PER_WEEK + this._adapter.getDayOfWeek(firstOfMonth) - this._adapter.getFirstDayOfWeek()) % DAYS_PER_WEEK;
+        this._createWeekCells();
+    };
+    /** Creates MdCalendarCells for the dates in this month. */
+    GIPIDatetimepickerMonthViewComponent.prototype._createWeekCells = function () {
+        var daysInMonth = this._adapter.getNumDaysInMonth(this.activeDate);
+        var dateNames = this._adapter.getDateNames();
+        this._weeks = [[]];
+        for (var i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {
+            if (cell == DAYS_PER_WEEK) {
+                this._weeks.push([]);
+                cell = 0;
+            }
+            var date = this._adapter.createDatetime(this._adapter.getYear(this.activeDate), this._adapter.getMonth(this.activeDate), i + 1, this._adapter.getHour(this.activeDate), this._adapter.getMinute(this.activeDate));
+            var enabled = !this.dateFilter || this.dateFilter(date);
+            var ariaLabel = this._adapter.format(date, this._dateFormats.display.dateA11yLabel);
+            this._weeks[this._weeks.length - 1].push(new GIPIDatetimepickerCalendarCell(i + 1, dateNames[i], ariaLabel, enabled));
+        }
+    };
+    /** Gets the date in this month that the given Date falls on.  Returns null if the given Date is in another month. */
+    GIPIDatetimepickerMonthViewComponent.prototype._getDateInCurrentMonth = function (date) {
+        return this._adapter.sameMonthAndYear(date, this.activeDate)
+            ? this._adapter.getDate(date)
+            : null;
+    };
+    GIPIDatetimepickerMonthViewComponent.prototype.calendarState = function (direction) {
+        this._calendarState = direction;
+    };
+    GIPIDatetimepickerMonthViewComponent.ctorParameters = function () { return [
+        { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [GIPI_DATETIME_FORMATS,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "type", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "dateFilter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "activeDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "selected", null);
+    __decorate([
+        Output(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "selectedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerMonthViewComponent.prototype, "_userSelection", void 0);
+    GIPIDatetimepickerMonthViewComponent = __decorate([
+        Component({
+            selector: 'gipi-mat-datetime-picker-month-view',
+            template: "<table class=\"gipi-mat-datetime-picker-calendar-table\">\n    <thead class=\"gipi-mat-datetime-picker-calendar-table-header\">\n        <tr>\n            <th *ngFor=\"let day of _weekdays\"\n                [attr.aria-label]=\"day.long\">\n                {{ day.narrow }}\n            </th>\n        </tr>\n        <tr>\n            <th class=\"gipi-mat-datetime-picker-calendar-table-header-divider\"\n                colspan=\"7\"\n                aria-hidden=\"true\">\n            </th>\n        </tr>\n    </thead>\n    <tbody gipiMatDatetimePickerCalendarBody\n           role=\"grid\"\n           [activeCell]=\"_adapter.getDate(activeDate) - 1\"\n           [rows]=\"_weeks\"\n           [selectedValue]=\"_selectedDate\"\n           [todayValue]=\"_todayDate\"\n           [@slideCalendar]=\"_calendarState\"\n           (@slideCalendar.done)=\"_calendarStateDone()\"\n           (selectedValueChange)=\"_dateSelected($event)\">\n    </tbody>\n</table>",
+            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])
+    ], GIPIDatetimepickerMonthViewComponent);
+    return GIPIDatetimepickerMonthViewComponent;
+}());
+export { GIPIDatetimepickerMonthViewComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"month-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/month-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\nconst DAYS_PER_WEEK = 7;\n\n/**\n * An internal component used to display a single month in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datetime-picker-month-view',\n    templateUrl: 'month-view.html',\n    animations: [slideCalendar],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class GIPIDatetimepickerMonthViewComponent<D> implements AfterContentInit {\n\n    /** Grid of calendar cells representing the dates of the month. */\n    _weeks: GIPIDatetimepickerCalendarCell[][];\n\n    /** The number of blank cells in the first row before the 1st of the month. */\n    _firstWeekOffset: number;\n\n    /** The date of the month that the currently selected Date falls on. Null if the currently selected Date is in another month. */\n    _selectedDate: number;\n\n    /** The date of the month that today falls on. Null if today is in another month. */\n    _todayDate: number;\n\n    /** The names of the weekdays. */\n    _weekdays: { long: string; narrow: string }[];\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 month view (everything other than the month and 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.sameMonthAndYear(oldActiveDate, this._activeDate)) {\n            this._init();\n            if (this._adapter.isInNextMonth(oldActiveDate, this._activeDate)) {\n                this.calendarState('right');\n            } else {\n                this.calendarState('left');\n            }\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._selectedDate = this._getDateInCurrentMonth(this.selected);\n    }\n\n    /** Emits when a new date 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('GIPIDatetimeAdapter');\n        }\n\n        if (!this._dateFormats) {\n            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');\n        }\n\n        const firstDayOfWeek = this._adapter.getFirstDayOfWeek();\n        const narrowWeekdays = this._adapter.getDayOfWeekNames('narrow');\n        const longWeekdays = this._adapter.getDayOfWeekNames('long');\n\n        // Rotate the labels for days of the week based on the configured first day of the week.\n        let weekdays = longWeekdays.map((long, i) => { return { long, narrow: narrowWeekdays[i] }; });\n        this._weekdays = weekdays\n            .slice(firstDayOfWeek)\n            .concat(weekdays.slice(0, firstDayOfWeek));\n\n        this._activeDate = this._adapter.today();\n    }\n\n    ngAfterContentInit(): void {\n        this._init();\n    }\n\n    /** Handles when a new date is selected. */\n    _dateSelected(date: number) {\n        this.selectedChange.emit(\n            this._adapter.createDatetime(\n                this._adapter.getYear(this.activeDate),\n                this._adapter.getMonth(this.activeDate),\n                date,\n                this._adapter.getHour(this.activeDate),\n                this._adapter.getMinute(this.activeDate)\n            )\n        );\n        if (this.type === 'date') {\n            this._userSelection.emit();\n        }\n    }\n\n    _calendarStateDone() {\n        this._calendarState = '';\n    }\n\n    /** Initializes this month view. */\n    private _init() {\n        this._selectedDate = this._getDateInCurrentMonth(this.selected);\n        this._todayDate = this._getDateInCurrentMonth(this._adapter.today());\n\n        let firstOfMonth = this._adapter.createDatetime(\n            this._adapter.getYear(this.activeDate),\n            this._adapter.getMonth(this.activeDate),\n            1,\n            this._adapter.getHour(this.activeDate),\n            this._adapter.getMinute(this.activeDate)\n        );\n        this._firstWeekOffset = (DAYS_PER_WEEK + this._adapter.getDayOfWeek(firstOfMonth) - this._adapter.getFirstDayOfWeek()) % DAYS_PER_WEEK;\n\n        this._createWeekCells();\n    }\n\n    /** Creates MdCalendarCells for the dates in this month. */\n    private _createWeekCells(): void {\n        let daysInMonth = this._adapter.getNumDaysInMonth(this.activeDate);\n        let dateNames = this._adapter.getDateNames();\n        this._weeks = [[]];\n        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {\n            if (cell == DAYS_PER_WEEK) {\n                this._weeks.push([]);\n                cell = 0;\n            }\n            let date = this._adapter.createDatetime(\n                this._adapter.getYear(this.activeDate),\n                this._adapter.getMonth(this.activeDate),\n                i + 1,\n                this._adapter.getHour(this.activeDate),\n                this._adapter.getMinute(this.activeDate)\n            );\n            let enabled = !this.dateFilter || this.dateFilter(date);\n            let ariaLabel = this._adapter.format(date, this._dateFormats.display.dateA11yLabel);\n            this._weeks[this._weeks.length - 1].push(new GIPIDatetimepickerCalendarCell(i + 1, dateNames[i], ariaLabel, enabled));\n        }\n    }\n\n    /** Gets the date in this month that the given Date falls on.  Returns null if the given Date is in another month. */\n    private _getDateInCurrentMonth(date: D): number {\n        return this._adapter.sameMonthAndYear(date, this.activeDate)\n            ? this._adapter.getDate(date)\n            : null;\n    }\n\n    private calendarState(direction: string): void {\n        this._calendarState = direction;\n    }\n\n}\n"]}

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

@@ -0,0 +1,248 @@
+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';
+export var yearsPerPage = 24;
+export var yearsPerRow = 4;
+/**
+ * An internal component used to display multiple years in the datepicker.
+ * @docs-private
+ */
+var GIPIDatetimepickerMultiYearViewComponent = /** @class */ (function () {
+    function GIPIDatetimepickerMultiYearViewComponent(_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('GIPIDatetimeAdapter');
+        }
+        if (!this._dateFormats) {
+            throw createMissingDateImplError('GIPI_DATETIME_FORMATS');
+        }
+        this._activeDate = this._adapter.today();
+    }
+    Object.defineProperty(GIPIDatetimepickerMultiYearViewComponent.prototype, "activeDate", {
+        get: function () {
+            return this._activeDate;
+        },
+        set: function (value) {
+            var oldActiveDate = this._activeDate;
+            this._activeDate = value || this._adapter.today();
+            if (oldActiveDate && this._activeDate && !isSameMultiYearView(this._adapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {
+                this._init();
+            }
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerMultiYearViewComponent.prototype, "selected", {
+        get: function () {
+            return this._selected;
+        },
+        set: function (value) {
+            this._selected = value;
+            this._selectedYear = this._selected && this._adapter.getYear(this._selected);
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerMultiYearViewComponent.prototype, "minDate", {
+        get: function () {
+            return this._minDate;
+        },
+        set: function (value) {
+            this._minDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(GIPIDatetimepickerMultiYearViewComponent.prototype, "maxDate", {
+        get: function () {
+            return this._maxDate;
+        },
+        set: function (value) {
+            this._maxDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+        },
+        enumerable: false,
+        configurable: true
+    });
+    GIPIDatetimepickerMultiYearViewComponent.prototype.ngAfterContentInit = function () {
+        this._init();
+    };
+    /** Handles when a new year is selected. */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._yearSelected = function (year) {
+        var month = this._adapter.getMonth(this.activeDate);
+        var normalizedDate = this._adapter.createDatetime(year, month, 1, 0, 0);
+        this.selectedChange.emit(this._adapter.createDatetime(year, 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 === 'year') {
+            this._userSelection.emit();
+        }
+    };
+    GIPIDatetimepickerMultiYearViewComponent.prototype._getActiveCell = function () {
+        return getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+    };
+    GIPIDatetimepickerMultiYearViewComponent.prototype._calendarStateDone = function () {
+        this._calendarState = '';
+    };
+    /** Initializes this year view. */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._init = function () {
+        var _this = this;
+        this._todayYear = this._adapter.getYear(this._adapter.today());
+        this._yearLabel = this._adapter.getYearName(this.activeDate);
+        var activeYear = this._adapter.getYear(this.activeDate);
+        var minYearOfPage = activeYear - getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+        this._years = [];
+        for (var i = 0, row = []; i < yearsPerPage; i++) {
+            row.push(minYearOfPage + i);
+            if (row.length == yearsPerRow) {
+                this._years.push(row.map(function (year) { return _this._createCellForYear(year); }));
+                row = [];
+            }
+        }
+    };
+    /** Creates an GIPIDatetimepickerCalendarCell for the given year. */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._createCellForYear = function (year) {
+        var yearName = this._adapter.getYearName(this._adapter.createDate(year, 0, 1));
+        return new GIPIDatetimepickerCalendarCell(year, yearName, yearName, this._shouldEnableYear(year));
+    };
+    /** Whether the given year is enabled. */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._shouldEnableYear = function (year) {
+        // disable if the year is greater than maxDate lower than minDate
+        if (year === undefined ||
+            year === null ||
+            (this.maxDate && year > this._adapter.getYear(this.maxDate)) ||
+            (this.minDate && year < this._adapter.getYear(this.minDate))) {
+            return false;
+        }
+        // enable if it reaches here and there's no filter defined
+        if (!this.dateFilter) {
+            return true;
+        }
+        var firstOfYear = this._adapter.createDate(year, 0, 1);
+        // If any date in the year is enabled count the year as enabled.
+        for (var date = firstOfYear; this._adapter.getYear(date) == year; date = this._adapter.addCalendarDays(date, 1)) {
+            if (this.dateFilter(date)) {
+                return true;
+            }
+        }
+        return false;
+    };
+    /**
+     * Gets the year in this years range that the given Date falls on.
+     * Returns null if the given Date is not in this range.
+     */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._getYearInCurrentRange = function (date) {
+        var year = this._adapter.getYear(date);
+        return this._isInRange(year) ? year : null;
+    };
+    /**
+     * Validate if the current year is in the current range
+     * Returns true if is in range else returns false
+     */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._isInRange = function (year) {
+        return true;
+    };
+    /**
+     * @param obj The object to check.
+     * @returns The given object if it is both a date instance and valid, otherwise null.
+     */
+    GIPIDatetimepickerMultiYearViewComponent.prototype._getValidDateOrNull = function (obj) {
+        return this._adapter.isDateInstance(obj) && this._adapter.isValid(obj) ? obj : null;
+    };
+    GIPIDatetimepickerMultiYearViewComponent.ctorParameters = function () { return [
+        { type: GIPIDatetimeAdapter, decorators: [{ type: Optional }] },
+        { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [GIPI_DATETIME_FORMATS,] }] }
+    ]; };
+    __decorate([
+        Input(),
+        __metadata("design:type", String)
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "type", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Function)
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "dateFilter", void 0);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "activeDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "selected", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "minDate", null);
+    __decorate([
+        Input(),
+        __metadata("design:type", Object),
+        __metadata("design:paramtypes", [Object])
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "maxDate", null);
+    __decorate([
+        Output(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "selectedChange", void 0);
+    __decorate([
+        Output(),
+        __metadata("design:type", Object)
+    ], GIPIDatetimepickerMultiYearViewComponent.prototype, "_userSelection", void 0);
+    GIPIDatetimepickerMultiYearViewComponent = __decorate([
+        Component({
+            selector: 'gipi-mat-datetime-picker-multi-year-view',
+            template: "<table class=\"gipi-mat-datetime-picker-calendar-table\">\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           role=\"grid\"\n           allowDisabledSelection=\"true\"\n           [cellAspectRatio]=\"4 / 7\"\n           [numCols]=\"4\"\n           [rows]=\"_years\"\n           [activeCell]=\"_getActiveCell()\"\n           [selectedValue]=\"_selectedYear\"\n           [todayValue]=\"_todayYear\"\n           [@slideCalendar]=\"_calendarState\"\n           (@slideCalendar.done)=\"_calendarStateDone()\"\n           (selectedValueChange)=\"_yearSelected($event)\">\n    </tbody>\n</table>",
+            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])
+    ], GIPIDatetimepickerMultiYearViewComponent);
+    return GIPIDatetimepickerMultiYearViewComponent;
+}());
+export { GIPIDatetimepickerMultiYearViewComponent };
+export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {
+    var year1 = dateAdapter.getYear(date1);
+    var year2 = dateAdapter.getYear(date2);
+    var startingYear = getStartingYear(dateAdapter, minDate, maxDate);
+    return (Math.floor((year1 - startingYear) / yearsPerPage) === Math.floor((year2 - startingYear) / yearsPerPage));
+}
+/**
+ * When the multi-year view is first opened, the active year will be in view.
+ * So we compute how many years are between the active year and the *slot* where our
+ * "startingYear" will render when paged into view.
+ */
+export function getActiveOffset(dateAdapter, activeDate, minDate, maxDate) {
+    var activeYear = dateAdapter.getYear(activeDate);
+    return euclideanModulo(activeYear - getStartingYear(dateAdapter, minDate, maxDate), yearsPerPage);
+}
+/**
+ * We pick a "starting" year such that either the maximum year would be at the end
+ * or the minimum year would be at the beginning of a page.
+ */
+function getStartingYear(dateAdapter, minDate, maxDate) {
+    var startingYear = 0;
+    if (maxDate) {
+        var maxYear = dateAdapter.getYear(maxDate);
+        startingYear = maxYear - yearsPerPage + 1;
+    }
+    else if (minDate) {
+        startingYear = dateAdapter.getYear(minDate);
+    }
+    return startingYear;
+}
+/** Gets remainder that is non-negative, even if first number is negative */
+function euclideanModulo(a, b) {
+    return ((a % b) + b) % b;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-year-view.js","sourceRoot":"ng://@gipisistemas/ng-core/","sources":["shared/gipi-components/datetime-picker/mat-datetime-picker/multi-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\nexport const yearsPerPage = 24;\n\nexport const yearsPerRow = 4;\n\n/**\n * An internal component used to display multiple years in the datepicker.\n * @docs-private\n */\n@Component({\n    selector: 'gipi-mat-datetime-picker-multi-year-view',\n    templateUrl: 'multi-year-view.html',\n    animations: [slideCalendar],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class GIPIDatetimepickerMultiYearViewComponent<D> implements AfterContentInit {\n\n    /** Grid of calendar cells representing the years in the range. */\n    _years: GIPIDatetimepickerCalendarCell[][];\n\n    /** The label for this year range (e.g. \"2000-2020\"). */\n    _yearLabel: string;\n\n    /** The year in this range that today falls on. Null if today is in a different range. */\n    _todayYear: number;\n\n    /** The year in this range that the selected Date falls on. Null if the selected Date is in a different range. */\n    _selectedYear: number | null;\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 multi year view */\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 && !isSameMultiYearView(this._adapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {\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._selectedYear = this._selected && this._adapter.getYear(this._selected);\n    }\n\n    /** The minimum selectable date. */\n    private _minDate: D | null;\n    @Input() get minDate(): D | null {\n        return this._minDate;\n    }\n    set minDate(value: D | null) {\n        this._minDate = this._getValidDateOrNull(this._adapter.deserialize(value));\n    }\n\n    /** The maximum selectable date. */\n    private _maxDate: D | null;\n    @Input() get maxDate(): D | null {\n        return this._maxDate;\n    }\n    set maxDate(value: D | null) {\n        this._maxDate = this._getValidDateOrNull(this._adapter.deserialize(value));\n    }\n\n    /** Emits when a new month is selected. */\n    @Output() selectedChange = new EventEmitter<D>();\n    @Output() _userSelection = new EventEmitter<void>();\n\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('GIPIDatetimeAdapter');\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 year is selected. */\n    _yearSelected(year: number) {\n        const month = this._adapter.getMonth(this.activeDate);\n        const normalizedDate = this._adapter.createDatetime(year, month, 1, 0, 0);\n\n        this.selectedChange.emit(\n            this._adapter.createDatetime(\n                year,\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\n        if (this.type === 'year') {\n            this._userSelection.emit();\n        }\n    }\n\n    _getActiveCell(): number {\n        return getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);\n    }\n\n    _calendarStateDone() {\n        this._calendarState = '';\n    }\n\n    /** Initializes this year view. */\n    private _init() {\n        this._todayYear = this._adapter.getYear(this._adapter.today());\n        this._yearLabel = this._adapter.getYearName(this.activeDate);\n\n        const activeYear = this._adapter.getYear(this.activeDate);\n        const minYearOfPage = activeYear - getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);\n\n        this._years = [];\n        for (let i = 0, row: number[] = []; i < yearsPerPage; i++) {\n            row.push(minYearOfPage + i);\n            if (row.length == yearsPerRow) {\n                this._years.push(row.map((year) => this._createCellForYear(year)));\n                row = [];\n            }\n        }\n    }\n\n    /** Creates an GIPIDatetimepickerCalendarCell for the given year. */\n    private _createCellForYear(year: number) {\n        let yearName = this._adapter.getYearName(this._adapter.createDate(year, 0, 1));\n        return new GIPIDatetimepickerCalendarCell(year, yearName, yearName, this._shouldEnableYear(year));\n    }\n\n    /** Whether the given year is enabled. */\n    private _shouldEnableYear(year: number) {\n        // disable if the year is greater than maxDate lower than minDate\n        if (\n            year === undefined ||\n            year === null ||\n            (this.maxDate && year > this._adapter.getYear(this.maxDate)) ||\n            (this.minDate && year < this._adapter.getYear(this.minDate))\n        ) {\n            return false;\n        }\n\n        // enable if it reaches here and there's no filter defined\n        if (!this.dateFilter) {\n            return true;\n        }\n\n        const firstOfYear = this._adapter.createDate(year, 0, 1);\n\n        // If any date in the year is enabled count the year as enabled.\n        for (let date = firstOfYear; this._adapter.getYear(date) == year; date = this._adapter.addCalendarDays(date, 1)) {\n            if (this.dateFilter(date)) {\n                return true;\n            }\n        }\n\n        return false;\n    }\n\n    /**\n     * Gets the year in this years range that the given Date falls on.\n     * Returns null if the given Date is not in this range.\n     */\n    private _getYearInCurrentRange(date: D) {\n        const year = this._adapter.getYear(date);\n        return this._isInRange(year) ? year : null;\n    }\n\n    /**\n     * Validate if the current year is in the current range\n     * Returns true if is in range else returns false\n     */\n    private _isInRange(year: number): boolean {\n        return true;\n    }\n\n    /**\n     * @param obj The object to check.\n     * @returns The given object if it is both a date instance and valid, otherwise null.\n     */\n    private _getValidDateOrNull(obj: any): D | null {\n        return this._adapter.isDateInstance(obj) && this._adapter.isValid(obj) ? obj : null;\n    }\n\n}\n\nexport function isSameMultiYearView<D>(dateAdapter: GIPIDatetimeAdapter<D>, date1: D, date2: D, minDate: D | null, maxDate: D | null): boolean {\n    const year1 = dateAdapter.getYear(date1);\n    const year2 = dateAdapter.getYear(date2);\n    const startingYear = getStartingYear(dateAdapter, minDate, maxDate);\n    return (Math.floor((year1 - startingYear) / yearsPerPage) === Math.floor((year2 - startingYear) / yearsPerPage));\n}\n\n/**\n * When the multi-year view is first opened, the active year will be in view.\n * So we compute how many years are between the active year and the *slot* where our\n * \"startingYear\" will render when paged into view.\n */\nexport function getActiveOffset<D>(dateAdapter: GIPIDatetimeAdapter<D>, activeDate: D, minDate: D | null, maxDate: D | null): number {\n    const activeYear = dateAdapter.getYear(activeDate);\n    return euclideanModulo(activeYear - getStartingYear(dateAdapter, minDate, maxDate), yearsPerPage);\n}\n\n/**\n * We pick a \"starting\" year such that either the maximum year would be at the end\n * or the minimum year would be at the beginning of a page.\n */\nfunction getStartingYear<D>(dateAdapter: GIPIDatetimeAdapter<D>, minDate: D | null, maxDate: D | null): number {\n    let startingYear = 0;\n    if (maxDate) {\n        const maxYear = dateAdapter.getYear(maxDate);\n        startingYear = maxYear - yearsPerPage + 1;\n    } else if (minDate) {\n        startingYear = dateAdapter.getYear(minDate);\n    }\n    return startingYear;\n}\n\n/** Gets remainder that is non-negative, even if first number is negative */\nfunction euclideanModulo(a: number, b: number): number {\n    return ((a % b) + b) % b;\n}\n"]}

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

@@ -0,0 +1,49 @@
+import { __decorate } from "tslib";
+import { NgModule } from '@angular/core';
+import { MatNativeDateModule, NativeDateModule } from '@angular/material/core';
+import { GIPIDatetimeAdapter } from './datetime-adapter';
+import { GIPI_DATETIME_FORMATS } from './datetime-formats';
+import { GIPINativeDatetimeAdapter } from './native-datetime-adapter';
+import { GIPI_NATIVE_DATETIME_FORMATS } from './native-datetime-formats';
+var NativeDatetimeModule = /** @class */ (function () {
+    function NativeDatetimeModule() {
+    }
+    NativeDatetimeModule = __decorate([
+        NgModule({
+            imports: [
+                NativeDateModule,
+            ],
+            providers: [
+                {
+                    provide: GIPIDatetimeAdapter,
+                    useClass: GIPINativeDatetimeAdapter,
+                },
+            ],
+        })
+    ], NativeDatetimeModule);
+    return NativeDatetimeModule;
+}());
+export { NativeDatetimeModule };
+var ɵ0 = GIPI_NATIVE_DATETIME_FORMATS;
+var GIPINativeDatetimeModule = /** @class */ (function () {
+    function GIPINativeDatetimeModule() {
+    }
+    GIPINativeDatetimeModule = __decorate([
+        NgModule({
+            imports: [
+                NativeDatetimeModule,
+                MatNativeDateModule,
+            ],
+            providers: [
+                {
+                    provide: GIPI_DATETIME_FORMATS,
+                    useValue: ɵ0,
+                },
+            ],
+        })
+    ], GIPINativeDatetimeModule);
+    return GIPINativeDatetimeModule;
+}());
+export { GIPINativeDatetimeModule };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,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