@clr/angular 12.0.11 → 13.0.1

package/esm2020/forms/datepicker/providers/date-io.service.mjs

@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { BIG_ENDIAN, DEFAULT_LOCALE_FORMAT, DELIMITER_REGEX, LITTLE_ENDIAN, LITTLE_ENDIAN_REGEX, MIDDLE_ENDIAN, MIDDLE_ENDIAN_REGEX, RTL_REGEX, USER_INPUT_REGEX, } from '../utils/constants';
+import { getNumberOfDaysInTheMonth, parseToFourDigitYear } from '../utils/date-utils';
+import { DayModel } from '../model/day.model';
+import * as i0 from "@angular/core";
+import * as i1 from "./locale-helper.service";
+export class DateIOService {
+    constructor(_localeHelperService) {
+        this._localeHelperService = _localeHelperService;
+        this.disabledDates = {
+            // This is the default range. It approximates the beginning of time to the end of time.
+            // Unless a minDate or maxDate is set with the native HTML5 api the range is all dates
+            // TODO: turn this into an Array of min/max ranges that allow configuration of multiple ranges.
+            minDate: new DayModel(0, 0, 1),
+            maxDate: new DayModel(9999, 11, 31),
+        };
+        this.cldrLocaleDateFormat = DEFAULT_LOCALE_FORMAT;
+        this.localeDisplayFormat = LITTLE_ENDIAN;
+        this.delimiters = ['/', '/'];
+        this.cldrLocaleDateFormat = this._localeHelperService.localeDateFormat;
+        this.initializeLocaleDisplayFormat();
+    }
+    setMinDate(date) {
+        // NOTE: I'm expecting consumers to pass one of four things here:
+        //       A proper date string(2019-11-11), null, undefined or empty string ('')
+        if (!date) {
+            // attribute binding was removed, reset back to the beginning of time
+            this.disabledDates.minDate = new DayModel(0, 0, 1);
+        }
+        else {
+            const [year, month, day] = date.split('-').map(n => parseInt(n, 10));
+            this.disabledDates.minDate = new DayModel(year, month - 1, day);
+        }
+    }
+    setMaxDate(date) {
+        // NOTE: I'm expecting consumers to pass one of four things here:
+        //       A proper date string(2019-11-11), null, undefined or empty string ('')
+        if (!date) {
+            // attribute binding was removed, reset forward to the end of time
+            this.disabledDates.maxDate = new DayModel(9999, 11, 31);
+        }
+        else {
+            const [year, month, day] = date.split('-').map(n => parseInt(n, 10));
+            this.disabledDates.maxDate = new DayModel(year, month - 1, day);
+        }
+    }
+    initializeLocaleDisplayFormat() {
+        const format = this.cldrLocaleDateFormat.toLocaleLowerCase();
+        if (LITTLE_ENDIAN_REGEX.test(format)) {
+            this.localeDisplayFormat = LITTLE_ENDIAN;
+        }
+        else if (MIDDLE_ENDIAN_REGEX.test(format)) {
+            this.localeDisplayFormat = MIDDLE_ENDIAN;
+        }
+        else {
+            // everything else is set to BIG-ENDIAN FORMAT
+            this.localeDisplayFormat = BIG_ENDIAN;
+        }
+        this.extractDelimiters();
+    }
+    extractDelimiters() {
+        if (this.cldrLocaleDateFormat) {
+            // Sanitize Date Format. Remove RTL characters.
+            // FIXME: When we support RTL, remove this and handle it correctly.
+            const localeFormat = this.cldrLocaleDateFormat.replace(RTL_REGEX, '');
+            const delimiters = localeFormat.split(DELIMITER_REGEX);
+            // NOTE: The split from the CLDR date format should always result
+            // in an arary with 4 elements. The 1st and the 2nd values are the delimiters
+            // we will use in order.
+            // Eg: "dd/MM/y".split(/d+|m+|y+/i) results in ["", "/", "/", ""]
+            if (delimiters && delimiters.length === 4) {
+                this.delimiters = [delimiters[1], delimiters[2]];
+            }
+            else {
+                console.error('Unexpected date format received. Delimiters extracted: ', delimiters);
+            }
+        }
+    }
+    toLocaleDisplayFormatString(date) {
+        if (date) {
+            if (isNaN(date.getTime())) {
+                return '';
+            }
+            const dateNo = date.getDate();
+            const monthNo = date.getMonth() + 1;
+            const dateStr = dateNo > 9 ? dateNo.toString() : '0' + dateNo;
+            const monthStr = monthNo > 9 ? monthNo.toString() : '0' + monthNo;
+            if (this.localeDisplayFormat === LITTLE_ENDIAN) {
+                return dateStr + this.delimiters[0] + monthStr + this.delimiters[1] + date.getFullYear();
+            }
+            else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {
+                return monthStr + this.delimiters[0] + dateStr + this.delimiters[1] + date.getFullYear();
+            }
+            else {
+                return date.getFullYear() + this.delimiters[0] + monthStr + this.delimiters[1] + dateStr;
+            }
+        }
+        return '';
+    }
+    get placeholderText() {
+        const format = this.localeDisplayFormat.format;
+        return format[0] + this.delimiters[0] + format[1] + this.delimiters[1] + format[2];
+    }
+    /**
+     * Checks if the month entered by the user is valid or not.
+     * Note: Month is 0 based.
+     */
+    isValidMonth(month) {
+        return month > -1 && month < 12;
+    }
+    /**
+     * Checks if the date is valid depending on the year and month provided.
+     */
+    isValidDate(year, month, date) {
+        return date > 0 && date <= getNumberOfDaysInTheMonth(year, month);
+    }
+    /**
+     * Validates the parameters provided and returns the date.
+     * If the parameters are not
+     * valid then return null.
+     * NOTE: (Month here is 1 based since the user has provided that as an input)
+     */
+    validateAndGetDate(year, month, date) {
+        // I don't know whats wrong with the TS compiler. It throws an error if I write
+        // the below if statement. The error is:
+        // Operator '!==' cannot be applied to types '2' and '4'
+        // More info here: https://github.com/Microsoft/TypeScript/issues/12794#issuecomment-270342936
+        /*
+            if (year.length !== 2 || year.length !== 4) {
+                return null;
+            }
+            */
+        // Instead I have to write the logic like this x-(
+        const y = +year;
+        const m = +month - 1; // month is 0 based
+        const d = +date;
+        if (!this.isValidMonth(m) || !this.isValidDate(y, m, d)) {
+            return null;
+        }
+        const result = parseToFourDigitYear(y);
+        return result !== -1 ? new Date(result, m, d) : null;
+    }
+    getDateValueFromDateString(date) {
+        if (!date) {
+            return null;
+        }
+        const dateParts = date.match(USER_INPUT_REGEX);
+        if (!dateParts || dateParts.length !== 3) {
+            return null;
+        }
+        const [firstPart, secondPart, thirdPart] = dateParts;
+        if (this.localeDisplayFormat === LITTLE_ENDIAN) {
+            // secondPart is month && firstPart is date
+            return this.validateAndGetDate(thirdPart, secondPart, firstPart);
+        }
+        else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {
+            // firstPart is month && secondPart is date
+            return this.validateAndGetDate(thirdPart, firstPart, secondPart);
+        }
+        else {
+            // secondPart is month && thirdPart is date
+            return this.validateAndGetDate(firstPart, secondPart, thirdPart);
+        }
+    }
+}
+DateIOService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateIOService, deps: [{ token: i1.LocaleHelperService }], target: i0.ɵɵFactoryTarget.Injectable });
+DateIOService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateIOService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateIOService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.LocaleHelperService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-io.service.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/forms/datepicker/providers/date-io.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { Injectable } from '@angular/core';\n\nimport {\n  BIG_ENDIAN,\n  DEFAULT_LOCALE_FORMAT,\n  DELIMITER_REGEX,\n  InputDateDisplayFormat,\n  LITTLE_ENDIAN,\n  LITTLE_ENDIAN_REGEX,\n  MIDDLE_ENDIAN,\n  MIDDLE_ENDIAN_REGEX,\n  RTL_REGEX,\n  USER_INPUT_REGEX,\n} from '../utils/constants';\nimport { getNumberOfDaysInTheMonth, parseToFourDigitYear } from '../utils/date-utils';\n\nimport { LocaleHelperService } from './locale-helper.service';\nimport { DateRange } from '../interfaces/date-range.interface';\nimport { DayModel } from '../model/day.model';\n\n@Injectable()\nexport class DateIOService {\n  public disabledDates: DateRange = {\n    // This is the default range. It approximates the beginning of time to the end of time.\n    // Unless a minDate or maxDate is set with the native HTML5 api the range is all dates\n    // TODO: turn this into an Array of min/max ranges that allow configuration of multiple ranges.\n    minDate: new DayModel(0, 0, 1),\n    maxDate: new DayModel(9999, 11, 31),\n  };\n  public cldrLocaleDateFormat: string = DEFAULT_LOCALE_FORMAT;\n  private localeDisplayFormat: InputDateDisplayFormat = LITTLE_ENDIAN;\n  private delimiters: [string, string] = ['/', '/'];\n\n  constructor(private _localeHelperService: LocaleHelperService) {\n    this.cldrLocaleDateFormat = this._localeHelperService.localeDateFormat;\n    this.initializeLocaleDisplayFormat();\n  }\n\n  public setMinDate(date: string): void {\n    // NOTE: I'm expecting consumers to pass one of four things here:\n    //       A proper date string(2019-11-11), null, undefined or empty string ('')\n    if (!date) {\n      // attribute binding was removed, reset back to the beginning of time\n      this.disabledDates.minDate = new DayModel(0, 0, 1);\n    } else {\n      const [year, month, day] = date.split('-').map(n => parseInt(n, 10));\n      this.disabledDates.minDate = new DayModel(year, month - 1, day);\n    }\n  }\n\n  public setMaxDate(date: string): void {\n    // NOTE: I'm expecting consumers to pass one of four things here:\n    //       A proper date string(2019-11-11), null, undefined or empty string ('')\n    if (!date) {\n      // attribute binding was removed, reset forward to the end of time\n      this.disabledDates.maxDate = new DayModel(9999, 11, 31);\n    } else {\n      const [year, month, day] = date.split('-').map(n => parseInt(n, 10));\n      this.disabledDates.maxDate = new DayModel(year, month - 1, day);\n    }\n  }\n\n  private initializeLocaleDisplayFormat(): void {\n    const format: string = this.cldrLocaleDateFormat.toLocaleLowerCase();\n    if (LITTLE_ENDIAN_REGEX.test(format)) {\n      this.localeDisplayFormat = LITTLE_ENDIAN;\n    } else if (MIDDLE_ENDIAN_REGEX.test(format)) {\n      this.localeDisplayFormat = MIDDLE_ENDIAN;\n    } else {\n      // everything else is set to BIG-ENDIAN FORMAT\n      this.localeDisplayFormat = BIG_ENDIAN;\n    }\n    this.extractDelimiters();\n  }\n\n  private extractDelimiters(): void {\n    if (this.cldrLocaleDateFormat) {\n      // Sanitize Date Format. Remove RTL characters.\n      // FIXME: When we support RTL, remove this and handle it correctly.\n      const localeFormat: string = this.cldrLocaleDateFormat.replace(RTL_REGEX, '');\n      const delimiters: string[] = localeFormat.split(DELIMITER_REGEX);\n\n      // NOTE: The split from the CLDR date format should always result\n      // in an arary with 4 elements. The 1st and the 2nd values are the delimiters\n      // we will use in order.\n      // Eg: \"dd/MM/y\".split(/d+|m+|y+/i) results in [\"\", \"/\", \"/\", \"\"]\n      if (delimiters && delimiters.length === 4) {\n        this.delimiters = [delimiters[1], delimiters[2]];\n      } else {\n        console.error('Unexpected date format received. Delimiters extracted: ', delimiters);\n      }\n    }\n  }\n\n  toLocaleDisplayFormatString(date: Date): string {\n    if (date) {\n      if (isNaN(date.getTime())) {\n        return '';\n      }\n      const dateNo: number = date.getDate();\n      const monthNo: number = date.getMonth() + 1;\n      const dateStr: string = dateNo > 9 ? dateNo.toString() : '0' + dateNo;\n      const monthStr: string = monthNo > 9 ? monthNo.toString() : '0' + monthNo;\n      if (this.localeDisplayFormat === LITTLE_ENDIAN) {\n        return dateStr + this.delimiters[0] + monthStr + this.delimiters[1] + date.getFullYear();\n      } else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {\n        return monthStr + this.delimiters[0] + dateStr + this.delimiters[1] + date.getFullYear();\n      } else {\n        return date.getFullYear() + this.delimiters[0] + monthStr + this.delimiters[1] + dateStr;\n      }\n    }\n    return '';\n  }\n\n  get placeholderText(): string {\n    const format: [string, string, string] = this.localeDisplayFormat.format;\n    return format[0] + this.delimiters[0] + format[1] + this.delimiters[1] + format[2];\n  }\n\n  /**\n   * Checks if the month entered by the user is valid or not.\n   * Note: Month is 0 based.\n   */\n  private isValidMonth(month: number): boolean {\n    return month > -1 && month < 12;\n  }\n\n  /**\n   * Checks if the date is valid depending on the year and month provided.\n   */\n  private isValidDate(year: number, month: number, date: number): boolean {\n    return date > 0 && date <= getNumberOfDaysInTheMonth(year, month);\n  }\n\n  /**\n   * Validates the parameters provided and returns the date.\n   * If the parameters are not\n   * valid then return null.\n   * NOTE: (Month here is 1 based since the user has provided that as an input)\n   */\n  private validateAndGetDate(year: string, month: string, date: string): Date {\n    // I don't know whats wrong with the TS compiler. It throws an error if I write\n    // the below if statement. The error is:\n    // Operator '!==' cannot be applied to types '2' and '4'\n    // More info here: https://github.com/Microsoft/TypeScript/issues/12794#issuecomment-270342936\n    /*\n        if (year.length !== 2 || year.length !== 4) {\n            return null;\n        }\n        */\n\n    // Instead I have to write the logic like this x-(\n    const y: number = +year;\n    const m: number = +month - 1; // month is 0 based\n    const d: number = +date;\n    if (!this.isValidMonth(m) || !this.isValidDate(y, m, d)) {\n      return null;\n    }\n    const result: number = parseToFourDigitYear(y);\n    return result !== -1 ? new Date(result, m, d) : null;\n  }\n\n  getDateValueFromDateString(date: string): Date {\n    if (!date) {\n      return null;\n    }\n    const dateParts: string[] = date.match(USER_INPUT_REGEX);\n    if (!dateParts || dateParts.length !== 3) {\n      return null;\n    }\n    const [firstPart, secondPart, thirdPart] = dateParts;\n    if (this.localeDisplayFormat === LITTLE_ENDIAN) {\n      // secondPart is month && firstPart is date\n      return this.validateAndGetDate(thirdPart, secondPart, firstPart);\n    } else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {\n      // firstPart is month && secondPart is date\n      return this.validateAndGetDate(thirdPart, firstPart, secondPart);\n    } else {\n      // secondPart is month && thirdPart is date\n      return this.validateAndGetDate(firstPart, secondPart, thirdPart);\n    }\n  }\n}\n"]}

package/esm2020/forms/datepicker/providers/date-navigation.service.mjs

@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import { CalendarModel } from '../model/calendar.model';
+import { DayModel } from '../model/day.model';
+import * as i0 from "@angular/core";
+/**
+ * This service is responsible for:
+ * 1. Initializing the displayed calendar.
+ * 2. Moving the calendar to the next, previous or current months
+ * 3. Managing the focused and selected day models.
+ */
+export class DateNavigationService {
+    constructor() {
+        /**
+         * Variable to store today's date.
+         */
+        this._todaysFullDate = new Date();
+        this._selectedDayChange = new Subject();
+        this._displayedCalendarChange = new Subject();
+        this._focusOnCalendarChange = new Subject();
+        this._focusedDayChange = new Subject();
+    }
+    get displayedCalendar() {
+        return this._displayedCalendar;
+    }
+    // not a setter because i want this to remain private
+    setDisplayedCalendar(value) {
+        if (!this._displayedCalendar.isEqual(value)) {
+            this._displayedCalendar = value;
+            this._displayedCalendarChange.next();
+        }
+    }
+    initializeTodaysDate() {
+        this._todaysFullDate = new Date();
+        this._today = new DayModel(this._todaysFullDate.getFullYear(), this._todaysFullDate.getMonth(), this._todaysFullDate.getDate());
+    }
+    get today() {
+        return this._today;
+    }
+    get selectedDayChange() {
+        return this._selectedDayChange.asObservable();
+    }
+    /**
+     * Notifies that the selected day has changed so that the date can be emitted to the user.
+     * Note: Only to be called from day.ts
+     */
+    notifySelectedDayChanged(dayModel) {
+        this.selectedDay = dayModel;
+        this._selectedDayChange.next(dayModel);
+    }
+    /**
+     * Initializes the calendar based on the selected day.
+     */
+    initializeCalendar() {
+        this.focusedDay = null; // Can be removed later on the store focus
+        this.initializeTodaysDate();
+        if (this.selectedDay) {
+            this._displayedCalendar = new CalendarModel(this.selectedDay.year, this.selectedDay.month);
+        }
+        else {
+            this._displayedCalendar = new CalendarModel(this.today.year, this.today.month);
+        }
+    }
+    changeMonth(month) {
+        this.setDisplayedCalendar(new CalendarModel(this._displayedCalendar.year, month));
+    }
+    changeYear(year) {
+        this.setDisplayedCalendar(new CalendarModel(year, this._displayedCalendar.month));
+    }
+    /**
+     * Moves the displayed calendar to the next month.
+     */
+    moveToNextMonth() {
+        this.setDisplayedCalendar(this._displayedCalendar.nextMonth());
+    }
+    /**
+     * Moves the displayed calendar to the previous month.
+     */
+    moveToPreviousMonth() {
+        this.setDisplayedCalendar(this._displayedCalendar.previousMonth());
+    }
+    /**
+     * Moves the displayed calendar to the current month and year.
+     */
+    moveToCurrentMonth() {
+        if (!this.displayedCalendar.isDayInCalendar(this.today)) {
+            this.setDisplayedCalendar(new CalendarModel(this.today.year, this.today.month));
+        }
+        this._focusOnCalendarChange.next();
+    }
+    incrementFocusDay(value) {
+        this.focusedDay = this.focusedDay.incrementBy(value);
+        if (this._displayedCalendar.isDayInCalendar(this.focusedDay)) {
+            this._focusedDayChange.next(this.focusedDay);
+        }
+        else {
+            this.setDisplayedCalendar(new CalendarModel(this.focusedDay.year, this.focusedDay.month));
+        }
+        this._focusOnCalendarChange.next();
+    }
+    /**
+     * This observable lets the subscriber know that the displayed calendar has changed.
+     */
+    get displayedCalendarChange() {
+        return this._displayedCalendarChange.asObservable();
+    }
+    /**
+     * This observable lets the subscriber know that the focus should be applied on the calendar.
+     */
+    get focusOnCalendarChange() {
+        return this._focusOnCalendarChange.asObservable();
+    }
+    /**
+     * This observable lets the subscriber know that the focused day in the displayed calendar has changed.
+     */
+    get focusedDayChange() {
+        return this._focusedDayChange.asObservable();
+    }
+}
+DateNavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateNavigationService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DateNavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateNavigationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DateNavigationService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-navigation.service.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/forms/datepicker/providers/date-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { Injectable } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Subject } from 'rxjs';\nimport { CalendarModel } from '../model/calendar.model';\nimport { DayModel } from '../model/day.model';\n\n/**\n * This service is responsible for:\n * 1. Initializing the displayed calendar.\n * 2. Moving the calendar to the next, previous or current months\n * 3. Managing the focused and selected day models.\n */\n@Injectable()\nexport class DateNavigationService {\n  private _displayedCalendar: CalendarModel;\n\n  get displayedCalendar(): CalendarModel {\n    return this._displayedCalendar;\n  }\n\n  // not a setter because i want this to remain private\n  private setDisplayedCalendar(value: CalendarModel) {\n    if (!this._displayedCalendar.isEqual(value)) {\n      this._displayedCalendar = value;\n      this._displayedCalendarChange.next();\n    }\n  }\n\n  /**\n   * Variable to store today's date.\n   */\n  private _todaysFullDate: Date = new Date();\n  private _today: DayModel;\n\n  private initializeTodaysDate(): void {\n    this._todaysFullDate = new Date();\n    this._today = new DayModel(\n      this._todaysFullDate.getFullYear(),\n      this._todaysFullDate.getMonth(),\n      this._todaysFullDate.getDate()\n    );\n  }\n\n  get today(): DayModel {\n    return this._today;\n  }\n\n  public selectedDay: DayModel;\n\n  private _selectedDayChange: Subject<DayModel> = new Subject<DayModel>();\n\n  get selectedDayChange(): Observable<DayModel> {\n    return this._selectedDayChange.asObservable();\n  }\n\n  /**\n   * Notifies that the selected day has changed so that the date can be emitted to the user.\n   * Note: Only to be called from day.ts\n   */\n  notifySelectedDayChanged(dayModel: DayModel) {\n    this.selectedDay = dayModel;\n    this._selectedDayChange.next(dayModel);\n  }\n\n  public focusedDay: DayModel;\n\n  /**\n   * Initializes the calendar based on the selected day.\n   */\n  initializeCalendar(): void {\n    this.focusedDay = null; // Can be removed later on the store focus\n    this.initializeTodaysDate();\n    if (this.selectedDay) {\n      this._displayedCalendar = new CalendarModel(this.selectedDay.year, this.selectedDay.month);\n    } else {\n      this._displayedCalendar = new CalendarModel(this.today.year, this.today.month);\n    }\n  }\n\n  changeMonth(month: number): void {\n    this.setDisplayedCalendar(new CalendarModel(this._displayedCalendar.year, month));\n  }\n\n  changeYear(year: number): void {\n    this.setDisplayedCalendar(new CalendarModel(year, this._displayedCalendar.month));\n  }\n\n  /**\n   * Moves the displayed calendar to the next month.\n   */\n  moveToNextMonth(): void {\n    this.setDisplayedCalendar(this._displayedCalendar.nextMonth());\n  }\n\n  /**\n   * Moves the displayed calendar to the previous month.\n   */\n  moveToPreviousMonth(): void {\n    this.setDisplayedCalendar(this._displayedCalendar.previousMonth());\n  }\n\n  /**\n   * Moves the displayed calendar to the current month and year.\n   */\n  moveToCurrentMonth(): void {\n    if (!this.displayedCalendar.isDayInCalendar(this.today)) {\n      this.setDisplayedCalendar(new CalendarModel(this.today.year, this.today.month));\n    }\n    this._focusOnCalendarChange.next();\n  }\n\n  incrementFocusDay(value: number): void {\n    this.focusedDay = this.focusedDay.incrementBy(value);\n    if (this._displayedCalendar.isDayInCalendar(this.focusedDay)) {\n      this._focusedDayChange.next(this.focusedDay);\n    } else {\n      this.setDisplayedCalendar(new CalendarModel(this.focusedDay.year, this.focusedDay.month));\n    }\n    this._focusOnCalendarChange.next();\n  }\n\n  private _displayedCalendarChange: Subject<void> = new Subject<void>();\n\n  /**\n   * This observable lets the subscriber know that the displayed calendar has changed.\n   */\n  get displayedCalendarChange(): Observable<void> {\n    return this._displayedCalendarChange.asObservable();\n  }\n\n  private _focusOnCalendarChange: Subject<void> = new Subject<void>();\n\n  /**\n   * This observable lets the subscriber know that the focus should be applied on the calendar.\n   */\n  get focusOnCalendarChange(): Observable<void> {\n    return this._focusOnCalendarChange.asObservable();\n  }\n\n  private _focusedDayChange: Subject<DayModel> = new Subject<DayModel>();\n\n  /**\n   * This observable lets the subscriber know that the focused day in the displayed calendar has changed.\n   */\n  get focusedDayChange(): Observable<DayModel> {\n    return this._focusedDayChange.asObservable();\n  }\n}\n"]}

package/esm2020/forms/datepicker/providers/datepicker-enabled.service.mjs

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { DOCUMENT } from '@angular/common';
+import { Inject, Injectable } from '@angular/core';
+import { DATEPICKER_ENABLE_BREAKPOINT } from '../../../utils/breakpoints/breakpoints';
+import { MOBILE_USERAGENT_REGEX } from '../utils/constants';
+import * as i0 from "@angular/core";
+export class DatepickerEnabledService {
+    constructor(_document) {
+        this._document = _document;
+        this._isUserAgentMobile = false;
+        if (this._document) {
+            this._isUserAgentMobile = MOBILE_USERAGENT_REGEX.test(_document.defaultView.navigator.userAgent);
+            this._innerWidth = _document.defaultView.innerWidth;
+        }
+    }
+    /**
+     * Returns if the calendar should be active or not.
+     * If the user agent is mobile and the screen width is less than DATEPICKER_ACTIVE_BREAKPOINT
+     * then the calendar is inactive.
+     */
+    get isEnabled() {
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Browser_detection_using_the_user_agent
+        // What they recommend is:
+        //"In summary, we recommend looking for the string 'Mobi'
+        // anywhere in the User Agent to detect a mobile device."
+        if (this._document) {
+            if (this._innerWidth < DATEPICKER_ENABLE_BREAKPOINT && this._isUserAgentMobile) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+DatepickerEnabledService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerEnabledService, deps: [{ token: DOCUMENT }], target: i0.ɵɵFactoryTarget.Injectable });
+DatepickerEnabledService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerEnabledService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerEnabledService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/forms/datepicker/providers/datepicker-focus.service.mjs

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { isPlatformBrowser } from '@angular/common';
+import { Inject, Injectable, PLATFORM_ID } from '@angular/core';
+import { first, filter } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+/**
+ * This service focuses the day that is focusable in the calendar.
+ */
+export class DatepickerFocusService {
+    constructor(_ngZone, platformId) {
+        this._ngZone = _ngZone;
+        this.platformId = platformId;
+    }
+    focusCell(elRef) {
+        this._ngZone.runOutsideAngular(() => {
+            this.ngZoneIsStableInBrowser().subscribe(() => {
+                const focusEl = elRef.nativeElement.querySelector('[tabindex="0"]');
+                if (focusEl) {
+                    focusEl.focus();
+                }
+            });
+        });
+    }
+    focusInput(element) {
+        this._ngZone.runOutsideAngular(() => this.ngZoneIsStableInBrowser().subscribe(() => element.focus()));
+    }
+    elementIsFocused(element) {
+        return isPlatformBrowser(this.platformId) && document.activeElement === element;
+    }
+    ngZoneIsStableInBrowser() {
+        // Credit: Material: https://github.com/angular/material2/blob/master/src/lib/datepicker/calendar.ts
+        return this._ngZone.onStable.asObservable().pipe(first(), filter(() => isPlatformBrowser(this.platformId)));
+    }
+}
+DatepickerFocusService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerFocusService, deps: [{ token: i0.NgZone }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+DatepickerFocusService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerFocusService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: DatepickerFocusService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/forms/datepicker/providers/locale-helper.service.mjs

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { FormatWidth, FormStyle, getLocaleDateFormat, getLocaleDayNames, getLocaleFirstDayOfWeek, getLocaleMonthNames, TranslationWidth, } from '@angular/common';
+import { Inject, Injectable, LOCALE_ID } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * This service extracts the Angular CLDR data needed by the datepicker.
+ */
+export class LocaleHelperService {
+    constructor(locale) {
+        this.locale = locale;
+        this._firstDayOfWeek = 0;
+        this.initializeLocaleData();
+    }
+    get firstDayOfWeek() {
+        return this._firstDayOfWeek;
+    }
+    get localeDays() {
+        return this._localeDays;
+    }
+    // leave for backward compatibility
+    get localeDaysNarrow() {
+        return this._localeDays.map(day => day.narrow);
+    }
+    get localeMonthsAbbreviated() {
+        return this._localeMonthsAbbreviated;
+    }
+    get localeMonthsWide() {
+        return this._localeMonthsWide;
+    }
+    get localeDateFormat() {
+        return this._localeDateFormat;
+    }
+    /**
+     * Initializes the locale data.
+     */
+    initializeLocaleData() {
+        // Order in which these functions is called is very important.
+        this.initializeFirstDayOfWeek();
+        this.initializeLocaleDateFormat();
+        this.initializeLocaleMonthsAbbreviated();
+        this.initializeLocaleMonthsWide();
+        this.initializeLocaleDays();
+    }
+    /**
+     * Initialize day names based on the locale.
+     * eg: [{day: Sunday, narrow: S}, {day: Monday, narrow: M}...] for en-US.
+     */
+    initializeLocaleDays() {
+        // Get locale day names starting with Sunday
+        const tempArr = [];
+        const tempWideArr = getLocaleDayNames(this.locale, FormStyle.Standalone, TranslationWidth.Wide).slice();
+        const tempNarrowArr = getLocaleDayNames(this.locale, FormStyle.Standalone, TranslationWidth.Narrow).slice();
+        // Get first day of the week based on the locale
+        const firstDayOfWeek = this.firstDayOfWeek;
+        for (let i = 0; i < 7; i++) {
+            tempArr.push({ day: tempWideArr[i], narrow: tempNarrowArr[i] });
+        }
+        // Rearrange the tempArr to start with the first day of the week based on the locale.
+        if (firstDayOfWeek > 0) {
+            const prevDays = tempArr.splice(0, firstDayOfWeek);
+            tempArr.push(...prevDays);
+        }
+        this._localeDays = tempArr;
+    }
+    /**
+     * Initializes the array of month names in the TranslationWidth.Abbreviated format.
+     * e.g. `[Jan, Feb, ...]` for en-US
+     */
+    initializeLocaleMonthsAbbreviated() {
+        this._localeMonthsAbbreviated = getLocaleMonthNames(this.locale, FormStyle.Standalone, TranslationWidth.Abbreviated).slice();
+    }
+    /**
+     * Initializes the array of month names in the TranslationWidth.Wide format.
+     * e.g. `[January, February, ...]` for en-US
+     */
+    initializeLocaleMonthsWide() {
+        this._localeMonthsWide = getLocaleMonthNames(this.locale, FormStyle.Standalone, TranslationWidth.Wide).slice();
+    }
+    /**
+     * Initializes the first day of the week based on the locale.
+     */
+    initializeFirstDayOfWeek() {
+        this._firstDayOfWeek = getLocaleFirstDayOfWeek(this.locale);
+    }
+    initializeLocaleDateFormat() {
+        this._localeDateFormat = getLocaleDateFormat(this.locale, FormatWidth.Short);
+    }
+}
+LocaleHelperService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocaleHelperService, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+LocaleHelperService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocaleHelperService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: LocaleHelperService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"locale-helper.service.js","sourceRoot":"","sources":["../../../../../../projects/angular/src/forms/datepicker/providers/locale-helper.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport {\n  FormatWidth,\n  FormStyle,\n  getLocaleDateFormat,\n  getLocaleDayNames,\n  getLocaleFirstDayOfWeek,\n  getLocaleMonthNames,\n  TranslationWidth,\n} from '@angular/common';\nimport { Inject, Injectable, LOCALE_ID } from '@angular/core';\nimport { ClrDayOfWeek } from '../interfaces/day-of-week.interface';\n\n/**\n * This service extracts the Angular CLDR data needed by the datepicker.\n */\n@Injectable()\nexport class LocaleHelperService {\n  constructor(@Inject(LOCALE_ID) public locale: string) {\n    this.initializeLocaleData();\n  }\n\n  private _firstDayOfWeek = 0;\n  private _localeDays: ReadonlyArray<ClrDayOfWeek>;\n  private _localeMonthsAbbreviated: ReadonlyArray<string>;\n  private _localeMonthsWide: ReadonlyArray<string>;\n  private _localeDateFormat: string;\n\n  get firstDayOfWeek(): number {\n    return this._firstDayOfWeek;\n  }\n\n  get localeDays(): ReadonlyArray<ClrDayOfWeek> {\n    return this._localeDays;\n  }\n\n  // leave for backward compatibility\n  get localeDaysNarrow(): ReadonlyArray<string> {\n    return this._localeDays.map(day => day.narrow);\n  }\n\n  get localeMonthsAbbreviated(): ReadonlyArray<string> {\n    return this._localeMonthsAbbreviated;\n  }\n\n  get localeMonthsWide(): ReadonlyArray<string> {\n    return this._localeMonthsWide;\n  }\n\n  get localeDateFormat(): string {\n    return this._localeDateFormat;\n  }\n\n  /**\n   * Initializes the locale data.\n   */\n  private initializeLocaleData(): void {\n    // Order in which these functions is called is very important.\n    this.initializeFirstDayOfWeek();\n    this.initializeLocaleDateFormat();\n    this.initializeLocaleMonthsAbbreviated();\n    this.initializeLocaleMonthsWide();\n    this.initializeLocaleDays();\n  }\n\n  /**\n   * Initialize day names based on the locale.\n   * eg: [{day: Sunday, narrow: S}, {day: Monday, narrow: M}...] for en-US.\n   */\n  private initializeLocaleDays(): void {\n    // Get locale day names starting with Sunday\n    const tempArr = [];\n    const tempWideArr: string[] = getLocaleDayNames(this.locale, FormStyle.Standalone, TranslationWidth.Wide).slice();\n    const tempNarrowArr: string[] = getLocaleDayNames(\n      this.locale,\n      FormStyle.Standalone,\n      TranslationWidth.Narrow\n    ).slice();\n    // Get first day of the week based on the locale\n    const firstDayOfWeek: number = this.firstDayOfWeek;\n    for (let i = 0; i < 7; i++) {\n      tempArr.push({ day: tempWideArr[i], narrow: tempNarrowArr[i] });\n    }\n    // Rearrange the tempArr to start with the first day of the week based on the locale.\n    if (firstDayOfWeek > 0) {\n      const prevDays: { day: string; narrow: string }[] = tempArr.splice(0, firstDayOfWeek);\n      tempArr.push(...prevDays);\n    }\n    this._localeDays = tempArr;\n  }\n\n  /**\n   * Initializes the array of month names in the TranslationWidth.Abbreviated format.\n   * e.g. `[Jan, Feb, ...]` for en-US\n   */\n  private initializeLocaleMonthsAbbreviated(): void {\n    this._localeMonthsAbbreviated = getLocaleMonthNames(\n      this.locale,\n      FormStyle.Standalone,\n      TranslationWidth.Abbreviated\n    ).slice();\n  }\n\n  /**\n   * Initializes the array of month names in the TranslationWidth.Wide format.\n   * e.g. `[January, February, ...]` for en-US\n   */\n  private initializeLocaleMonthsWide(): void {\n    this._localeMonthsWide = getLocaleMonthNames(this.locale, FormStyle.Standalone, TranslationWidth.Wide).slice();\n  }\n\n  /**\n   * Initializes the first day of the week based on the locale.\n   */\n  private initializeFirstDayOfWeek(): void {\n    this._firstDayOfWeek = getLocaleFirstDayOfWeek(this.locale);\n  }\n\n  private initializeLocaleDateFormat(): void {\n    this._localeDateFormat = getLocaleDateFormat(this.locale, FormatWidth.Short);\n  }\n}\n"]}

package/esm2020/forms/datepicker/providers/view-manager.service.mjs

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { ClrPopoverPositions } from '../../../utils/popover/enums/positions.enum';
+import * as i0 from "@angular/core";
+/**
+ * This service manages which view is visible in the datepicker popover.
+ */
+export class ViewManagerService {
+    constructor() {
+        this._currentView = "DAYVIEW" /* DAYVIEW */;
+        this.position = ClrPopoverPositions['bottom-left'];
+    }
+    get isDayView() {
+        return this._currentView === "DAYVIEW" /* DAYVIEW */;
+    }
+    get isYearView() {
+        return this._currentView === "YEARVIEW" /* YEARVIEW */;
+    }
+    get isMonthView() {
+        return this._currentView === "MONTHVIEW" /* MONTHVIEW */;
+    }
+    changeToMonthView() {
+        this._currentView = "MONTHVIEW" /* MONTHVIEW */;
+    }
+    changeToYearView() {
+        this._currentView = "YEARVIEW" /* YEARVIEW */;
+    }
+    changeToDayView() {
+        this._currentView = "DAYVIEW" /* DAYVIEW */;
+    }
+}
+ViewManagerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ViewManagerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ViewManagerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ViewManagerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ViewManagerService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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