@gipisistemas/ng-core 1.1.11 → 1.1.13

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

@@ -0,0 +1,151 @@
+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';
+const DAYS_PER_WEEK = 7;
+/**
+ * An internal component used to display a single month in the datepicker.
+ * @docs-private
+ */
+let GIPIDatetimepickerMonthViewComponent = class GIPIDatetimepickerMonthViewComponent {
+    constructor(_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');
+        }
+        const firstDayOfWeek = this._adapter.getFirstDayOfWeek();
+        const narrowWeekdays = this._adapter.getDayOfWeekNames('narrow');
+        const longWeekdays = this._adapter.getDayOfWeekNames('long');
+        // Rotate the labels for days of the week based on the configured first day of the week.
+        let weekdays = longWeekdays.map((long, i) => { return { long, narrow: narrowWeekdays[i] }; });
+        this._weekdays = weekdays
+            .slice(firstDayOfWeek)
+            .concat(weekdays.slice(0, firstDayOfWeek));
+        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.sameMonthAndYear(oldActiveDate, this._activeDate)) {
+            this._init();
+            if (this._adapter.isInNextMonth(oldActiveDate, this._activeDate)) {
+                this.calendarState('right');
+            }
+            else {
+                this.calendarState('left');
+            }
+        }
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this._selectedDate = this._getDateInCurrentMonth(this.selected);
+    }
+    ngAfterContentInit() {
+        this._init();
+    }
+    /** Handles when a new date is selected. */
+    _dateSelected(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();
+        }
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Initializes this month view. */
+    _init() {
+        this._selectedDate = this._getDateInCurrentMonth(this.selected);
+        this._todayDate = this._getDateInCurrentMonth(this._adapter.today());
+        let 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. */
+    _createWeekCells() {
+        let daysInMonth = this._adapter.getNumDaysInMonth(this.activeDate);
+        let dateNames = this._adapter.getDateNames();
+        this._weeks = [[]];
+        for (let i = 0, cell = this._firstWeekOffset; i < daysInMonth; i++, cell++) {
+            if (cell == DAYS_PER_WEEK) {
+                this._weeks.push([]);
+                cell = 0;
+            }
+            let 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));
+            let enabled = !this.dateFilter || this.dateFilter(date);
+            let 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. */
+    _getDateInCurrentMonth(date) {
+        return this._adapter.sameMonthAndYear(date, this.activeDate)
+            ? this._adapter.getDate(date)
+            : null;
+    }
+    calendarState(direction) {
+        this._calendarState = direction;
+    }
+};
+GIPIDatetimepickerMonthViewComponent.ctorParameters = () => [
+    { 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);
+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/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/multi-year-view.js

@@ -0,0 +1,230 @@
+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 const yearsPerPage = 24;
+export const yearsPerRow = 4;
+/**
+ * An internal component used to display multiple years in the datepicker.
+ * @docs-private
+ */
+let GIPIDatetimepickerMultiYearViewComponent = class GIPIDatetimepickerMultiYearViewComponent {
+    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('GIPIDatetimeAdapter');
+        }
+        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 && !isSameMultiYearView(this._adapter, oldActiveDate, this._activeDate, this.minDate, this.maxDate)) {
+            this._init();
+        }
+    }
+    get selected() {
+        return this._selected;
+    }
+    set selected(value) {
+        this._selected = value;
+        this._selectedYear = this._selected && this._adapter.getYear(this._selected);
+    }
+    get minDate() {
+        return this._minDate;
+    }
+    set minDate(value) {
+        this._minDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+    }
+    get maxDate() {
+        return this._maxDate;
+    }
+    set maxDate(value) {
+        this._maxDate = this._getValidDateOrNull(this._adapter.deserialize(value));
+    }
+    ngAfterContentInit() {
+        this._init();
+    }
+    /** Handles when a new year is selected. */
+    _yearSelected(year) {
+        const month = this._adapter.getMonth(this.activeDate);
+        const 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();
+        }
+    }
+    _getActiveCell() {
+        return getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+    }
+    _calendarStateDone() {
+        this._calendarState = '';
+    }
+    /** Initializes this year view. */
+    _init() {
+        this._todayYear = this._adapter.getYear(this._adapter.today());
+        this._yearLabel = this._adapter.getYearName(this.activeDate);
+        const activeYear = this._adapter.getYear(this.activeDate);
+        const minYearOfPage = activeYear - getActiveOffset(this._adapter, this.activeDate, this.minDate, this.maxDate);
+        this._years = [];
+        for (let i = 0, row = []; i < yearsPerPage; i++) {
+            row.push(minYearOfPage + i);
+            if (row.length == yearsPerRow) {
+                this._years.push(row.map((year) => this._createCellForYear(year)));
+                row = [];
+            }
+        }
+    }
+    /** Creates an GIPIDatetimepickerCalendarCell for the given year. */
+    _createCellForYear(year) {
+        let 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. */
+    _shouldEnableYear(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;
+        }
+        const firstOfYear = this._adapter.createDate(year, 0, 1);
+        // If any date in the year is enabled count the year as enabled.
+        for (let 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.
+     */
+    _getYearInCurrentRange(date) {
+        const 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
+     */
+    _isInRange(year) {
+        return true;
+    }
+    /**
+     * @param obj The object to check.
+     * @returns The given object if it is both a date instance and valid, otherwise null.
+     */
+    _getValidDateOrNull(obj) {
+        return this._adapter.isDateInstance(obj) && this._adapter.isValid(obj) ? obj : null;
+    }
+};
+GIPIDatetimepickerMultiYearViewComponent.ctorParameters = () => [
+    { 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);
+export { GIPIDatetimepickerMultiYearViewComponent };
+export function isSameMultiYearView(dateAdapter, date1, date2, minDate, maxDate) {
+    const year1 = dateAdapter.getYear(date1);
+    const year2 = dateAdapter.getYear(date2);
+    const 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) {
+    const 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) {
+    let startingYear = 0;
+    if (maxDate) {
+        const 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/esm2015/shared/gipi-components/datetime-picker/mat-datetime-picker/shared/adapter/adapter.module.js

@@ -0,0 +1,43 @@
+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';
+let NativeDatetimeModule = class NativeDatetimeModule {
+};
+NativeDatetimeModule = __decorate([
+    NgModule({
+        imports: [
+            NativeDateModule,
+        ],
+        providers: [
+            {
+                provide: GIPIDatetimeAdapter,
+                useClass: GIPINativeDatetimeAdapter,
+            },
+        ],
+    })
+], NativeDatetimeModule);
+export { NativeDatetimeModule };
+const ɵ0 = GIPI_NATIVE_DATETIME_FORMATS;
+let GIPINativeDatetimeModule = class GIPINativeDatetimeModule {
+};
+GIPINativeDatetimeModule = __decorate([
+    NgModule({
+        imports: [
+            NativeDatetimeModule,
+            MatNativeDateModule,
+        ],
+        providers: [
+            {
+                provide: GIPI_DATETIME_FORMATS,
+                useValue: ɵ0,
+            },
+        ],
+    })
+], GIPINativeDatetimeModule);
+export { GIPINativeDatetimeModule };
+export { ɵ0 };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYWRhcHRlci5tb2R1bGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AZ2lwaXNpc3RlbWFzL25nLWNvcmUvIiwic291cmNlcyI6WyJzaGFyZWQvZ2lwaS1jb21wb25lbnRzL2RhdGV0aW1lLXBpY2tlci9tYXQtZGF0ZXRpbWUtcGlja2VyL3NoYXJlZC9hZGFwdGVyL2FkYXB0ZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRS9FLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzNELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3RFLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBYXpFLElBQWEsb0JBQW9CLEdBQWpDLE1BQWEsb0JBQW9CO0NBQUksQ0FBQTtBQUF4QixvQkFBb0I7SUFYaEMsUUFBUSxDQUFDO1FBQ04sT0FBTyxFQUFFO1lBQ0wsZ0JBQWdCO1NBQ25CO1FBQ0QsU0FBUyxFQUFFO1lBQ1A7Z0JBQ0ksT0FBTyxFQUFFLG1CQUFtQjtnQkFDNUIsUUFBUSxFQUFFLHlCQUF5QjthQUN0QztTQUNKO0tBQ0osQ0FBQztHQUNXLG9CQUFvQixDQUFJO1NBQXhCLG9CQUFvQjtXQVVYLDRCQUE0QjtBQUlsRCxJQUFhLHdCQUF3QixHQUFyQyxNQUFhLHdCQUF3QjtDQUFJLENBQUE7QUFBNUIsd0JBQXdCO0lBWnBDLFFBQVEsQ0FBQztRQUNOLE9BQU8sRUFBRTtZQUNMLG9CQUFvQjtZQUNwQixtQkFBbUI7U0FDdEI7UUFDRCxTQUFTLEVBQUU7WUFDUDtnQkFDSSxPQUFPLEVBQUUscUJBQXFCO2dCQUM5QixRQUFRLElBQThCO2FBQ3pDO1NBQ0o7S0FDSixDQUFDO0dBQ1csd0JBQXdCLENBQUk7U0FBNUIsd0JBQXdCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1hdE5hdGl2ZURhdGVNb2R1bGUsIE5hdGl2ZURhdGVNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9tYXRlcmlhbC9jb3JlJztcblxuaW1wb3J0IHsgR0lQSURhdGV0aW1lQWRhcHRlciB9IGZyb20gJy4vZGF0ZXRpbWUtYWRhcHRlcic7XG5pbXBvcnQgeyBHSVBJX0RBVEVUSU1FX0ZPUk1BVFMgfSBmcm9tICcuL2RhdGV0aW1lLWZvcm1hdHMnO1xuaW1wb3J0IHsgR0lQSU5hdGl2ZURhdGV0aW1lQWRhcHRlciB9IGZyb20gJy4vbmF0aXZlLWRhdGV0aW1lLWFkYXB0ZXInO1xuaW1wb3J0IHsgR0lQSV9OQVRJVkVfREFURVRJTUVfRk9STUFUUyB9IGZyb20gJy4vbmF0aXZlLWRhdGV0aW1lLWZvcm1hdHMnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtcbiAgICAgICAgTmF0aXZlRGF0ZU1vZHVsZSxcbiAgICBdLFxuICAgIHByb3ZpZGVyczogW1xuICAgICAgICB7XG4gICAgICAgICAgICBwcm92aWRlOiBHSVBJRGF0ZXRpbWVBZGFwdGVyLFxuICAgICAgICAgICAgdXNlQ2xhc3M6IEdJUElOYXRpdmVEYXRldGltZUFkYXB0ZXIsXG4gICAgICAgIH0sXG4gICAgXSxcbn0pXG5leHBvcnQgY2xhc3MgTmF0aXZlRGF0ZXRpbWVNb2R1bGUgeyB9XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1xuICAgICAgICBOYXRpdmVEYXRldGltZU1vZHVsZSxcbiAgICAgICAgTWF0TmF0aXZlRGF0ZU1vZHVsZSxcbiAgICBdLFxuICAgIHByb3ZpZGVyczogW1xuICAgICAgICB7XG4gICAgICAgICAgICBwcm92aWRlOiBHSVBJX0RBVEVUSU1FX0ZPUk1BVFMsXG4gICAgICAgICAgICB1c2VWYWx1ZTogR0lQSV9OQVRJVkVfREFURVRJTUVfRk9STUFUUyxcbiAgICAgICAgfSxcbiAgICBdLFxufSlcbmV4cG9ydCBjbGFzcyBHSVBJTmF0aXZlRGF0ZXRpbWVNb2R1bGUgeyB9XG4iXX0=