@porscheinformatik/clr-addons 15.0.0 → 15.2.0

package/esm2020/daterangepicker/directives/if-daterange-error.directive.mjs

@@ -0,0 +1,94 @@
+import { Directive, Input, Optional, TemplateRef, ViewContainerRef } from '@angular/core';
+import { DaterangeControlStateService } from '../providers/daterange-control-state.service';
+import { ClrDaterangepickerContainerComponent } from './daterangepicker-container/daterangepicker-container.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../providers/daterange-control-state.service";
+import * as i2 from "./daterangepicker-container/daterangepicker-container.component";
+/**
+ * Directive for multiple error messages.
+ * It works the same as Clarity `ClrIfError`, but for customized `ClrDaterangepickerContainerComponent`.
+ * Using Clarity `ClrIfError` requires the container to have service implemented that are not publicly exported.
+ *
+ * @see https://clarity.design/documentation/forms (section "Multiple error messages").
+ *
+ * Altered version from https://github.com/vmware-clarity/ng-clarity/blob/138a6dd95fdc4ffb67b054391c44ce5fa3c44660/projects/angular/src/forms/common/if-control-state/if-error.ts
+ */
+export class ClrIfDaterangeErrorDirective {
+    constructor(template, container, daterangeControlStateService, daterangepickerContainerComponent) {
+        this.template = template;
+        this.container = container;
+        this.daterangeControlStateService = daterangeControlStateService;
+        this.daterangepickerContainerComponent = daterangepickerContainerComponent;
+        /** Flag to remember if content is displayed. */
+        this.displayedContent = false;
+        /** List of subscriptions to later destroy. */
+        this.subscriptions = [];
+        // This directive only works inside `clr-daterangepicker-container`.
+        if (this.daterangeControlStateService == null || this.daterangepickerContainerComponent == null) {
+            throw new Error('`ClrIfDaterangeErrorDirective` can only be used within `ClrDaterangepickerContainerComponent`');
+        }
+        // Listen to status changes to toggle error visibility.
+        this.subscriptions.push(this.daterangeControlStateService.statusChange.subscribe((_status) => {
+            this.handleState();
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(subscription => subscription.unsubscribe());
+    }
+    /**
+     * Handle error depending on states.
+     */
+    handleState() {
+        if (!this.daterangeControlStateService.invalid) {
+            // If control is not invalid, hide all errors.
+            this.toggleErrorVisibility(false);
+        }
+        else if (this.clrIfDaterangeError) {
+            // Display error only if error input is list of errors.
+            const hasError = this.clrIfDaterangeError in this.daterangeControlStateService.errors;
+            this.toggleErrorVisibility(hasError);
+        }
+        else {
+            // Display error.
+            this.toggleErrorVisibility(true);
+        }
+    }
+    /**
+     * Display/hide error.
+     * @param displayError - Wether to show/hide error.
+     */
+    toggleErrorVisibility(displayError) {
+        if (displayError) {
+            const error = this.daterangeControlStateService.errors[this.clrIfDaterangeError];
+            if (this.displayedContent === false) {
+                this.embeddedViewRef = this.container.createEmbeddedView(this.template, {
+                    error,
+                });
+                this.displayedContent = true;
+            }
+            else if (this.embeddedViewRef && this.embeddedViewRef.context) {
+                // If view is already rendered, update the error object to keep it in sync.
+                this.embeddedViewRef.context.error = error;
+            }
+        }
+        else {
+            this.container.clear();
+            this.displayedContent = false;
+        }
+    }
+}
+ClrIfDaterangeErrorDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrIfDaterangeErrorDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i1.DaterangeControlStateService, optional: true }, { token: i2.ClrDaterangepickerContainerComponent, optional: true }], target: i0.ɵɵFactoryTarget.Directive });
+ClrIfDaterangeErrorDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", type: ClrIfDaterangeErrorDirective, selector: "[clrIfDaterangeError]", inputs: { clrIfDaterangeError: "clrIfDaterangeError" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrIfDaterangeErrorDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrIfDaterangeError]',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i1.DaterangeControlStateService, decorators: [{
+                    type: Optional
+                }] }, { type: i2.ClrDaterangepickerContainerComponent, decorators: [{
+                    type: Optional
+                }] }]; }, propDecorators: { clrIfDaterangeError: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/index.mjs

@@ -0,0 +1,14 @@
+export * from './daterange.constants';
+export * from './daterangepicker.module';
+export * from './directives/daterangepicker-container/daterangepicker-container.component';
+export * from './directives/daterangepicker/daterangepicker.directive';
+export * from './directives/if-daterange-error.directive';
+export * from './interfaces/daterange-preset.interface';
+export * from './interfaces/daterange.interface';
+export * from './models/day.model';
+export * from './models/popover-positions.model';
+export * from './validators/daterange-max.validator';
+export * from './validators/daterange-min.validator';
+export * from './validators/daterange-order.validator';
+export * from './validators/daterange-required.validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY2xyLWFkZG9ucy9kYXRlcmFuZ2VwaWNrZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsNEVBQTRFLENBQUM7QUFDM0YsY0FBYyx3REFBd0QsQ0FBQztBQUN2RSxjQUFjLDJDQUEyQyxDQUFDO0FBQzFELGNBQWMseUNBQXlDLENBQUM7QUFDeEQsY0FBYyxrQ0FBa0MsQ0FBQztBQUNqRCxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsa0NBQWtDLENBQUM7QUFDakQsY0FBYyxzQ0FBc0MsQ0FBQztBQUNyRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsd0NBQXdDLENBQUM7QUFDdkQsY0FBYywyQ0FBMkMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0ZXJhbmdlLmNvbnN0YW50cyc7XG5leHBvcnQgKiBmcm9tICcuL2RhdGVyYW5nZXBpY2tlci5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL2RhdGVyYW5nZXBpY2tlci1jb250YWluZXIvZGF0ZXJhbmdlcGlja2VyLWNvbnRhaW5lci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL2RhdGVyYW5nZXBpY2tlci9kYXRlcmFuZ2VwaWNrZXIuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcy9pZi1kYXRlcmFuZ2UtZXJyb3IuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJmYWNlcy9kYXRlcmFuZ2UtcHJlc2V0LmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL2ludGVyZmFjZXMvZGF0ZXJhbmdlLmludGVyZmFjZSc7XG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9kYXkubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcG9wb3Zlci1wb3NpdGlvbnMubW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi92YWxpZGF0b3JzL2RhdGVyYW5nZS1tYXgudmFsaWRhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vdmFsaWRhdG9ycy9kYXRlcmFuZ2UtbWluLnZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3ZhbGlkYXRvcnMvZGF0ZXJhbmdlLW9yZGVyLnZhbGlkYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL3ZhbGlkYXRvcnMvZGF0ZXJhbmdlLXJlcXVpcmVkLnZhbGlkYXRvcic7XG4iXX0=

package/esm2020/daterangepicker/interfaces/daterange-preset.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXJhbmdlLXByZXNldC5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvY2xyLWFkZG9ucy9kYXRlcmFuZ2VwaWNrZXIvaW50ZXJmYWNlcy9kYXRlcmFuZ2UtcHJlc2V0LmludGVyZmFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGF0ZXJhbmdlIH0gZnJvbSAnLi9kYXRlcmFuZ2UuaW50ZXJmYWNlJztcblxuLyoqXG4gKiBEYXRlcmFuZ2UgcHJlc2V0IGZvciBkYXRlcmFuZ2VwaWNrZXIuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRGF0ZXJhbmdlUHJlc2V0IHtcbiAgdGV4dDogc3RyaW5nO1xuICByYW5nZSgpOiBEYXRlcmFuZ2U7XG59XG4iXX0=

package/esm2020/daterangepicker/interfaces/daterange.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXJhbmdlLmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3NyYy9jbHItYWRkb25zL2RhdGVyYW5nZXBpY2tlci9pbnRlcmZhY2VzL2RhdGVyYW5nZS5pbnRlcmZhY2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE51bGxhYmxlRGF5TW9kZWwgfSBmcm9tICcuLi9tb2RlbHMvZGF5Lm1vZGVsJztcblxuLyoqXG4gKiBEYXRlcmFuZ2UgaW50ZXJmYWNlLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIERhdGVyYW5nZSB7XG4gIGZyb206IE51bGxhYmxlRGF5TW9kZWw7XG4gIHRvOiBOdWxsYWJsZURheU1vZGVsO1xufVxuXG4vKipcbiAqIERhdGVyYW5nZS5cbiAqL1xuZXhwb3J0IHR5cGUgTnVsbGFibGVEYXRlcmFuZ2UgPSBEYXRlcmFuZ2UgfCB1bmRlZmluZWQgfCBudWxsO1xuIl19

package/esm2020/daterangepicker/models/day.model.mjs

@@ -0,0 +1,99 @@
+/**
+ * Day model.
+ * Takes care of keeping records of full days, without the times & timezone issues.
+ */
+export class DayModel {
+    constructor(...args) {
+        if (args[0] instanceof Date) {
+            const date = args[0];
+            this.year = date.getFullYear();
+            this.month = date.getMonth();
+            this.date = date.getDate();
+        }
+        else if (typeof args[0] === 'string') {
+            const [year, month, day] = args[0].split('-').map(n => parseInt(n, 10));
+            this.year = year;
+            this.month = month - 1;
+            this.date = day;
+        }
+        else {
+            this.year = args[0];
+            this.month = args[1];
+            this.date = args[2];
+        }
+    }
+    /**
+     * Checks if the passed value is equal to current day model.
+     * @param value - Day model.
+     * @returns Wether value is equal to current day model.
+     */
+    isEqual(value) {
+        if (value) {
+            return this.year === value.year && this.month === value.month && this.date === value.date;
+        }
+        return false;
+    }
+    /**
+     * Increment day model with date value.
+     * @param value - Incremental date value.
+     * @returns Updated day model with incremented date value.
+     */
+    incrementBy(value) {
+        // Creating new Javascript Date object to increment because
+        // it will automatically take care of switching to next or previous
+        // months & years without we having to worry about it.
+        const date = new Date(this.year, this.month, this.date + value);
+        this.year = date.getFullYear();
+        this.month = date.getMonth();
+        this.date = date.getDate();
+        return this;
+    }
+    /**
+     * Checks if current day model is after value.
+     * @param value - Day model.
+     * @returns Wether current day model is after value.
+     */
+    isAfter(value) {
+        return this.toDate() > value.toDate();
+    }
+    /**
+     * Checks if current day model is before value.
+     * @param value - Day model.
+     * @returns Wether current day model is before value.
+     */
+    isBefore(value) {
+        return this.toDate() < value.toDate();
+    }
+    /**
+     * Clones the current day model.
+     * @returns Cloned day model.
+     */
+    clone() {
+        return new DayModel(this.year, this.month, this.date);
+    }
+    /**
+     * Convert to Javascript Date object.
+     * @returns Javascript Date object.
+     */
+    toDate() {
+        return new Date(this.year, this.month, this.date);
+    }
+    /**
+     * To HTML5 date spec string.
+     * See https://clarity.design/documentation/datepicker
+     * @returns Date as HTML5 spec string.
+     */
+    toHTML5SpecDateString() {
+        // The clarity date picker uses the format 'YYYY-MM-DD'.
+        return `${this.year}-${this.pad(this.month + 1)}-${this.pad(this.date)}`;
+    }
+    /**
+     * String padding with zeros.
+     * @param num - Number to pad.
+     * @returns Padded string.
+     */
+    pad(num) {
+        return num < 10 ? `0${num}` : `${num}`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"day.model.js","sourceRoot":"","sources":["../../../../../src/clr-addons/daterangepicker/models/day.model.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Day model.\n * Takes care of keeping records of full days, without the times & timezone issues.\n */\nexport class DayModel {\n  /** Year. */\n  private year!: number;\n\n  /** Month, zero-indexed. */\n  private month!: number;\n\n  /** Date of the month. */\n  private date!: number;\n\n  /**\n   * Creates an day model.\n   * @param year - The full year.\n   * @param month - The month as a number between 0 and 11 (January to December).\n   * @param date - The date as a number between 1 and 31.\n   */\n  public constructor(year: number, month: number, date: number);\n  /**\n   * Creates an day model.\n   * @param date - Javascript Date object.\n   */\n  public constructor(date: Date);\n  /**\n   * Creates an day model.\n   * @param date - Date string in `yyyy-mm-dd` format.\n   */\n  public constructor(date: string);\n  public constructor(...args: Array<number | Date | string>) {\n    if (args[0] instanceof Date) {\n      const date: Date = args[0];\n      this.year = date.getFullYear();\n      this.month = date.getMonth();\n      this.date = date.getDate();\n    } else if (typeof args[0] === 'string') {\n      const [year, month, day] = args[0].split('-').map(n => parseInt(n, 10));\n      this.year = year;\n      this.month = month - 1;\n      this.date = day;\n    } else {\n      this.year = args[0];\n      this.month = args[1] as number;\n      this.date = args[2] as number;\n    }\n  }\n\n  /**\n   * Checks if the passed value is equal to current day model.\n   * @param value - Day model.\n   * @returns Wether value is equal to current day model.\n   */\n  public isEqual(value: DayModel): boolean {\n    if (value) {\n      return this.year === value.year && this.month === value.month && this.date === value.date;\n    }\n    return false;\n  }\n\n  /**\n   * Increment day model with date value.\n   * @param value - Incremental date value.\n   * @returns Updated day model with incremented date value.\n   */\n  public incrementBy(value: number): DayModel {\n    // Creating new Javascript Date object to increment because\n    // it will automatically take care of switching to next or previous\n    // months & years without we having to worry about it.\n    const date: Date = new Date(this.year, this.month, this.date + value);\n    this.year = date.getFullYear();\n    this.month = date.getMonth();\n    this.date = date.getDate();\n    return this;\n  }\n\n  /**\n   * Checks if current day model is after value.\n   * @param value - Day model.\n   * @returns Wether current day model is after value.\n   */\n  public isAfter(value: DayModel): boolean {\n    return this.toDate() > value.toDate();\n  }\n\n  /**\n   * Checks if current day model is before value.\n   * @param value - Day model.\n   * @returns Wether current day model is before value.\n   */\n  public isBefore(value: DayModel): boolean {\n    return this.toDate() < value.toDate();\n  }\n\n  /**\n   * Clones the current day model.\n   * @returns Cloned day model.\n   */\n  public clone(): DayModel {\n    return new DayModel(this.year, this.month, this.date);\n  }\n\n  /**\n   * Convert to Javascript Date object.\n   * @returns Javascript Date object.\n   */\n  public toDate(): Date {\n    return new Date(this.year, this.month, this.date);\n  }\n\n  /**\n   * To HTML5 date spec string.\n   * See https://clarity.design/documentation/datepicker\n   * @returns Date as HTML5 spec string.\n   */\n  public toHTML5SpecDateString(): string {\n    // The clarity date picker uses the format 'YYYY-MM-DD'.\n    return `${this.year}-${this.pad(this.month + 1)}-${this.pad(this.date)}`;\n  }\n\n  /**\n   * String padding with zeros.\n   * @param num - Number to pad.\n   * @returns Padded string.\n   */\n  private pad(num: number): string {\n    return num < 10 ? `0${num}` : `${num}`;\n  }\n}\n\n/**\n * Day model.\n * Takes care of keeping records of full days, without the times & timezone issues.\n */\nexport type NullableDayModel = DayModel | undefined | null;\n"]}

package/esm2020/daterangepicker/models/popover-positions.model.mjs

@@ -0,0 +1,66 @@
+import { ClrAlignment, ClrAxis, ClrSide } from '@clr/angular';
+/**
+ * Popover positions.
+ * https://github.com/vmware-clarity/ng-clarity/blob/f1a668086bf88bcf5ef1cd36b0d150e45e88def7/projects/angular/src/utils/popover/enums/positions.enum.ts
+ */
+export class PopoverPositions {
+}
+PopoverPositions.options = [
+    'bottom-left',
+    'bottom-right',
+    'left-bottom',
+    'left-top',
+    'right-bottom',
+    'right-top',
+    'top-left',
+    'top-right',
+];
+PopoverPositions['bottom-left'] = {
+    axis: ClrAxis.VERTICAL,
+    side: ClrSide.AFTER,
+    anchor: ClrAlignment.START,
+    content: ClrAlignment.START,
+};
+PopoverPositions['bottom-right'] = {
+    axis: ClrAxis.VERTICAL,
+    side: ClrSide.AFTER,
+    anchor: ClrAlignment.END,
+    content: ClrAlignment.END,
+};
+PopoverPositions['left-bottom'] = {
+    axis: ClrAxis.HORIZONTAL,
+    side: ClrSide.BEFORE,
+    anchor: ClrAlignment.START,
+    content: ClrAlignment.START,
+};
+PopoverPositions['left-top'] = {
+    axis: ClrAxis.HORIZONTAL,
+    side: ClrSide.BEFORE,
+    anchor: ClrAlignment.CENTER,
+    content: ClrAlignment.END,
+};
+PopoverPositions['right-bottom'] = {
+    axis: ClrAxis.HORIZONTAL,
+    side: ClrSide.AFTER,
+    anchor: ClrAlignment.START,
+    content: ClrAlignment.START,
+};
+PopoverPositions['right-top'] = {
+    axis: ClrAxis.HORIZONTAL,
+    side: ClrSide.AFTER,
+    anchor: ClrAlignment.CENTER,
+    content: ClrAlignment.END,
+};
+PopoverPositions['top-left'] = {
+    axis: ClrAxis.VERTICAL,
+    side: ClrSide.BEFORE,
+    anchor: ClrAlignment.START,
+    content: ClrAlignment.START,
+};
+PopoverPositions['top-right'] = {
+    axis: ClrAxis.VERTICAL,
+    side: ClrSide.BEFORE,
+    anchor: ClrAlignment.END,
+    content: ClrAlignment.END,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/providers/daterange-control-state.service.mjs

@@ -0,0 +1,62 @@
+import { EventEmitter, Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Daterange control state service.
+ * Stores data for communication between daterange container and input.
+ */
+export class DaterangeControlStateService {
+    constructor() {
+        /** Disabled control state. */
+        this.disabled = false;
+        /** Focused. */
+        this.focused = false;
+        /** List of validation errors. */
+        this.errors = null;
+        this._invalid = false;
+        this._touched = false;
+        /**
+         * Event triggered when status changes.
+         */
+        this.statusChange = new EventEmitter();
+    }
+    /**
+     * Control invalid status.
+     * @returns Control invalid status.
+     */
+    get invalid() {
+        return this._invalid;
+    }
+    /**
+     * Touched.
+     * @returns Touched.
+     */
+    get touched() {
+        return this._touched;
+    }
+    /**
+     * Update status.
+     * Only for valid & invalid status changes.
+     * And only if there was a real change.
+     * Also updates errors list.
+     * Emits `statusChange` event.
+     * @param control
+     */
+    updateStatus(control) {
+        this._touched = control.touched;
+        // We only care about valid & invalid status changes.
+        // There is an bug where `ClrDaterangepickerDirective.writeValue` is called twice with same value (`null`).
+        // Setting ` && (control.touched || control.dirty)` in next if-statement will hide the errors,
+        // but the control will still be invalid with errors (just hidden).
+        if (['VALID', 'INVALID'].includes(control.status)) {
+            this.errors = control.errors;
+            this._invalid = control.invalid;
+            this.statusChange.emit(this._invalid);
+        }
+    }
+}
+DaterangeControlStateService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeControlStateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+DaterangeControlStateService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeControlStateService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeControlStateService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/providers/daterange-parsing.service.mjs

@@ -0,0 +1,206 @@
+import { FormatWidth, getLocaleDateFormat } from '@angular/common';
+import { Inject, Injectable, LOCALE_ID } from '@angular/core';
+import { BIG_ENDIAN, DELIMITER_REGEX, LITTLE_ENDIAN, LITTLE_ENDIAN_REGEX, MIDDLE_ENDIAN, MIDDLE_ENDIAN_REGEX, SEPARATOR_TEXT_DEFAULT, USER_INPUT_REGEX, } from '../daterange.constants';
+import { DayModel } from '../models/day.model';
+import * as i0 from "@angular/core";
+/**
+ * Daterange parsing service.
+ * Heavy inspired by `date-io.service.ts` from Clarity.
+ * https://github.com/vmware-clarity/ng-clarity/blob/a21fe726fe91ae3c929b8f016359afe354bb89c6/projects/angular/src/forms/datepicker/providers/date-io.service.ts
+ */
+export class DaterangeParsingService {
+    constructor(locale) {
+        this.locale = locale;
+        this.localeDelimiter = [];
+        const localeFormat = getLocaleDateFormat(this.locale, FormatWidth.Short);
+        const format = localeFormat.toLocaleLowerCase();
+        if (LITTLE_ENDIAN_REGEX.test(format)) {
+            this.localeDisplayFormat = LITTLE_ENDIAN;
+        }
+        else if (MIDDLE_ENDIAN_REGEX.test(format)) {
+            this.localeDisplayFormat = MIDDLE_ENDIAN;
+        }
+        else {
+            this.localeDisplayFormat = BIG_ENDIAN;
+        }
+        // Splitting it by date, month and year, leaves us with the delimiters.
+        // E.g. `"dd/MM/y".split(/d+|m+|y+/i)` results in `["", "/", "/", ""]`.
+        const delimiters = localeFormat.split(DELIMITER_REGEX);
+        this.localeDelimiter = [delimiters[1], delimiters[2]];
+    }
+    /** Locale format. */
+    get localeFormat() {
+        return (this.localeDisplayFormat.format[0] +
+            this.localeDelimiter[0] +
+            this.localeDisplayFormat.format[1] +
+            this.localeDelimiter[1] +
+            this.localeDisplayFormat.format[2]);
+    }
+    /**
+     * Convert daterange to locale friendly text.
+     * @param daterange - Daterange.
+     * @param separator - Separator between 'from' and 'to' dates.
+     * @returns Friendly daterange text.
+     */
+    toLocaleString(daterange, separator = SEPARATOR_TEXT_DEFAULT) {
+        if (daterange == null) {
+            return '';
+        }
+        const { from, to } = daterange;
+        if (from == null || to == null) {
+            return '';
+        }
+        const fromDate = from.toDate();
+        const toDate = to.toDate();
+        const fromDateStr = this.toLocaleDisplayFormatString(fromDate);
+        const toDateStr = this.toLocaleDisplayFormatString(toDate);
+        return fromDateStr + separator + toDateStr;
+    }
+    /**
+     * Convert date to locale display format string.
+     * @param date - Javascript Date object.
+     * @returns Locale display format string.
+     */
+    toLocaleDisplayFormatString(date) {
+        const dateNo = date.getDate();
+        const monthNo = date.getMonth() + 1;
+        const yearNo = date.getFullYear();
+        const dateStr = this.pad(dateNo);
+        const monthStr = this.pad(monthNo);
+        const delim1 = this.localeDelimiter[0];
+        const delim2 = this.localeDelimiter[1];
+        if (this.localeDisplayFormat === LITTLE_ENDIAN) {
+            return dateStr + delim1 + monthStr + delim2 + yearNo;
+        }
+        else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {
+            return monthStr + delim1 + dateStr + delim2 + yearNo;
+        }
+        else {
+            return yearNo + delim1 + monthStr + delim2 + dateStr;
+        }
+    }
+    /**
+     * String padding with zeros.
+     * @param num - Number to pad.
+     * @returns Padded string.
+     */
+    pad(num) {
+        return num < 10 ? `0${num}` : `${num}`;
+    }
+    /**
+     * Parse daterange string to daterange object.
+     * @param daterangeString - Daterange string.
+     * @param separator - Separator text.
+     * @returns Daterange object.
+     */
+    parse(daterangeString, separator = SEPARATOR_TEXT_DEFAULT) {
+        if (daterangeString == null || daterangeString === '') {
+            return null;
+        }
+        const [fromString, toString] = daterangeString.split(separator);
+        const from = this.getDayModelFromDateString(fromString);
+        const to = this.getDayModelFromDateString(toString);
+        if (from == null && to == null) {
+            return null;
+        }
+        return { from, to };
+    }
+    /**
+     * Get `DayModel` from date string.
+     * @param dateString - Date string.
+     * @returns DayModel.
+     */
+    getDayModelFromDateString(dateString) {
+        if (dateString == null || dateString === '') {
+            return null;
+        }
+        const dateParts = dateString.match(USER_INPUT_REGEX);
+        if (dateParts == null || dateParts.length !== 3) {
+            return null;
+        }
+        const [firstPart, secondPart, thirdPart] = dateParts;
+        if (this.localeDisplayFormat === LITTLE_ENDIAN) {
+            // secondPart is month && firstPart is date.
+            return this.getDayModelFromDateParts(thirdPart, secondPart, firstPart);
+        }
+        else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {
+            // firstPart is month && secondPart is date.
+            return this.getDayModelFromDateParts(thirdPart, firstPart, secondPart);
+        }
+        else {
+            // secondPart is month && thirdPart is date.
+            return this.getDayModelFromDateParts(firstPart, secondPart, thirdPart);
+        }
+    }
+    /**
+     * Get `DayModel` from date string parts.
+     * @param yearString - Year string.
+     * @param monthString - Month string.
+     * @param dateString - Date string.
+     * @returns DayModel.
+     */
+    getDayModelFromDateParts(yearString, monthString, dateString) {
+        // Check for valid date part strings.
+        let year = parseInt(yearString);
+        if (isNaN(year)) {
+            return null;
+        }
+        let month = parseInt(monthString);
+        if (isNaN(month)) {
+            return null;
+        }
+        const date = parseInt(dateString);
+        if (isNaN(date)) {
+            return null;
+        }
+        // Convert year to 4 digit year.
+        year = this.parseToFourDigitYear(year);
+        if (year == null) {
+            return null;
+        }
+        // Month is zero-indexed.
+        month -= 1;
+        // Creating new Javascript Date object, because it will automatically take care of
+        // switching to next or previous months & years without we having to worry about it.
+        const parsedDate = new Date(year, month, date);
+        if (isNaN(parsedDate.getTime())) {
+            return null;
+        }
+        return new DayModel(parsedDate);
+    }
+    /**
+     * Takes in a year and if it is a 2 digit year, returns the corresponding 4 digit year.
+     * Window of 80 years before and 20 years after the present year.
+     * Credit: https://github.com/globalizejs/globalize/blob/e1b31cd6a4f1cff75b185b68b7a32220aac5196f/src/date/parse.js
+     * @param year - Year.
+     * @returns Four-digit year.
+     */
+    parseToFourDigitYear(year) {
+        // Impossible years.
+        if (year > 9999 || (year > 100 && year < 999) || year < 10) {
+            return null;
+        }
+        if (year > 999) {
+            return year;
+        }
+        const currYear = new Date().getFullYear();
+        const century = Math.floor(currYear / 100) * 100;
+        let result = year + century;
+        if (result > currYear + 20) {
+            result = result - 100;
+        }
+        return result;
+    }
+}
+DaterangeParsingService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeParsingService, deps: [{ token: LOCALE_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+DaterangeParsingService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeParsingService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: DaterangeParsingService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [LOCALE_ID]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterange-parsing.service.js","sourceRoot":"","sources":["../../../../../src/clr-addons/daterangepicker/providers/daterange-parsing.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACnE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9D,OAAO,EACL,UAAU,EACV,eAAe,EAEf,aAAa,EACb,mBAAmB,EACnB,aAAa,EACb,mBAAmB,EACnB,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,QAAQ,EAAoB,MAAM,qBAAqB,CAAC;;AAEjE;;;;GAIG;AAIH,MAAM,OAAO,uBAAuB;IAelC,YAAuD,MAAc;QAAd,WAAM,GAAN,MAAM,CAAQ;QAbrD,oBAAe,GAAkB,EAAE,CAAC;QAclD,MAAM,YAAY,GAAG,mBAAmB,CAAC,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,CAAC,CAAC;QACzE,MAAM,MAAM,GAAW,YAAY,CAAC,iBAAiB,EAAE,CAAC;QAExD,IAAI,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YACpC,IAAI,CAAC,mBAAmB,GAAG,aAAa,CAAC;SAC1C;aAAM,IAAI,mBAAmB,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;YAC3C,IAAI,CAAC,mBAAmB,GAAG,aAAa,CAAC;SAC1C;aAAM;YACL,IAAI,CAAC,mBAAmB,GAAG,UAAU,CAAC;SACvC;QAED,uEAAuE;QACvE,uEAAuE;QACvE,MAAM,UAAU,GAAkB,YAAY,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;QACtE,IAAI,CAAC,eAAe,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACxD,CAAC;IA3BD,qBAAqB;IACrB,IAAW,YAAY;QACrB,OAAO,CACL,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC;YAClC,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC;YACvB,IAAI,CAAC,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,CACnC,CAAC;IACJ,CAAC;IAoBD;;;;;OAKG;IACI,cAAc,CAAC,SAA4B,EAAE,YAAoB,sBAAsB;QAC5F,IAAI,SAAS,IAAI,IAAI,EAAE;YACrB,OAAO,EAAE,CAAC;SACX;QAED,MAAM,EAAE,IAAI,EAAE,EAAE,EAAE,GAAG,SAAS,CAAC;QAC/B,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE;YAC9B,OAAO,EAAE,CAAC;SACX;QAED,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC;QAC/B,MAAM,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,CAAC;QAE3B,MAAM,WAAW,GAAG,IAAI,CAAC,2BAA2B,CAAC,QAAQ,CAAC,CAAC;QAC/D,MAAM,SAAS,GAAG,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;QAE3D,OAAO,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;IAC7C,CAAC;IAED;;;;OAIG;IACK,2BAA2B,CAAC,IAAU;QAC5C,MAAM,MAAM,GAAW,IAAI,CAAC,OAAO,EAAE,CAAC;QACtC,MAAM,OAAO,GAAW,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;QAC5C,MAAM,MAAM,GAAW,IAAI,CAAC,WAAW,EAAE,CAAC;QAE1C,MAAM,OAAO,GAAW,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAW,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAE3C,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QACvC,MAAM,MAAM,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC;QAEvC,IAAI,IAAI,CAAC,mBAAmB,KAAK,aAAa,EAAE;YAC9C,OAAO,OAAO,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;SACtD;aAAM,IAAI,IAAI,CAAC,mBAAmB,KAAK,aAAa,EAAE;YACrD,OAAO,QAAQ,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;SACtD;aAAM;YACL,OAAO,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAC;SACtD;IACH,CAAC;IAED;;;;OAIG;IACK,GAAG,CAAC,GAAW;QACrB,OAAO,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,GAAG,GAAG,EAAE,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACI,KAAK,CAAC,eAAuB,EAAE,YAAoB,sBAAsB;QAC9E,IAAI,eAAe,IAAI,IAAI,IAAI,eAAe,KAAK,EAAE,EAAE;YACrD,OAAO,IAAI,CAAC;SACb;QAED,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC;QAChE,MAAM,IAAI,GAAG,IAAI,CAAC,yBAAyB,CAAC,UAAU,CAAC,CAAC;QACxD,MAAM,EAAE,GAAG,IAAI,CAAC,yBAAyB,CAAC,QAAQ,CAAC,CAAC;QAEpD,IAAI,IAAI,IAAI,IAAI,IAAI,EAAE,IAAI,IAAI,EAAE;YAC9B,OAAO,IAAI,CAAC;SACb;QAED,OAAO,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;IACtB,CAAC;IAED;;;;OAIG;IACK,yBAAyB,CAAC,UAAkB;QAClD,IAAI,UAAU,IAAI,IAAI,IAAI,UAAU,KAAK,EAAE,EAAE;YAC3C,OAAO,IAAI,CAAC;SACb;QAED,MAAM,SAAS,GAAqB,UAAU,CAAC,KAAK,CAAC,gBAAgB,CAAC,CAAC;QACvE,IAAI,SAAS,IAAI,IAAI,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAC/C,OAAO,IAAI,CAAC;SACb;QAED,MAAM,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,GAAG,SAAS,CAAC;QACrD,IAAI,IAAI,CAAC,mBAAmB,KAAK,aAAa,EAAE;YAC9C,4CAA4C;YAC5C,OAAO,IAAI,CAAC,wBAAwB,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;SACxE;aAAM,IAAI,IAAI,CAAC,mBAAmB,KAAK,aAAa,EAAE;YACrD,4CAA4C;YAC5C,OAAO,IAAI,CAAC,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,CAAC,CAAC;SACxE;aAAM;YACL,4CAA4C;YAC5C,OAAO,IAAI,CAAC,wBAAwB,CAAC,SAAS,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;SACxE;IACH,CAAC;IAED;;;;;;OAMG;IACK,wBAAwB,CAAC,UAAkB,EAAE,WAAmB,EAAE,UAAkB;QAC1F,qCAAqC;QACrC,IAAI,IAAI,GAAW,QAAQ,CAAC,UAAU,CAAC,CAAC;QACxC,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;YACf,OAAO,IAAI,CAAC;SACb;QACD,IAAI,KAAK,GAAW,QAAQ,CAAC,WAAW,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,KAAK,CAAC,EAAE;YAChB,OAAO,IAAI,CAAC;SACb;QACD,MAAM,IAAI,GAAW,QAAQ,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,KAAK,CAAC,IAAI,CAAC,EAAE;YACf,OAAO,IAAI,CAAC;SACb;QAED,gCAAgC;QAChC,IAAI,GAAG,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,OAAO,IAAI,CAAC;SACb;QAED,yBAAyB;QACzB,KAAK,IAAI,CAAC,CAAC;QAEX,kFAAkF;QAClF,oFAAoF;QACpF,MAAM,UAAU,GAAG,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;QAC/C,IAAI,KAAK,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,EAAE;YAC/B,OAAO,IAAI,CAAC;SACb;QAED,OAAO,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;OAMG;IACK,oBAAoB,CAAC,IAAY;QACvC,oBAAoB;QACpB,IAAI,IAAI,GAAG,IAAI,IAAI,CAAC,IAAI,GAAG,GAAG,IAAI,IAAI,GAAG,GAAG,CAAC,IAAI,IAAI,GAAG,EAAE,EAAE;YAC1D,OAAO,IAAI,CAAC;SACb;QAED,IAAI,IAAI,GAAG,GAAG,EAAE;YACd,OAAO,IAAI,CAAC;SACb;QAED,MAAM,QAAQ,GAAW,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QAClD,MAAM,OAAO,GAAW,IAAI,CAAC,KAAK,CAAC,QAAQ,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC;QACzD,IAAI,MAAM,GAAW,IAAI,GAAG,OAAO,CAAC;QACpC,IAAI,MAAM,GAAG,QAAQ,GAAG,EAAE,EAAE;YAC1B,MAAM,GAAG,MAAM,GAAG,GAAG,CAAC;SACvB;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;;oHA/MU,uBAAuB,kBAeP,SAAS;wHAfzB,uBAAuB,cAFtB,MAAM;2FAEP,uBAAuB;kBAHnC,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;0BAgBqB,MAAM;2BAAC,SAAS","sourcesContent":["import { FormatWidth, getLocaleDateFormat } from '@angular/common';\nimport { Inject, Injectable, LOCALE_ID } from '@angular/core';\n\nimport {\n  BIG_ENDIAN,\n  DELIMITER_REGEX,\n  InputDateDisplayFormat,\n  LITTLE_ENDIAN,\n  LITTLE_ENDIAN_REGEX,\n  MIDDLE_ENDIAN,\n  MIDDLE_ENDIAN_REGEX,\n  SEPARATOR_TEXT_DEFAULT,\n  USER_INPUT_REGEX,\n} from '../daterange.constants';\nimport { NullableDaterange } from '../interfaces/daterange.interface';\nimport { DayModel, NullableDayModel } from '../models/day.model';\n\n/**\n * Daterange parsing service.\n * Heavy inspired by `date-io.service.ts` from Clarity.\n * https://github.com/vmware-clarity/ng-clarity/blob/a21fe726fe91ae3c929b8f016359afe354bb89c6/projects/angular/src/forms/datepicker/providers/date-io.service.ts\n */\n@Injectable({\n  providedIn: 'root',\n})\nexport class DaterangeParsingService {\n  public readonly localeDisplayFormat: InputDateDisplayFormat;\n  public readonly localeDelimiter: Array<string> = [];\n\n  /** Locale format. */\n  public get localeFormat(): string {\n    return (\n      this.localeDisplayFormat.format[0] +\n      this.localeDelimiter[0] +\n      this.localeDisplayFormat.format[1] +\n      this.localeDelimiter[1] +\n      this.localeDisplayFormat.format[2]\n    );\n  }\n\n  public constructor(@Inject(LOCALE_ID) private readonly locale: string) {\n    const localeFormat = getLocaleDateFormat(this.locale, FormatWidth.Short);\n    const format: string = localeFormat.toLocaleLowerCase();\n\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      this.localeDisplayFormat = BIG_ENDIAN;\n    }\n\n    // Splitting it by date, month and year, leaves us with the delimiters.\n    // E.g. `\"dd/MM/y\".split(/d+|m+|y+/i)` results in `[\"\", \"/\", \"/\", \"\"]`.\n    const delimiters: Array<string> = localeFormat.split(DELIMITER_REGEX);\n    this.localeDelimiter = [delimiters[1], delimiters[2]];\n  }\n\n  /**\n   * Convert daterange to locale friendly text.\n   * @param daterange - Daterange.\n   * @param separator - Separator between 'from' and 'to' dates.\n   * @returns Friendly daterange text.\n   */\n  public toLocaleString(daterange: NullableDaterange, separator: string = SEPARATOR_TEXT_DEFAULT): string {\n    if (daterange == null) {\n      return '';\n    }\n\n    const { from, to } = daterange;\n    if (from == null || to == null) {\n      return '';\n    }\n\n    const fromDate = from.toDate();\n    const toDate = to.toDate();\n\n    const fromDateStr = this.toLocaleDisplayFormatString(fromDate);\n    const toDateStr = this.toLocaleDisplayFormatString(toDate);\n\n    return fromDateStr + separator + toDateStr;\n  }\n\n  /**\n   * Convert date to locale display format string.\n   * @param date - Javascript Date object.\n   * @returns Locale display format string.\n   */\n  private toLocaleDisplayFormatString(date: Date): string {\n    const dateNo: number = date.getDate();\n    const monthNo: number = date.getMonth() + 1;\n    const yearNo: number = date.getFullYear();\n\n    const dateStr: string = this.pad(dateNo);\n    const monthStr: string = this.pad(monthNo);\n\n    const delim1 = this.localeDelimiter[0];\n    const delim2 = this.localeDelimiter[1];\n\n    if (this.localeDisplayFormat === LITTLE_ENDIAN) {\n      return dateStr + delim1 + monthStr + delim2 + yearNo;\n    } else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {\n      return monthStr + delim1 + dateStr + delim2 + yearNo;\n    } else {\n      return yearNo + delim1 + monthStr + delim2 + dateStr;\n    }\n  }\n\n  /**\n   * String padding with zeros.\n   * @param num - Number to pad.\n   * @returns Padded string.\n   */\n  private pad(num: number): string {\n    return num < 10 ? `0${num}` : `${num}`;\n  }\n\n  /**\n   * Parse daterange string to daterange object.\n   * @param daterangeString - Daterange string.\n   * @param separator - Separator text.\n   * @returns Daterange object.\n   */\n  public parse(daterangeString: string, separator: string = SEPARATOR_TEXT_DEFAULT): NullableDaterange {\n    if (daterangeString == null || daterangeString === '') {\n      return null;\n    }\n\n    const [fromString, toString] = daterangeString.split(separator);\n    const from = this.getDayModelFromDateString(fromString);\n    const to = this.getDayModelFromDateString(toString);\n\n    if (from == null && to == null) {\n      return null;\n    }\n\n    return { from, to };\n  }\n\n  /**\n   * Get `DayModel` from date string.\n   * @param dateString - Date string.\n   * @returns DayModel.\n   */\n  private getDayModelFromDateString(dateString: string): NullableDayModel {\n    if (dateString == null || dateString === '') {\n      return null;\n    }\n\n    const dateParts: RegExpMatchArray = dateString.match(USER_INPUT_REGEX);\n    if (dateParts == null || dateParts.length !== 3) {\n      return null;\n    }\n\n    const [firstPart, secondPart, thirdPart] = dateParts;\n    if (this.localeDisplayFormat === LITTLE_ENDIAN) {\n      // secondPart is month && firstPart is date.\n      return this.getDayModelFromDateParts(thirdPart, secondPart, firstPart);\n    } else if (this.localeDisplayFormat === MIDDLE_ENDIAN) {\n      // firstPart is month && secondPart is date.\n      return this.getDayModelFromDateParts(thirdPart, firstPart, secondPart);\n    } else {\n      // secondPart is month && thirdPart is date.\n      return this.getDayModelFromDateParts(firstPart, secondPart, thirdPart);\n    }\n  }\n\n  /**\n   * Get `DayModel` from date string parts.\n   * @param yearString - Year string.\n   * @param monthString - Month string.\n   * @param dateString - Date string.\n   * @returns DayModel.\n   */\n  private getDayModelFromDateParts(yearString: string, monthString: string, dateString: string): NullableDayModel {\n    // Check for valid date part strings.\n    let year: number = parseInt(yearString);\n    if (isNaN(year)) {\n      return null;\n    }\n    let month: number = parseInt(monthString);\n    if (isNaN(month)) {\n      return null;\n    }\n    const date: number = parseInt(dateString);\n    if (isNaN(date)) {\n      return null;\n    }\n\n    // Convert year to 4 digit year.\n    year = this.parseToFourDigitYear(year);\n    if (year == null) {\n      return null;\n    }\n\n    // Month is zero-indexed.\n    month -= 1;\n\n    // Creating new Javascript Date object, because it will automatically take care of\n    // switching to next or previous months & years without we having to worry about it.\n    const parsedDate = new Date(year, month, date);\n    if (isNaN(parsedDate.getTime())) {\n      return null;\n    }\n\n    return new DayModel(parsedDate);\n  }\n\n  /**\n   * Takes in a year and if it is a 2 digit year, returns the corresponding 4 digit year.\n   * Window of 80 years before and 20 years after the present year.\n   * Credit: https://github.com/globalizejs/globalize/blob/e1b31cd6a4f1cff75b185b68b7a32220aac5196f/src/date/parse.js\n   * @param year - Year.\n   * @returns Four-digit year.\n   */\n  private parseToFourDigitYear(year: number): number | null {\n    // Impossible years.\n    if (year > 9999 || (year > 100 && year < 999) || year < 10) {\n      return null;\n    }\n\n    if (year > 999) {\n      return year;\n    }\n\n    const currYear: number = new Date().getFullYear();\n    const century: number = Math.floor(currYear / 100) * 100;\n    let result: number = year + century;\n    if (result > currYear + 20) {\n      result = result - 100;\n    }\n    return result;\n  }\n}\n"]}