@openmrs/ngx-formentry 3.0.0

package/esm2015/components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-adapter.class.js

@@ -0,0 +1,347 @@
+/**
+ * native-date-time-adapter.class
+ */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { Platform } from '@angular/cdk/platform';
+import { DateTimeAdapter, OWL_DATE_TIME_LOCALE } from './date-time-adapter.class';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/platform";
+/** The default month names to use if Intl API is not available. */
+const DEFAULT_MONTH_NAMES = {
+    long: [
+        'January',
+        'February',
+        'March',
+        'April',
+        'May',
+        'June',
+        'July',
+        'August',
+        'September',
+        'October',
+        'November',
+        'December'
+    ],
+    short: [
+        'Jan',
+        'Feb',
+        'Mar',
+        'Apr',
+        'May',
+        'Jun',
+        'Jul',
+        'Aug',
+        'Sep',
+        'Oct',
+        'Nov',
+        'Dec'
+    ],
+    narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']
+};
+/** The default day of the week names to use if Intl API is not available. */
+const DEFAULT_DAY_OF_WEEK_NAMES = {
+    long: [
+        'Sunday',
+        'Monday',
+        'Tuesday',
+        'Wednesday',
+        'Thursday',
+        'Friday',
+        'Saturday'
+    ],
+    short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S']
+};
+/** The default date names to use if Intl API is not available. */
+const DEFAULT_DATE_NAMES = range(31, (i) => String(i + 1));
+/** Whether the browser supports the Intl API. */
+const SUPPORTS_INTL_API = typeof Intl !== 'undefined';
+/**
+ * Matches strings that have the form of a valid RFC 3339 string
+ * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date
+ * because the regex will match strings an with out of bounds month, date, etc.
+ */
+const ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|(?:(?:\+|-)\d{2}:\d{2}))?)?$/;
+/** Creates an array and fills it with values. */
+function range(length, valueFunction) {
+    const valuesArray = Array(length);
+    for (let i = 0; i < length; i++) {
+        valuesArray[i] = valueFunction(i);
+    }
+    return valuesArray;
+}
+export class NativeDateTimeAdapter extends DateTimeAdapter {
+    constructor(owlDateTimeLocale, platform) {
+        super();
+        this.owlDateTimeLocale = owlDateTimeLocale;
+        super.setLocale(owlDateTimeLocale);
+        // IE does its own time zone correction, so we disable this on IE.
+        this.useUtcForDisplay = !platform.TRIDENT;
+        this._clampDate = platform.TRIDENT || platform.EDGE;
+    }
+    getYear(date) {
+        return date.getFullYear();
+    }
+    getMonth(date) {
+        return date.getMonth();
+    }
+    getDay(date) {
+        return date.getDay();
+    }
+    getDate(date) {
+        return date.getDate();
+    }
+    getHours(date) {
+        return date.getHours();
+    }
+    getMinutes(date) {
+        return date.getMinutes();
+    }
+    getSeconds(date) {
+        return date.getSeconds();
+    }
+    getTime(date) {
+        return date.getTime();
+    }
+    getNumDaysInMonth(date) {
+        const lastDateOfMonth = this.createDateWithOverflow(this.getYear(date), this.getMonth(date) + 1, 0);
+        return this.getDate(lastDateOfMonth);
+    }
+    differenceInCalendarDays(dateLeft, dateRight) {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            const dateLeftStartOfDay = this.createDate(this.getYear(dateLeft), this.getMonth(dateLeft), this.getDate(dateLeft));
+            const dateRightStartOfDay = this.createDate(this.getYear(dateRight), this.getMonth(dateRight), this.getDate(dateRight));
+            const timeStampLeft = this.getTime(dateLeftStartOfDay) -
+                dateLeftStartOfDay.getTimezoneOffset() * this.milliseondsInMinute;
+            const timeStampRight = this.getTime(dateRightStartOfDay) -
+                dateRightStartOfDay.getTimezoneOffset() * this.milliseondsInMinute;
+            return Math.round((timeStampLeft - timeStampRight) / this.millisecondsInDay);
+        }
+        else {
+            return null;
+        }
+    }
+    getYearName(date) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, {
+                year: 'numeric',
+                timeZone: 'utc'
+            });
+            return this.stripDirectionalityCharacters(this._format(dtf, date));
+        }
+        return String(this.getYear(date));
+    }
+    getMonthNames(style) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, {
+                month: style,
+                timeZone: 'utc'
+            });
+            return range(12, (i) => this.stripDirectionalityCharacters(this._format(dtf, new Date(2017, i, 1))));
+        }
+        return DEFAULT_MONTH_NAMES[style];
+    }
+    getDayOfWeekNames(style) {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, {
+                weekday: style,
+                timeZone: 'utc'
+            });
+            return range(7, (i) => this.stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
+        }
+        return DEFAULT_DAY_OF_WEEK_NAMES[style];
+    }
+    getDateNames() {
+        if (SUPPORTS_INTL_API) {
+            const dtf = new Intl.DateTimeFormat(this.locale, {
+                day: 'numeric',
+                timeZone: 'utc'
+            });
+            return range(31, (i) => this.stripDirectionalityCharacters(this._format(dtf, new Date(2017, 0, i + 1))));
+        }
+        return DEFAULT_DATE_NAMES;
+    }
+    toIso8601(date) {
+        return date.toISOString();
+    }
+    isEqual(dateLeft, dateRight) {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            return dateLeft.getTime() === dateRight.getTime();
+        }
+        else {
+            return false;
+        }
+    }
+    isSameDay(dateLeft, dateRight) {
+        if (this.isValid(dateLeft) && this.isValid(dateRight)) {
+            const dateLeftStartOfDay = this.clone(dateLeft);
+            const dateRightStartOfDay = this.clone(dateRight);
+            dateLeftStartOfDay.setHours(0, 0, 0, 0);
+            dateRightStartOfDay.setHours(0, 0, 0, 0);
+            return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();
+        }
+        else {
+            return false;
+        }
+    }
+    isValid(date) {
+        return date && !isNaN(date.getTime());
+    }
+    invalid() {
+        return new Date(NaN);
+    }
+    isDateInstance(obj) {
+        return obj instanceof Date;
+    }
+    addCalendarYears(date, amount) {
+        return this.addCalendarMonths(date, amount * 12);
+    }
+    addCalendarMonths(date, amount) {
+        const result = this.clone(date);
+        amount = Number(amount);
+        const desiredMonth = result.getMonth() + amount;
+        const dateWithDesiredMonth = new Date(0);
+        dateWithDesiredMonth.setFullYear(result.getFullYear(), desiredMonth, 1);
+        dateWithDesiredMonth.setHours(0, 0, 0, 0);
+        const daysInMonth = this.getNumDaysInMonth(dateWithDesiredMonth);
+        // Set the last day of the new month
+        // if the original date was the last day of the longer month
+        result.setMonth(desiredMonth, Math.min(daysInMonth, result.getDate()));
+        return result;
+    }
+    addCalendarDays(date, amount) {
+        const result = this.clone(date);
+        amount = Number(amount);
+        result.setDate(result.getDate() + amount);
+        return result;
+    }
+    setHours(date, amount) {
+        const result = this.clone(date);
+        result.setHours(amount);
+        return result;
+    }
+    setMinutes(date, amount) {
+        const result = this.clone(date);
+        result.setMinutes(amount);
+        return result;
+    }
+    setSeconds(date, amount) {
+        const result = this.clone(date);
+        result.setSeconds(amount);
+        return result;
+    }
+    createDate(year, month, date, hours = 0, minutes = 0, seconds = 0) {
+        if (month < 0 || month > 11) {
+            throw Error(`Invalid month index "${month}". Month index has to be between 0 and 11.`);
+        }
+        if (date < 1) {
+            throw Error(`Invalid date "${date}". Date has to be greater than 0.`);
+        }
+        if (hours < 0 || hours > 23) {
+            throw Error(`Invalid hours "${hours}". Hours has to be between 0 and 23.`);
+        }
+        if (minutes < 0 || minutes > 59) {
+            throw Error(`Invalid minutes "${minutes}". Minutes has to between 0 and 59.`);
+        }
+        if (seconds < 0 || seconds > 59) {
+            throw Error(`Invalid seconds "${seconds}". Seconds has to be between 0 and 59.`);
+        }
+        const result = this.createDateWithOverflow(year, month, date, hours, minutes, seconds);
+        // Check that the date wasn't above the upper bound for the month, causing the month to overflow
+        // For example, createDate(2017, 1, 31) would try to create a date 2017/02/31 which is invalid
+        if (result.getMonth() !== month) {
+            throw Error(`Invalid date "${date}" for month with index "${month}".`);
+        }
+        return result;
+    }
+    clone(date) {
+        return this.createDate(this.getYear(date), this.getMonth(date), this.getDate(date), this.getHours(date), this.getMinutes(date), this.getSeconds(date));
+    }
+    now() {
+        return new Date();
+    }
+    format(date, displayFormat) {
+        if (!this.isValid(date)) {
+            throw Error('JSNativeDate: Cannot format invalid date.');
+        }
+        if (SUPPORTS_INTL_API) {
+            if (this._clampDate &&
+                (date.getFullYear() < 1 || date.getFullYear() > 9999)) {
+                date = this.clone(date);
+                date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));
+            }
+            displayFormat = Object.assign(Object.assign({}, displayFormat), { timeZone: 'utc' });
+            const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);
+            return this.stripDirectionalityCharacters(this._format(dtf, date));
+        }
+        return this.stripDirectionalityCharacters(date.toDateString());
+    }
+    parse(value, parseFormat) {
+        // There is no way using the native JS Date to set the parse format or locale
+        if (typeof value === 'number') {
+            return new Date(value);
+        }
+        return value ? new Date(Date.parse(value)) : null;
+    }
+    /**
+     * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings
+     * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an
+     * invalid date for all other values.
+     */
+    deserialize(value) {
+        if (typeof value === 'string') {
+            if (!value) {
+                return null;
+            }
+            // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the
+            // string is the right format first.
+            if (ISO_8601_REGEX.test(value)) {
+                const date = new Date(value);
+                if (this.isValid(date)) {
+                    return date;
+                }
+            }
+        }
+        return super.deserialize(value);
+    }
+    /**
+     * Creates a date but allows the month and date to overflow.
+     */
+    createDateWithOverflow(year, month, date, hours = 0, minutes = 0, seconds = 0) {
+        const result = new Date(year, month, date, hours, minutes, seconds);
+        if (year >= 0 && year < 100) {
+            result.setFullYear(this.getYear(result) - 1900);
+        }
+        return result;
+    }
+    /**
+     * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while
+     * other browsers do not. We remove them to make output consistent and because they interfere with
+     * date parsing.
+     */
+    stripDirectionalityCharacters(str) {
+        return str.replace(/[\u200e\u200f]/g, '');
+    }
+    /**
+     * When converting Date object to string, javascript built-in functions may return wrong
+     * results because it applies its internal DST rules. The DST rules around the world change
+     * very frequently, and the current valid rule is not always valid in previous years though.
+     * We work around this problem building a new Date object which has its internal UTC
+     * representation with the local date and time.
+     */
+    _format(dtf, date) {
+        const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds()));
+        return dtf.format(d);
+    }
+}
+NativeDateTimeAdapter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeAdapter, deps: [{ token: OWL_DATE_TIME_LOCALE, optional: true }, { token: i1.Platform }], target: i0.ɵɵFactoryTarget.Injectable });
+NativeDateTimeAdapter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeAdapter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [OWL_DATE_TIME_LOCALE]
+                }] }, { type: i1.Platform }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"native-date-time-adapter.class.js","sourceRoot":"","sources":["../../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-adapter.class.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * native-date-time-adapter.class\n */\n\nimport { Inject, Injectable, Optional } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\nimport {\n  DateTimeAdapter,\n  OWL_DATE_TIME_LOCALE\n} from './date-time-adapter.class';\n\n/** The default month names to use if Intl API is not available. */\nconst DEFAULT_MONTH_NAMES = {\n  long: [\n    'January',\n    'February',\n    'March',\n    'April',\n    'May',\n    'June',\n    'July',\n    'August',\n    'September',\n    'October',\n    'November',\n    'December'\n  ],\n  short: [\n    'Jan',\n    'Feb',\n    'Mar',\n    'Apr',\n    'May',\n    'Jun',\n    'Jul',\n    'Aug',\n    'Sep',\n    'Oct',\n    'Nov',\n    'Dec'\n  ],\n  narrow: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D']\n};\n\n/** The default day of the week names to use if Intl API is not available. */\nconst DEFAULT_DAY_OF_WEEK_NAMES = {\n  long: [\n    'Sunday',\n    'Monday',\n    'Tuesday',\n    'Wednesday',\n    'Thursday',\n    'Friday',\n    'Saturday'\n  ],\n  short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],\n  narrow: ['S', 'M', 'T', 'W', 'T', 'F', 'S']\n};\n\n/** The default date names to use if Intl API is not available. */\nconst DEFAULT_DATE_NAMES = range(31, (i) => String(i + 1));\n\n/** Whether the browser supports the Intl API. */\nconst SUPPORTS_INTL_API = typeof Intl !== 'undefined';\n\n/**\n * Matches strings that have the form of a valid RFC 3339 string\n * (https://tools.ietf.org/html/rfc3339). Note that the string may not actually be a valid date\n * because the regex will match strings an with out of bounds month, date, etc.\n */\nconst ISO_8601_REGEX = /^\\d{4}-\\d{2}-\\d{2}(?:T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|(?:(?:\\+|-)\\d{2}:\\d{2}))?)?$/;\n\n/** Creates an array and fills it with values. */\nfunction range<T>(length: number, valueFunction: (index: number) => T): T[] {\n  const valuesArray = Array(length);\n  for (let i = 0; i < length; i++) {\n    valuesArray[i] = valueFunction(i);\n  }\n  return valuesArray;\n}\n\n@Injectable()\nexport class NativeDateTimeAdapter extends DateTimeAdapter<Date> {\n  /** Whether to clamp the date between 1 and 9999 to avoid IE and Edge errors. */\n  private readonly _clampDate: boolean;\n\n  /**\n   * Whether to use `timeZone: 'utc'` with `Intl.DateTimeFormat` when formatting dates.\n   * Without this `Intl.DateTimeFormat` sometimes chooses the wrong timeZone, which can throw off\n   * the result. (e.g. in the en-US locale `new Date(1800, 7, 14).toLocaleDateString()`\n   * will produce `'8/13/1800'`.\n   */\n  useUtcForDisplay: boolean;\n\n  constructor(\n    @Optional()\n    @Inject(OWL_DATE_TIME_LOCALE)\n    private owlDateTimeLocale: string,\n    platform: Platform\n  ) {\n    super();\n    super.setLocale(owlDateTimeLocale);\n\n    // IE does its own time zone correction, so we disable this on IE.\n    this.useUtcForDisplay = !platform.TRIDENT;\n    this._clampDate = platform.TRIDENT || platform.EDGE;\n  }\n\n  public getYear(date: Date): number {\n    return date.getFullYear();\n  }\n\n  public getMonth(date: Date): number {\n    return date.getMonth();\n  }\n\n  public getDay(date: Date): number {\n    return date.getDay();\n  }\n\n  public getDate(date: Date): number {\n    return date.getDate();\n  }\n\n  public getHours(date: Date): number {\n    return date.getHours();\n  }\n\n  public getMinutes(date: Date): number {\n    return date.getMinutes();\n  }\n\n  public getSeconds(date: Date): number {\n    return date.getSeconds();\n  }\n\n  public getTime(date: Date): number {\n    return date.getTime();\n  }\n\n  public getNumDaysInMonth(date: Date): number {\n    const lastDateOfMonth = this.createDateWithOverflow(\n      this.getYear(date),\n      this.getMonth(date) + 1,\n      0\n    );\n\n    return this.getDate(lastDateOfMonth);\n  }\n\n  public differenceInCalendarDays(dateLeft: Date, dateRight: Date): number {\n    if (this.isValid(dateLeft) && this.isValid(dateRight)) {\n      const dateLeftStartOfDay = this.createDate(\n        this.getYear(dateLeft),\n        this.getMonth(dateLeft),\n        this.getDate(dateLeft)\n      );\n      const dateRightStartOfDay = this.createDate(\n        this.getYear(dateRight),\n        this.getMonth(dateRight),\n        this.getDate(dateRight)\n      );\n\n      const timeStampLeft =\n        this.getTime(dateLeftStartOfDay) -\n        dateLeftStartOfDay.getTimezoneOffset() * this.milliseondsInMinute;\n      const timeStampRight =\n        this.getTime(dateRightStartOfDay) -\n        dateRightStartOfDay.getTimezoneOffset() * this.milliseondsInMinute;\n      return Math.round(\n        (timeStampLeft - timeStampRight) / this.millisecondsInDay\n      );\n    } else {\n      return null;\n    }\n  }\n\n  public getYearName(date: Date): string {\n    if (SUPPORTS_INTL_API) {\n      const dtf = new Intl.DateTimeFormat(this.locale, {\n        year: 'numeric',\n        timeZone: 'utc'\n      });\n      return this.stripDirectionalityCharacters(this._format(dtf, date));\n    }\n    return String(this.getYear(date));\n  }\n\n  public getMonthNames(style: 'long' | 'short' | 'narrow'): string[] {\n    if (SUPPORTS_INTL_API) {\n      const dtf = new Intl.DateTimeFormat(this.locale, {\n        month: style,\n        timeZone: 'utc'\n      });\n      return range(12, (i) =>\n        this.stripDirectionalityCharacters(\n          this._format(dtf, new Date(2017, i, 1))\n        )\n      );\n    }\n    return DEFAULT_MONTH_NAMES[style];\n  }\n\n  public getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[] {\n    if (SUPPORTS_INTL_API) {\n      const dtf = new Intl.DateTimeFormat(this.locale, {\n        weekday: style,\n        timeZone: 'utc'\n      });\n      return range(7, (i) =>\n        this.stripDirectionalityCharacters(\n          this._format(dtf, new Date(2017, 0, i + 1))\n        )\n      );\n    }\n\n    return DEFAULT_DAY_OF_WEEK_NAMES[style];\n  }\n\n  public getDateNames(): string[] {\n    if (SUPPORTS_INTL_API) {\n      const dtf = new Intl.DateTimeFormat(this.locale, {\n        day: 'numeric',\n        timeZone: 'utc'\n      });\n      return range(31, (i) =>\n        this.stripDirectionalityCharacters(\n          this._format(dtf, new Date(2017, 0, i + 1))\n        )\n      );\n    }\n    return DEFAULT_DATE_NAMES;\n  }\n\n  public toIso8601(date: Date): string {\n    return date.toISOString();\n  }\n\n  public isEqual(dateLeft: Date, dateRight: Date): boolean {\n    if (this.isValid(dateLeft) && this.isValid(dateRight)) {\n      return dateLeft.getTime() === dateRight.getTime();\n    } else {\n      return false;\n    }\n  }\n\n  public isSameDay(dateLeft: Date, dateRight: Date): boolean {\n    if (this.isValid(dateLeft) && this.isValid(dateRight)) {\n      const dateLeftStartOfDay = this.clone(dateLeft);\n      const dateRightStartOfDay = this.clone(dateRight);\n      dateLeftStartOfDay.setHours(0, 0, 0, 0);\n      dateRightStartOfDay.setHours(0, 0, 0, 0);\n      return dateLeftStartOfDay.getTime() === dateRightStartOfDay.getTime();\n    } else {\n      return false;\n    }\n  }\n\n  public isValid(date: Date): boolean {\n    return date && !isNaN(date.getTime());\n  }\n\n  public invalid(): Date {\n    return new Date(NaN);\n  }\n\n  public isDateInstance(obj: any): boolean {\n    return obj instanceof Date;\n  }\n\n  public addCalendarYears(date: Date, amount: number): Date {\n    return this.addCalendarMonths(date, amount * 12);\n  }\n\n  public addCalendarMonths(date: Date, amount: number): Date {\n    const result = this.clone(date);\n    amount = Number(amount);\n\n    const desiredMonth = result.getMonth() + amount;\n    const dateWithDesiredMonth = new Date(0);\n    dateWithDesiredMonth.setFullYear(result.getFullYear(), desiredMonth, 1);\n    dateWithDesiredMonth.setHours(0, 0, 0, 0);\n\n    const daysInMonth = this.getNumDaysInMonth(dateWithDesiredMonth);\n    // Set the last day of the new month\n    // if the original date was the last day of the longer month\n    result.setMonth(desiredMonth, Math.min(daysInMonth, result.getDate()));\n    return result;\n  }\n\n  public addCalendarDays(date: Date, amount: number): Date {\n    const result = this.clone(date);\n    amount = Number(amount);\n    result.setDate(result.getDate() + amount);\n    return result;\n  }\n\n  public setHours(date: Date, amount: number): Date {\n    const result = this.clone(date);\n    result.setHours(amount);\n    return result;\n  }\n\n  public setMinutes(date: Date, amount: number): Date {\n    const result = this.clone(date);\n    result.setMinutes(amount);\n    return result;\n  }\n\n  public setSeconds(date: Date, amount: number): Date {\n    const result = this.clone(date);\n    result.setSeconds(amount);\n    return result;\n  }\n\n  public createDate(\n    year: number,\n    month: number,\n    date: number,\n    hours: number = 0,\n    minutes: number = 0,\n    seconds: number = 0\n  ): Date {\n    if (month < 0 || month > 11) {\n      throw Error(\n        `Invalid month index \"${month}\". Month index has to be between 0 and 11.`\n      );\n    }\n\n    if (date < 1) {\n      throw Error(`Invalid date \"${date}\". Date has to be greater than 0.`);\n    }\n\n    if (hours < 0 || hours > 23) {\n      throw Error(\n        `Invalid hours \"${hours}\". Hours has to be between 0 and 23.`\n      );\n    }\n\n    if (minutes < 0 || minutes > 59) {\n      throw Error(\n        `Invalid minutes \"${minutes}\". Minutes has to between 0 and 59.`\n      );\n    }\n\n    if (seconds < 0 || seconds > 59) {\n      throw Error(\n        `Invalid seconds \"${seconds}\". Seconds has to be between 0 and 59.`\n      );\n    }\n\n    const result = this.createDateWithOverflow(\n      year,\n      month,\n      date,\n      hours,\n      minutes,\n      seconds\n    );\n\n    // Check that the date wasn't above the upper bound for the month, causing the month to overflow\n    // For example, createDate(2017, 1, 31) would try to create a date 2017/02/31 which is invalid\n    if (result.getMonth() !== month) {\n      throw Error(`Invalid date \"${date}\" for month with index \"${month}\".`);\n    }\n\n    return result;\n  }\n\n  public clone(date: Date): Date {\n    return this.createDate(\n      this.getYear(date),\n      this.getMonth(date),\n      this.getDate(date),\n      this.getHours(date),\n      this.getMinutes(date),\n      this.getSeconds(date)\n    );\n  }\n\n  public now(): Date {\n    return new Date();\n  }\n\n  public format(date: Date, displayFormat: any): string {\n    if (!this.isValid(date)) {\n      throw Error('JSNativeDate: Cannot format invalid date.');\n    }\n\n    if (SUPPORTS_INTL_API) {\n      if (\n        this._clampDate &&\n        (date.getFullYear() < 1 || date.getFullYear() > 9999)\n      ) {\n        date = this.clone(date);\n        date.setFullYear(Math.max(1, Math.min(9999, date.getFullYear())));\n      }\n\n      displayFormat = { ...displayFormat, timeZone: 'utc' };\n      const dtf = new Intl.DateTimeFormat(this.locale, displayFormat);\n      return this.stripDirectionalityCharacters(this._format(dtf, date));\n    }\n\n    return this.stripDirectionalityCharacters(date.toDateString());\n  }\n\n  public parse(value: any, parseFormat: any): Date | null {\n    // There is no way using the native JS Date to set the parse format or locale\n    if (typeof value === 'number') {\n      return new Date(value);\n    }\n    return value ? new Date(Date.parse(value)) : null;\n  }\n\n  /**\n   * Returns the given value if given a valid Date or null. Deserializes valid ISO 8601 strings\n   * (https://www.ietf.org/rfc/rfc3339.txt) into valid Dates and empty string into null. Returns an\n   * invalid date for all other values.\n   */\n  public deserialize(value: any): Date | null {\n    if (typeof value === 'string') {\n      if (!value) {\n        return null;\n      }\n      // The `Date` constructor accepts formats other than ISO 8601, so we need to make sure the\n      // string is the right format first.\n      if (ISO_8601_REGEX.test(value)) {\n        const date = new Date(value);\n        if (this.isValid(date)) {\n          return date;\n        }\n      }\n    }\n    return super.deserialize(value);\n  }\n\n  /**\n   * Creates a date but allows the month and date to overflow.\n   */\n  private createDateWithOverflow(\n    year: number,\n    month: number,\n    date: number,\n    hours: number = 0,\n    minutes: number = 0,\n    seconds: number = 0\n  ): Date {\n    const result = new Date(year, month, date, hours, minutes, seconds);\n\n    if (year >= 0 && year < 100) {\n      result.setFullYear(this.getYear(result) - 1900);\n    }\n    return result;\n  }\n\n  /**\n   * Strip out unicode LTR and RTL characters. Edge and IE insert these into formatted dates while\n   * other browsers do not. We remove them to make output consistent and because they interfere with\n   * date parsing.\n   */\n  private stripDirectionalityCharacters(str: string) {\n    return str.replace(/[\\u200e\\u200f]/g, '');\n  }\n\n  /**\n   * When converting Date object to string, javascript built-in functions may return wrong\n   * results because it applies its internal DST rules. The DST rules around the world change\n   * very frequently, and the current valid rule is not always valid in previous years though.\n   * We work around this problem building a new Date object which has its internal UTC\n   * representation with the local date and time.\n   */\n  private _format(dtf: Intl.DateTimeFormat, date: Date) {\n    const d = new Date(\n      Date.UTC(\n        date.getFullYear(),\n        date.getMonth(),\n        date.getDate(),\n        date.getHours(),\n        date.getMinutes(),\n        date.getSeconds(),\n        date.getMilliseconds()\n      )\n    );\n    return dtf.format(d);\n  }\n}\n"]}

package/esm2015/components/ngx-pick-datetime/lib/date-time/adapter/native-date-time-format.class.js

@@ -0,0 +1,16 @@
+export const OWL_NATIVE_DATE_TIME_FORMATS = {
+    parseInput: null,
+    fullPickerInput: {
+        year: 'numeric',
+        month: 'numeric',
+        day: 'numeric',
+        hour: 'numeric',
+        minute: 'numeric'
+    },
+    datePickerInput: { year: 'numeric', month: 'numeric', day: 'numeric' },
+    timePickerInput: { hour: 'numeric', minute: 'numeric' },
+    monthYearLabel: { year: 'numeric', month: 'short' },
+    dateA11yLabel: { year: 'numeric', month: 'long', day: 'numeric' },
+    monthYearA11yLabel: { year: 'numeric', month: 'long' }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmF0aXZlLWRhdGUtdGltZS1mb3JtYXQuY2xhc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtZm9ybWVudHJ5L3NyYy9jb21wb25lbnRzL25neC1waWNrLWRhdGV0aW1lL2xpYi9kYXRlLXRpbWUvYWRhcHRlci9uYXRpdmUtZGF0ZS10aW1lLWZvcm1hdC5jbGFzcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFLQSxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBdUI7SUFDOUQsVUFBVSxFQUFFLElBQUk7SUFDaEIsZUFBZSxFQUFFO1FBQ2YsSUFBSSxFQUFFLFNBQVM7UUFDZixLQUFLLEVBQUUsU0FBUztRQUNoQixHQUFHLEVBQUUsU0FBUztRQUNkLElBQUksRUFBRSxTQUFTO1FBQ2YsTUFBTSxFQUFFLFNBQVM7S0FDbEI7SUFDRCxlQUFlLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxTQUFTLEVBQUUsR0FBRyxFQUFFLFNBQVMsRUFBRTtJQUN0RSxlQUFlLEVBQUUsRUFBRSxJQUFJLEVBQUUsU0FBUyxFQUFFLE1BQU0sRUFBRSxTQUFTLEVBQUU7SUFDdkQsY0FBYyxFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFO0lBQ25ELGFBQWEsRUFBRSxFQUFFLElBQUksRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxHQUFHLEVBQUUsU0FBUyxFQUFFO0lBQ2pFLGtCQUFrQixFQUFFLEVBQUUsSUFBSSxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFFO0NBQ3ZELENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIG5hdGl2ZS1kYXRlLXRpbWUtZm9ybWF0LmNsYXNzXG4gKi9cbmltcG9ydCB7IE93bERhdGVUaW1lRm9ybWF0cyB9IGZyb20gJy4vZGF0ZS10aW1lLWZvcm1hdC5jbGFzcyc7XG5cbmV4cG9ydCBjb25zdCBPV0xfTkFUSVZFX0RBVEVfVElNRV9GT1JNQVRTOiBPd2xEYXRlVGltZUZvcm1hdHMgPSB7XG4gIHBhcnNlSW5wdXQ6IG51bGwsXG4gIGZ1bGxQaWNrZXJJbnB1dDoge1xuICAgIHllYXI6ICdudW1lcmljJyxcbiAgICBtb250aDogJ251bWVyaWMnLFxuICAgIGRheTogJ251bWVyaWMnLFxuICAgIGhvdXI6ICdudW1lcmljJyxcbiAgICBtaW51dGU6ICdudW1lcmljJ1xuICB9LFxuICBkYXRlUGlja2VySW5wdXQ6IHsgeWVhcjogJ251bWVyaWMnLCBtb250aDogJ251bWVyaWMnLCBkYXk6ICdudW1lcmljJyB9LFxuICB0aW1lUGlja2VySW5wdXQ6IHsgaG91cjogJ251bWVyaWMnLCBtaW51dGU6ICdudW1lcmljJyB9LFxuICBtb250aFllYXJMYWJlbDogeyB5ZWFyOiAnbnVtZXJpYycsIG1vbnRoOiAnc2hvcnQnIH0sXG4gIGRhdGVBMTF5TGFiZWw6IHsgeWVhcjogJ251bWVyaWMnLCBtb250aDogJ2xvbmcnLCBkYXk6ICdudW1lcmljJyB9LFxuICBtb250aFllYXJBMTF5TGFiZWw6IHsgeWVhcjogJ251bWVyaWMnLCBtb250aDogJ2xvbmcnIH1cbn07XG4iXX0=

package/esm2015/components/ngx-pick-datetime/lib/date-time/adapter/native-date-time.module.js

@@ -0,0 +1,39 @@
+/**
+ * native-date-time.module
+ */
+import { NgModule } from '@angular/core';
+import { PlatformModule } from '@angular/cdk/platform';
+import { DateTimeAdapter } from './date-time-adapter.class';
+import { NativeDateTimeAdapter } from './native-date-time-adapter.class';
+import { OWL_DATE_TIME_FORMATS } from './date-time-format.class';
+import { OWL_NATIVE_DATE_TIME_FORMATS } from './native-date-time-format.class';
+import * as i0 from "@angular/core";
+export class NativeDateTimeModule {
+}
+NativeDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+NativeDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeModule, imports: [PlatformModule] });
+NativeDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeModule, providers: [{ provide: DateTimeAdapter, useClass: NativeDateTimeAdapter }], imports: [[PlatformModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: NativeDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [PlatformModule],
+                    providers: [{ provide: DateTimeAdapter, useClass: NativeDateTimeAdapter }]
+                }]
+        }] });
+export class OwlNativeDateTimeModule {
+}
+OwlNativeDateTimeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlNativeDateTimeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+OwlNativeDateTimeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlNativeDateTimeModule, imports: [NativeDateTimeModule] });
+OwlNativeDateTimeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlNativeDateTimeModule, providers: [
+        { provide: OWL_DATE_TIME_FORMATS, useValue: OWL_NATIVE_DATE_TIME_FORMATS }
+    ], imports: [[NativeDateTimeModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlNativeDateTimeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [NativeDateTimeModule],
+                    providers: [
+                        { provide: OWL_DATE_TIME_FORMATS, useValue: OWL_NATIVE_DATE_TIME_FORMATS }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/ngx-pick-datetime/lib/date-time/calendar-body.component.js

@@ -0,0 +1,149 @@
+import { ChangeDetectionStrategy, Component, ElementRef, EventEmitter, HostBinding, Input, NgZone, Output } from '@angular/core';
+import { take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class CalendarCell {
+    constructor(value, displayValue, ariaLabel, enabled, out = false, cellClass = '') {
+        this.value = value;
+        this.displayValue = displayValue;
+        this.ariaLabel = ariaLabel;
+        this.enabled = enabled;
+        this.out = out;
+        this.cellClass = cellClass;
+    }
+}
+export class OwlCalendarBodyComponent {
+    constructor(elmRef, ngZone) {
+        this.elmRef = elmRef;
+        this.ngZone = ngZone;
+        this.owlDTCalendarBodyClass = true;
+        /**
+         * The cell number of the active cell in the table.
+         */
+        this.activeCell = 0;
+        /**
+         * The number of columns in the table.
+         * */
+        this.numCols = 7;
+        /**
+         * The ratio (width / height) to use for the cells in the table.
+         */
+        this.cellRatio = 1;
+        /**
+         * Emit when a calendar cell is selected
+         * */
+        this.cellSelected = new EventEmitter();
+    }
+    get isInSingleMode() {
+        return this.selectMode === 'single';
+    }
+    get isInRangeMode() {
+        return (this.selectMode === 'range' ||
+            this.selectMode === 'rangeFrom' ||
+            this.selectMode === 'rangeTo');
+    }
+    selectCell(cell) {
+        this.cellSelected.emit(cell);
+    }
+    isActiveCell(rowIndex, colIndex) {
+        const cellNumber = rowIndex * this.numCols + colIndex;
+        return cellNumber === this.activeCell;
+    }
+    /**
+     * Check if the cell is selected
+     */
+    isSelected(value) {
+        if (!this.selectedValues || this.selectedValues.length === 0) {
+            return false;
+        }
+        if (this.isInSingleMode) {
+            return value === this.selectedValues[0];
+        }
+        if (this.isInRangeMode) {
+            const fromValue = this.selectedValues[0];
+            const toValue = this.selectedValues[1];
+            return value === fromValue || value === toValue;
+        }
+    }
+    /**
+     * Check if the cell in the range
+     * */
+    isInRange(value) {
+        if (this.isInRangeMode) {
+            const fromValue = this.selectedValues[0];
+            const toValue = this.selectedValues[1];
+            if (fromValue !== null && toValue !== null) {
+                return value >= fromValue && value <= toValue;
+            }
+            else {
+                return value === fromValue || value === toValue;
+            }
+        }
+    }
+    /**
+     * Check if the cell is the range from
+     * */
+    isRangeFrom(value) {
+        if (this.isInRangeMode) {
+            const fromValue = this.selectedValues[0];
+            return fromValue !== null && value === fromValue;
+        }
+    }
+    /**
+     * Check if the cell is the range to
+     * */
+    isRangeTo(value) {
+        if (this.isInRangeMode) {
+            const toValue = this.selectedValues[1];
+            return toValue !== null && value === toValue;
+        }
+    }
+    /**
+     * Focus to a active cell
+     * */
+    focusActiveCell() {
+        this.ngZone.runOutsideAngular(() => {
+            this.ngZone.onStable
+                .asObservable()
+                .pipe(take(1))
+                .subscribe(() => {
+                this.elmRef.nativeElement
+                    .querySelector('.owl-dt-calendar-cell-active')
+                    .focus();
+            });
+        });
+    }
+}
+OwlCalendarBodyComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlCalendarBodyComponent, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Component });
+OwlCalendarBodyComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: OwlCalendarBodyComponent, selector: "[ofe-owl-date-time-calendar-body]", inputs: { activeCell: "activeCell", rows: "rows", numCols: "numCols", cellRatio: "cellRatio", todayValue: "todayValue", selectedValues: "selectedValues", selectMode: "selectMode" }, outputs: { cellSelected: "cellSelected" }, host: { properties: { "class.owl-dt-calendar-body": "this.owlDTCalendarBodyClass" } }, exportAs: ["owlDateTimeCalendarBody"], ngImport: i0, template: "<tr *ngFor=\"let row of rows; let rowIndex = index\" role=\"row\">\n  <td\n    *ngFor=\"let item of row; let colIndex = index\"\n    class=\"owl-dt-calendar-cell {{ item.cellClass }}\"\n    [tabindex]=\"isActiveCell(rowIndex, colIndex) ? 0 : -1\"\n    [class.owl-dt-calendar-cell-active]=\"isActiveCell(rowIndex, colIndex)\"\n    [class.owl-dt-calendar-cell-disabled]=\"!item.enabled\"\n    [class.owl-dt-calendar-cell-in-range]=\"isInRange(item.value)\"\n    [class.owl-dt-calendar-cell-range-from]=\"isRangeFrom(item.value)\"\n    [class.owl-dt-calendar-cell-range-to]=\"isRangeTo(item.value)\"\n    [attr.aria-label]=\"item.ariaLabel\"\n    [attr.aria-disabled]=\"!item.enabled || null\"\n    [style.width.%]=\"100 / numCols\"\n    [style.paddingTop.%]=\"(50 * cellRatio) / numCols\"\n    [style.paddingBottom.%]=\"(50 * cellRatio) / numCols\"\n    (click)=\"selectCell(item)\"\n  >\n    <span\n      class=\"owl-dt-calendar-cell-content\"\n      [ngClass]=\"{\n        'owl-dt-calendar-cell-out': item.out,\n        'owl-dt-calendar-cell-today': item.value === todayValue,\n        'owl-dt-calendar-cell-selected': isSelected(item.value)\n      }\"\n    >\n      {{ item.displayValue }}\n    </span>\n  </td>\n</tr>\n", styles: [""], directives: [{ type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: OwlCalendarBodyComponent, decorators: [{
+            type: Component,
+            args: [{
+                    /* eslint-disable-next-line @angular-eslint/component-selector */
+                    selector: '[ofe-owl-date-time-calendar-body]',
+                    exportAs: 'owlDateTimeCalendarBody',
+                    templateUrl: './calendar-body.component.html',
+                    styleUrls: ['./calendar-body.component.scss'],
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.NgZone }]; }, propDecorators: { owlDTCalendarBodyClass: [{
+                type: HostBinding,
+                args: ['class.owl-dt-calendar-body']
+            }], activeCell: [{
+                type: Input
+            }], rows: [{
+                type: Input
+            }], numCols: [{
+                type: Input
+            }], cellRatio: [{
+                type: Input
+            }], todayValue: [{
+                type: Input
+            }], selectedValues: [{
+                type: Input
+            }], selectMode: [{
+                type: Input
+            }], cellSelected: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calendar-body.component.js","sourceRoot":"","sources":["../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/calendar-body.component.ts","../../../../../../../projects/ngx-formentry/src/components/ngx-pick-datetime/lib/date-time/calendar-body.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Input,\n  NgZone,\n  Output\n} from '@angular/core';\nimport { take } from 'rxjs/operators';\nimport { SelectMode } from './date-time.class';\n\nexport class CalendarCell {\n  constructor(\n    public value: number,\n    public displayValue: string,\n    public ariaLabel: string,\n    public enabled: boolean,\n    public out = false,\n    public cellClass: string = ''\n  ) {}\n}\n\n@Component({\n  /* eslint-disable-next-line @angular-eslint/component-selector */\n  selector: '[ofe-owl-date-time-calendar-body]',\n  exportAs: 'owlDateTimeCalendarBody',\n  templateUrl: './calendar-body.component.html',\n  styleUrls: ['./calendar-body.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class OwlCalendarBodyComponent {\n  @HostBinding('class.owl-dt-calendar-body') owlDTCalendarBodyClass = true;\n\n  /**\n   * The cell number of the active cell in the table.\n   */\n  @Input()\n  activeCell = 0;\n\n  /**\n   * The cells to display in the table.\n   * */\n  @Input()\n  rows: CalendarCell[][];\n\n  /**\n   * The number of columns in the table.\n   * */\n  @Input()\n  numCols = 7;\n\n  /**\n   * The ratio (width / height) to use for the cells in the table.\n   */\n  @Input()\n  cellRatio = 1;\n\n  /**\n   * The value in the table that corresponds to today.\n   * */\n  @Input()\n  todayValue: number;\n\n  /**\n   * The value in the table that is currently selected.\n   * */\n  @Input()\n  selectedValues: number[];\n\n  /**\n   * Current picker select mode\n   */\n  @Input()\n  selectMode: SelectMode;\n\n  /**\n   * Emit when a calendar cell is selected\n   * */\n  @Output()\n  public readonly cellSelected = new EventEmitter<CalendarCell>();\n\n  get isInSingleMode(): boolean {\n    return this.selectMode === 'single';\n  }\n\n  get isInRangeMode(): boolean {\n    return (\n      this.selectMode === 'range' ||\n      this.selectMode === 'rangeFrom' ||\n      this.selectMode === 'rangeTo'\n    );\n  }\n\n  constructor(private elmRef: ElementRef, private ngZone: NgZone) {}\n\n  public selectCell(cell: CalendarCell): void {\n    this.cellSelected.emit(cell);\n  }\n\n  public isActiveCell(rowIndex: number, colIndex: number): boolean {\n    const cellNumber = rowIndex * this.numCols + colIndex;\n    return cellNumber === this.activeCell;\n  }\n\n  /**\n   * Check if the cell is selected\n   */\n  public isSelected(value: number): boolean {\n    if (!this.selectedValues || this.selectedValues.length === 0) {\n      return false;\n    }\n\n    if (this.isInSingleMode) {\n      return value === this.selectedValues[0];\n    }\n\n    if (this.isInRangeMode) {\n      const fromValue = this.selectedValues[0];\n      const toValue = this.selectedValues[1];\n\n      return value === fromValue || value === toValue;\n    }\n  }\n\n  /**\n   * Check if the cell in the range\n   * */\n  public isInRange(value: number): boolean {\n    if (this.isInRangeMode) {\n      const fromValue = this.selectedValues[0];\n      const toValue = this.selectedValues[1];\n\n      if (fromValue !== null && toValue !== null) {\n        return value >= fromValue && value <= toValue;\n      } else {\n        return value === fromValue || value === toValue;\n      }\n    }\n  }\n\n  /**\n   * Check if the cell is the range from\n   * */\n  public isRangeFrom(value: number): boolean {\n    if (this.isInRangeMode) {\n      const fromValue = this.selectedValues[0];\n      return fromValue !== null && value === fromValue;\n    }\n  }\n\n  /**\n   * Check if the cell is the range to\n   * */\n  public isRangeTo(value: number): boolean {\n    if (this.isInRangeMode) {\n      const toValue = this.selectedValues[1];\n      return toValue !== null && value === toValue;\n    }\n  }\n\n  /**\n   * Focus to a active cell\n   * */\n  public focusActiveCell(): void {\n    this.ngZone.runOutsideAngular(() => {\n      this.ngZone.onStable\n        .asObservable()\n        .pipe(take(1))\n        .subscribe(() => {\n          this.elmRef.nativeElement\n            .querySelector('.owl-dt-calendar-cell-active')\n            .focus();\n        });\n    });\n  }\n}\n","<tr *ngFor=\"let row of rows; let rowIndex = index\" role=\"row\">\n  <td\n    *ngFor=\"let item of row; let colIndex = index\"\n    class=\"owl-dt-calendar-cell {{ item.cellClass }}\"\n    [tabindex]=\"isActiveCell(rowIndex, colIndex) ? 0 : -1\"\n    [class.owl-dt-calendar-cell-active]=\"isActiveCell(rowIndex, colIndex)\"\n    [class.owl-dt-calendar-cell-disabled]=\"!item.enabled\"\n    [class.owl-dt-calendar-cell-in-range]=\"isInRange(item.value)\"\n    [class.owl-dt-calendar-cell-range-from]=\"isRangeFrom(item.value)\"\n    [class.owl-dt-calendar-cell-range-to]=\"isRangeTo(item.value)\"\n    [attr.aria-label]=\"item.ariaLabel\"\n    [attr.aria-disabled]=\"!item.enabled || null\"\n    [style.width.%]=\"100 / numCols\"\n    [style.paddingTop.%]=\"(50 * cellRatio) / numCols\"\n    [style.paddingBottom.%]=\"(50 * cellRatio) / numCols\"\n    (click)=\"selectCell(item)\"\n  >\n    <span\n      class=\"owl-dt-calendar-cell-content\"\n      [ngClass]=\"{\n        'owl-dt-calendar-cell-out': item.out,\n        'owl-dt-calendar-cell-today': item.value === todayValue,\n        'owl-dt-calendar-cell-selected': isSelected(item.value)\n      }\"\n    >\n      {{ item.displayValue }}\n    </span>\n  </td>\n</tr>\n"]}