@ptsecurity/mosaic 12.3.0 → 13.1.1

package/esm2020/core/formatters/date/formatter.mjs

@@ -0,0 +1,359 @@
+// tslint:disable:no-magic-numbers
+import { Inject, Injectable } from '@angular/core';
+// tslint:disable:import-name
+import MessageFormat from '@messageformat/core';
+import { DateAdapter, MC_DATE_LOCALE } from '@ptsecurity/cdk/datetime';
+import { enUS } from './templates/en-US';
+import { ruRU } from './templates/ru-RU';
+import * as i0 from "@angular/core";
+import * as i1 from "@ptsecurity/cdk/datetime";
+export class DateFormatter {
+    constructor(adapter, locale) {
+        this.adapter = adapter;
+        this.invalidDateErrorText = 'Invalid date';
+        this.config = locale === 'en' ? enUS : ruRU;
+        this.messageFormat = new MessageFormat(locale);
+    }
+    setLocale(locale) {
+        this.config = locale === 'en' ? enUS : ruRU;
+        this.adapter.setLocale(locale);
+    }
+    /**
+     * @param date - date
+     * @param template - template
+     * @returns relative date by template
+     */
+    relativeDate(date, template, seconds = false, milliseconds = false) {
+        if (!this.adapter.isDateInstance(date)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        let newTemplate;
+        const templateVariables = { ...this.adapter.config.variables, ...template.variables };
+        if (this.isBeforeYesterday(date)) {
+            newTemplate = template.BEFORE_YESTERDAY;
+        }
+        else if (this.isYesterday(date)) {
+            newTemplate = template.YESTERDAY;
+        }
+        else if (this.isToday(date)) {
+            newTemplate = template.TODAY;
+        }
+        else if (this.isTomorrow(date)) {
+            newTemplate = template.TOMORROW;
+        }
+        else if (this.isAfterTomorrow(date)) {
+            newTemplate = template.AFTER_TOMORROW;
+        }
+        const variables = this.compileVariables(date, templateVariables);
+        variables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+        variables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+        return this.messageFormat.compile(newTemplate)(variables);
+    }
+    /**
+     * @param date - date
+     * @returns relative date in short format
+     */
+    relativeShortDate(date) {
+        return this.relativeDate(date, this.config.relativeTemplates.short);
+    }
+    /**
+     * @param date - date
+     * @returns relative date in long format
+     */
+    relativeLongDate(date) {
+        return this.relativeDate(date, this.config.relativeTemplates.long);
+    }
+    /**
+     * @param date - date
+     * @param options - DateTimeOptions
+     * @returns relative date in short format with time
+     */
+    relativeShortDateTime(date, options) {
+        return this.relativeDate(date, this.config.relativeTemplates.short, options?.seconds, options?.milliseconds);
+    }
+    /**
+     * @param date - date
+     * @param options - DateTimeOptions
+     * @returns relative date in long format with time
+     */
+    relativeLongDateTime(date, options) {
+        return this.relativeDate(date, this.config.relativeTemplates.long, options?.seconds, options?.milliseconds);
+    }
+    /**
+     * @param date - date
+     * @param params - parameters
+     * @param datetime - should time be shown as well
+     * @param seconds - should time with seconds be shown as well
+     * @param milliseconds - should time with milliseconds be shown as well
+     * @returns absolute date in common format
+     */
+    absoluteDate(date, params, datetime = false, seconds = false, milliseconds = false) {
+        if (!this.adapter.isDateInstance(date)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        const variables = this.compileVariables(date, { ...this.adapter.config.variables, ...params.variables });
+        variables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+        variables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+        const template = datetime ? params.DATETIME : params.DATE;
+        return this.messageFormat.compile(template)(variables);
+    }
+    /**
+     * @param date - date
+     * @returns absolute date in short format
+     */
+    absoluteShortDate(date) {
+        return this.absoluteDate(date, this.config.absoluteTemplates.short);
+    }
+    /**
+     * @param date - date
+     * @param options - DateTimeOptions
+     * @returns absolute date in short format with time
+     */
+    absoluteShortDateTime(date, options) {
+        return this.absoluteDate(date, this.config.absoluteTemplates.short, true, options?.seconds, options?.milliseconds);
+    }
+    /**
+     * @param date - date
+     * @returns absolute date in long format
+     */
+    absoluteLongDate(date) {
+        return this.absoluteDate(date, this.config.absoluteTemplates.long);
+    }
+    /**
+     * @param date - date
+     * @param options - DateTimeOptions
+     * @returns absolute date in long format with time
+     */
+    absoluteLongDateTime(date, options) {
+        return this.absoluteDate(date, this.config.absoluteTemplates.long, true, options?.seconds, options?.milliseconds);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param template - template
+     * @returns opened date
+     */
+    openedRangeDate(startDate, endDate, template) {
+        if (!this.adapter.isDateInstance(startDate) && !this.adapter.isDateInstance(endDate)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        const variables = { ...this.adapter.config.variables, ...template.variables };
+        let params = {};
+        if (startDate) {
+            const startDateVariables = this.compileVariables(startDate, variables);
+            params = {
+                ...variables,
+                START_DATE: this.messageFormat.compile(template.START_DATE)(startDateVariables),
+                RANGE_TYPE: 'onlyStart'
+            };
+        }
+        else if (endDate) {
+            const endDateVariables = this.compileVariables(endDate, variables);
+            params = {
+                ...variables,
+                END_DATE: this.messageFormat.compile(template.END_DATE)(endDateVariables),
+                RANGE_TYPE: 'onlyEnd'
+            };
+        }
+        return this.messageFormat.compile(template.DATE)(params);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param template - template
+     * @param seconds - should time with seconds be shown as well
+     * @param milliseconds - should time with milliseconds be shown as well
+     * @returns opened date
+     */
+    openedRangeDateTime(startDate, endDate, template, seconds = false, milliseconds = false) {
+        if (!this.adapter.isDateInstance(startDate) && !this.adapter.isDateInstance(endDate)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        const variables = { ...this.adapter.config.variables, ...template.variables };
+        let params = {};
+        if (startDate) {
+            const startDateVariables = this.compileVariables(startDate, variables);
+            startDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+            startDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+            params = {
+                ...variables,
+                START_DATETIME: this.messageFormat.compile(template.START_DATETIME)(startDateVariables),
+                RANGE_TYPE: 'onlyStart'
+            };
+        }
+        else if (endDate) {
+            const endDateVariables = this.compileVariables(endDate, variables);
+            endDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+            endDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+            params = {
+                ...variables,
+                END_DATETIME: this.messageFormat.compile(template.END_DATETIME)(endDateVariables),
+                RANGE_TYPE: 'onlyEnd'
+            };
+        }
+        return this.messageFormat.compile(template.DATETIME)(params);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param template - template
+     * @returns range date in template format
+     */
+    rangeDate(startDate, endDate, template) {
+        if (!this.adapter.isDateInstance(startDate) || !this.adapter.isDateInstance(endDate)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        const variables = { ...this.adapter.config.variables, ...template.variables };
+        const sameMonth = this.hasSame(startDate, endDate, 'month');
+        const startDateVariables = this.compileVariables(startDate, variables);
+        startDateVariables.SAME_MONTH = sameMonth;
+        const endDateVariables = this.compileVariables(endDate, variables);
+        endDateVariables.SAME_MONTH = sameMonth;
+        const bothCurrentYear = startDateVariables.CURRENT_YEAR === 'yes' && endDateVariables.CURRENT_YEAR === 'yes';
+        startDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';
+        endDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';
+        const params = {
+            ...variables,
+            START_DATE: this.messageFormat.compile(template.START_DATE)(startDateVariables),
+            END_DATE: this.messageFormat.compile(template.END_DATE)(endDateVariables),
+            SAME_MONTH: sameMonth
+        };
+        return this.messageFormat.compile(template.DATE)(params);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param template - template
+     * @returns range date in template format with time
+     */
+    rangeDateTime(startDate, endDate, template, seconds = false, milliseconds = false) {
+        if (!this.adapter.isDateInstance(startDate) || !this.adapter.isDateInstance(endDate)) {
+            throw new Error(this.invalidDateErrorText);
+        }
+        const variables = { ...this.adapter.config.variables, ...template.variables };
+        const sameMonth = this.hasSame(startDate, endDate, 'month');
+        const sameDay = this.hasSame(startDate, endDate, 'day');
+        const startDateVariables = this.compileVariables(startDate, variables);
+        startDateVariables.SAME_MONTH = sameMonth;
+        startDateVariables.SAME_DAY = sameDay;
+        startDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+        startDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+        const endDateVariables = this.compileVariables(endDate, variables);
+        endDateVariables.SAME_MONTH = sameMonth;
+        endDateVariables.SAME_DAY = sameDay;
+        endDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';
+        endDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';
+        const bothCurrentYear = startDateVariables.CURRENT_YEAR === 'yes' && endDateVariables.CURRENT_YEAR === 'yes';
+        startDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';
+        endDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';
+        const params = {
+            ...variables,
+            START_DATETIME: this.messageFormat.compile(template.START_DATETIME)(startDateVariables),
+            END_DATETIME: this.messageFormat.compile(template.END_DATETIME)(endDateVariables),
+            SAME_MONTH: sameMonth,
+            SAME_DAY: sameDay
+        };
+        return this.messageFormat.compile(template.DATETIME)(params);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @returns range date in short format
+     */
+    rangeShortDate(startDate, endDate) {
+        const rangeTemplates = this.config.rangeTemplates;
+        if (startDate && endDate) {
+            return this.rangeDate(startDate, endDate, rangeTemplates.closedRange.short);
+        }
+        return this.openedRangeDate(startDate, endDate || null, rangeTemplates.openedRange.short);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param options - DateTimeOptions
+     * @returns range date in short format with time
+     */
+    rangeShortDateTime(startDate, endDate, options) {
+        const rangeTemplates = this.config.rangeTemplates;
+        if (startDate && endDate) {
+            return this.rangeDateTime(startDate, endDate, rangeTemplates.closedRange.short, options?.seconds, options?.milliseconds);
+        }
+        return this.openedRangeDateTime(startDate, endDate || null, rangeTemplates.openedRange.short, options?.seconds, options?.milliseconds);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @returns range date in long format
+     */
+    rangeLongDate(startDate, endDate) {
+        const rangeTemplates = this.config.rangeTemplates;
+        if (startDate && endDate) {
+            return this.rangeDate(startDate, endDate, rangeTemplates.closedRange.long);
+        }
+        return this.openedRangeDate(startDate, endDate || null, rangeTemplates.openedRange.long);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param options - DateTimeOptions
+     * @returns range date in long format with time
+     */
+    rangeLongDateTime(startDate, endDate, options) {
+        const rangeTemplates = this.config.rangeTemplates;
+        if (startDate && endDate) {
+            return this.rangeDateTime(startDate, endDate, rangeTemplates.closedRange.long, options?.seconds, options?.milliseconds);
+        }
+        return this.openedRangeDateTime(startDate, endDate || null, rangeTemplates.openedRange.long);
+    }
+    /**
+     * @param startDate - start date
+     * @param endDate - end date
+     * @param options - DateTimeOptions
+     * @returns range middle date with time
+     */
+    rangeMiddleDateTime(startDate, endDate, options) {
+        return this.rangeDateTime(startDate, endDate, this.config.rangeTemplates.closedRange.middle, options?.seconds, options?.milliseconds);
+    }
+    compileVariables(date, variables) {
+        const compiledVariables = {};
+        // tslint:disable-next-line:no-for-in
+        for (const key in variables) {
+            if (!variables.hasOwnProperty(key)) {
+                continue;
+            }
+            const value = variables[key];
+            compiledVariables[key] = this.adapter.format(date, value);
+        }
+        compiledVariables.CURRENT_YEAR = this.hasSame(date, this.adapter.today(), 'year');
+        return compiledVariables;
+    }
+    isBeforeYesterday(date) {
+        return this.adapter.daysFromToday(date) <= -2;
+    }
+    isYesterday(date) {
+        const interval = this.adapter.daysFromToday(date);
+        return interval > -2 && interval <= -1;
+    }
+    isToday(date) {
+        return this.adapter.daysFromToday(date) === 0;
+    }
+    isTomorrow(date) {
+        const interval = this.adapter.daysFromToday(date);
+        return interval >= 1 && interval < 2;
+    }
+    isAfterTomorrow(date) {
+        return this.adapter.daysFromToday(date) >= 2;
+    }
+    hasSame(startDate, endDate, unit) {
+        return this.adapter.hasSame(startDate, endDate, unit) ? 'yes' : 'no';
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DateFormatter.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DateFormatter, deps: [{ token: i1.DateAdapter }, { token: MC_DATE_LOCALE }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DateFormatter.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DateFormatter });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DateFormatter, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.DateAdapter }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MC_DATE_LOCALE]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"formatter.js","sourceRoot":"","sources":["../../../../../../packages/mosaic/core/formatters/date/formatter.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable:no-magic-numbers\nimport { Inject, Injectable } from '@angular/core';\n// tslint:disable:import-name\nimport MessageFormat from '@messageformat/core';\nimport { DateAdapter, MC_DATE_LOCALE } from '@ptsecurity/cdk/datetime';\n\nimport { enUS } from './templates/en-US';\nimport { ruRU } from './templates/ru-RU';\n\n\n/**\n * interface for absolute date or datetime formatter template\n */\n// tslint:disable-next-line:naming-convention\nexport interface FormatterAbsoluteTemplate {\n    variables?: { [name: string]: string };\n    DATE: string;\n    DATETIME: string;\n}\n\n/**\n * interface for range date or datetime formatter template\n */\n// tslint:disable-next-line:naming-convention\nexport interface FormatterRangeTemplate {\n    variables?: { [name: string]: string };\n    START_DATE: string;\n    END_DATE: string;\n    DATE: string;\n    START_DATETIME: string;\n    END_DATETIME: string;\n    DATETIME: string;\n}\n\n/**\n * interface for relative date or datetime formatter template\n */\n// tslint:disable-next-line:naming-convention\nexport interface FormatterRelativeTemplate {\n    variables?: { [name: string]: string };\n    BEFORE_YESTERDAY: string;\n    YESTERDAY: string;\n    TODAY: string;\n    TOMORROW: string;\n    AFTER_TOMORROW: string;\n}\n\n// tslint:disable-next-line:naming-convention\nexport interface DateTimeOptions {\n    seconds?: boolean;\n    milliseconds?: boolean;\n}\n\n// tslint:disable-next-line:naming-convention\nexport interface FormatterConfig {\n    relativeTemplates: {\n        short: FormatterRelativeTemplate;\n        long: FormatterRelativeTemplate;\n    };\n    absoluteTemplates: {\n        short: FormatterAbsoluteTemplate;\n        long: FormatterAbsoluteTemplate;\n    };\n    rangeTemplates: {\n        closedRange: {\n            short: FormatterRangeTemplate;\n            middle: FormatterRangeTemplate;\n            long: FormatterRangeTemplate;\n        };\n        openedRange: {\n            short: FormatterRangeTemplate;\n            long: FormatterRangeTemplate;\n        };\n    };\n}\n\n\n@Injectable()\nexport class DateFormatter<D> {\n    config: FormatterConfig;\n\n    private readonly invalidDateErrorText: string = 'Invalid date';\n\n    private messageFormat: MessageFormat;\n\n    constructor(\n        private readonly adapter: DateAdapter<D>,\n        @Inject(MC_DATE_LOCALE) locale: string\n    ) {\n        this.config = locale === 'en' ? enUS : ruRU;\n\n        this.messageFormat = new MessageFormat(locale);\n    }\n\n    setLocale(locale: string): void {\n        this.config = locale === 'en' ? enUS : ruRU;\n\n        this.adapter.setLocale(locale);\n    }\n\n    /**\n     * @param date - date\n     * @param template - template\n     * @returns relative date by template\n     */\n    relativeDate(\n        date: D,\n        template: FormatterRelativeTemplate,\n        seconds = false,\n        milliseconds = false\n    ): string {\n        if (!this.adapter.isDateInstance(date)) { throw new Error(this.invalidDateErrorText); }\n\n        let newTemplate;\n\n        const templateVariables = {...this.adapter.config.variables, ...template.variables};\n\n        if (this.isBeforeYesterday(date)) {\n            newTemplate = template.BEFORE_YESTERDAY;\n        } else if (this.isYesterday(date)) {\n            newTemplate = template.YESTERDAY;\n        } else if (this.isToday(date)) {\n            newTemplate = template.TODAY;\n        } else if (this.isTomorrow(date)) {\n            newTemplate = template.TOMORROW;\n        } else if (this.isAfterTomorrow(date)) {\n            newTemplate = template.AFTER_TOMORROW;\n        }\n\n        const variables = this.compileVariables(date, templateVariables);\n\n        variables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n        variables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n        return this.messageFormat.compile(newTemplate)(variables);\n    }\n\n    /**\n     * @param date - date\n     * @returns relative date in short format\n     */\n    relativeShortDate(date: D): string {\n        return this.relativeDate(date, this.config.relativeTemplates.short);\n    }\n\n    /**\n     * @param date - date\n     * @returns relative date in long format\n     */\n    relativeLongDate(date: D): string {\n        return this.relativeDate(date, this.config.relativeTemplates.long);\n    }\n\n    /**\n     * @param date - date\n     * @param options - DateTimeOptions\n     * @returns relative date in short format with time\n     */\n    relativeShortDateTime(date: D, options?: DateTimeOptions): string {\n        return this.relativeDate(date, this.config.relativeTemplates.short, options?.seconds, options?.milliseconds);\n    }\n\n    /**\n     * @param date - date\n     * @param options - DateTimeOptions\n     * @returns relative date in long format with time\n     */\n    relativeLongDateTime(date: D, options?: DateTimeOptions): string {\n        return this.relativeDate(date, this.config.relativeTemplates.long, options?.seconds, options?.milliseconds);\n    }\n\n    /**\n     * @param date - date\n     * @param params - parameters\n     * @param datetime - should time be shown as well\n     * @param seconds - should time with seconds be shown as well\n     * @param milliseconds - should time with milliseconds be shown as well\n     * @returns absolute date in common format\n     */\n    absoluteDate(\n        date: D,\n        params: FormatterAbsoluteTemplate,\n        datetime = false,\n        seconds = false,\n        milliseconds = false\n    ): string {\n        if (!this.adapter.isDateInstance(date)) { throw new Error(this.invalidDateErrorText); }\n\n        const variables = this.compileVariables(date, { ...this.adapter.config.variables, ...params.variables });\n\n        variables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n        variables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n        const template = datetime ? params.DATETIME : params.DATE;\n\n        return this.messageFormat.compile(template)(variables);\n    }\n\n    /**\n     * @param date - date\n     * @returns absolute date in short format\n     */\n    absoluteShortDate(date: D): string {\n        return this.absoluteDate(date, this.config.absoluteTemplates.short);\n    }\n\n    /**\n     * @param date - date\n     * @param options - DateTimeOptions\n     * @returns absolute date in short format with time\n     */\n    absoluteShortDateTime(date: D, options?: DateTimeOptions): string {\n        return this.absoluteDate(date, this.config.absoluteTemplates.short, true, options?.seconds, options?.milliseconds);\n    }\n\n    /**\n     * @param date - date\n     * @returns absolute date in long format\n     */\n    absoluteLongDate(date: D): string {\n        return this.absoluteDate(date, this.config.absoluteTemplates.long);\n    }\n\n    /**\n     * @param date - date\n     * @param options - DateTimeOptions\n     * @returns absolute date in long format with time\n     */\n    absoluteLongDateTime(date: D, options?: DateTimeOptions): string {\n        return this.absoluteDate(date, this.config.absoluteTemplates.long, true, options?.seconds, options?.milliseconds);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param template - template\n     * @returns opened date\n     */\n    openedRangeDate(startDate: D | null, endDate: D | null, template: FormatterRangeTemplate) {\n        if (!this.adapter.isDateInstance(startDate) && !this.adapter.isDateInstance(endDate)) {\n            throw new Error(this.invalidDateErrorText);\n        }\n\n        const variables = { ...this.adapter.config.variables, ...template.variables };\n        let params = {};\n\n        if (startDate) {\n            const startDateVariables = this.compileVariables(startDate, variables);\n\n            params = {\n                ...variables,\n                START_DATE: this.messageFormat.compile(template.START_DATE)(startDateVariables),\n                RANGE_TYPE: 'onlyStart'\n            };\n        } else if (endDate) {\n            const endDateVariables = this.compileVariables(endDate, variables);\n\n            params = {\n                ...variables,\n                END_DATE: this.messageFormat.compile(template.END_DATE)(endDateVariables),\n                RANGE_TYPE: 'onlyEnd'\n            };\n        }\n\n        return this.messageFormat.compile(template.DATE)(params);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param template - template\n     * @param seconds - should time with seconds be shown as well\n     * @param milliseconds - should time with milliseconds be shown as well\n     * @returns opened date\n     */\n    openedRangeDateTime(\n        startDate: D | null,\n        endDate: D | null,\n        template: FormatterRangeTemplate,\n        seconds = false,\n        milliseconds = false\n    ) {\n        if (!this.adapter.isDateInstance(startDate) && !this.adapter.isDateInstance(endDate)) {\n            throw new Error(this.invalidDateErrorText);\n        }\n\n        const variables = { ...this.adapter.config.variables, ...template.variables };\n        let params = {};\n\n        if (startDate) {\n            const startDateVariables = this.compileVariables(startDate, variables);\n            startDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n            startDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n            params = {\n                ...variables,\n                START_DATETIME: this.messageFormat.compile(template.START_DATETIME)(startDateVariables),\n                RANGE_TYPE: 'onlyStart'\n            };\n        } else if (endDate) {\n            const endDateVariables = this.compileVariables(endDate, variables);\n            endDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n            endDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n            params = {\n                ...variables,\n                END_DATETIME: this.messageFormat.compile(template.END_DATETIME)(endDateVariables),\n                RANGE_TYPE: 'onlyEnd'\n            };\n        }\n\n        return this.messageFormat.compile(template.DATETIME)(params);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param template - template\n     * @returns range date in template format\n     */\n    rangeDate(startDate: D, endDate: D, template: FormatterRangeTemplate): string {\n        if (!this.adapter.isDateInstance(startDate) || !this.adapter.isDateInstance(endDate)) {\n            throw new Error(this.invalidDateErrorText);\n        }\n\n        const variables = { ...this.adapter.config.variables, ...template.variables };\n        const sameMonth = this.hasSame(startDate, endDate, 'month');\n\n        const startDateVariables = this.compileVariables(startDate, variables);\n        startDateVariables.SAME_MONTH = sameMonth;\n\n        const endDateVariables = this.compileVariables(endDate, variables);\n        endDateVariables.SAME_MONTH = sameMonth;\n\n        const bothCurrentYear = startDateVariables.CURRENT_YEAR === 'yes' && endDateVariables.CURRENT_YEAR === 'yes';\n        startDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';\n        endDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';\n\n        const params = {\n            ...variables,\n            START_DATE: this.messageFormat.compile(template.START_DATE)(startDateVariables),\n            END_DATE: this.messageFormat.compile(template.END_DATE)(endDateVariables),\n            SAME_MONTH: sameMonth\n        };\n\n        return this.messageFormat.compile(template.DATE)(params);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param template - template\n     * @returns range date in template format with time\n     */\n    rangeDateTime(startDate: D, endDate: D, template: FormatterRangeTemplate, seconds = false, milliseconds = false): string {\n        if (!this.adapter.isDateInstance(startDate) || !this.adapter.isDateInstance(endDate)) {\n            throw new Error(this.invalidDateErrorText);\n        }\n\n        const variables = {...this.adapter.config.variables, ...template.variables};\n\n        const sameMonth = this.hasSame(startDate, endDate, 'month');\n        const sameDay = this.hasSame(startDate, endDate, 'day');\n\n        const startDateVariables = this.compileVariables(startDate, variables);\n        startDateVariables.SAME_MONTH = sameMonth;\n        startDateVariables.SAME_DAY = sameDay;\n        startDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n        startDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n        const endDateVariables = this.compileVariables(endDate, variables);\n        endDateVariables.SAME_MONTH = sameMonth;\n        endDateVariables.SAME_DAY = sameDay;\n        endDateVariables.SHOW_SECONDS = seconds ? 'yes' : 'no';\n        endDateVariables.SHOW_MILLISECONDS = milliseconds ? 'yes' : 'no';\n\n        const bothCurrentYear = startDateVariables.CURRENT_YEAR === 'yes' && endDateVariables.CURRENT_YEAR === 'yes';\n        startDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';\n        endDateVariables.CURRENT_YEAR = bothCurrentYear ? 'yes' : 'no';\n\n        const params = {\n            ...variables,\n            START_DATETIME: this.messageFormat.compile(template.START_DATETIME)(startDateVariables),\n            END_DATETIME: this.messageFormat.compile(template.END_DATETIME)(endDateVariables),\n            SAME_MONTH: sameMonth,\n            SAME_DAY: sameDay\n        };\n\n        return this.messageFormat.compile(template.DATETIME)(params);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @returns range date in short format\n     */\n    rangeShortDate(startDate: D | null, endDate?: D): string {\n        const rangeTemplates = this.config.rangeTemplates;\n\n        if (startDate && endDate) {\n            return this.rangeDate(startDate, endDate, rangeTemplates.closedRange.short);\n        }\n\n        return this.openedRangeDate(startDate, endDate || null, rangeTemplates.openedRange.short);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param options - DateTimeOptions\n     * @returns range date in short format with time\n     */\n    rangeShortDateTime(startDate: D | null, endDate?: D | null, options?: DateTimeOptions): string {\n        const rangeTemplates = this.config.rangeTemplates;\n\n        if (startDate && endDate) {\n            return this.rangeDateTime(startDate, endDate, rangeTemplates.closedRange.short, options?.seconds, options?.milliseconds);\n        }\n\n        return this.openedRangeDateTime(\n            startDate,\n            endDate || null,\n            rangeTemplates.openedRange.short,\n            options?.seconds,\n            options?.milliseconds\n        );\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @returns range date in long format\n     */\n    rangeLongDate(startDate: D | null, endDate?: D | null): string {\n        const rangeTemplates = this.config.rangeTemplates;\n\n        if (startDate && endDate) {\n            return this.rangeDate(startDate, endDate, rangeTemplates.closedRange.long);\n        }\n\n        return this.openedRangeDate(startDate, endDate || null, rangeTemplates.openedRange.long);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param options - DateTimeOptions\n     * @returns range date in long format with time\n     */\n    rangeLongDateTime(startDate: D | null, endDate?: D, options?: DateTimeOptions): string {\n        const rangeTemplates = this.config.rangeTemplates;\n\n        if (startDate && endDate) {\n            return this.rangeDateTime(startDate, endDate, rangeTemplates.closedRange.long, options?.seconds, options?.milliseconds);\n        }\n\n        return this.openedRangeDateTime(startDate, endDate || null, rangeTemplates.openedRange.long);\n    }\n\n    /**\n     * @param startDate - start date\n     * @param endDate - end date\n     * @param options - DateTimeOptions\n     * @returns range middle date with time\n     */\n    rangeMiddleDateTime(startDate: D, endDate: D, options?: DateTimeOptions): string {\n        return this.rangeDateTime(\n            startDate,\n            endDate,\n            this.config.rangeTemplates.closedRange.middle,\n            options?.seconds,\n            options?.milliseconds\n        );\n    }\n\n    private compileVariables(date: D, variables: any): any {\n        const compiledVariables: any = {};\n\n        // tslint:disable-next-line:no-for-in\n        for (const key in variables) {\n            if (!variables.hasOwnProperty(key)) { continue; }\n\n            const value = variables[key];\n            compiledVariables[key] = this.adapter.format(date, value);\n        }\n\n        compiledVariables.CURRENT_YEAR = this.hasSame(date, this.adapter.today(), 'year');\n\n        return compiledVariables;\n    }\n\n    private isBeforeYesterday(date: D): boolean {\n        return this.adapter.daysFromToday(date) <= -2;\n    }\n\n    private isYesterday(date: D): boolean {\n        const interval = this.adapter.daysFromToday(date);\n\n        return interval > -2 && interval <= -1;\n    }\n\n    private isToday(date: D): boolean {\n        return this.adapter.daysFromToday(date) === 0;\n    }\n\n    private isTomorrow(date: any): boolean {\n        const interval = this.adapter.daysFromToday(date);\n\n        return interval >= 1 && interval < 2;\n    }\n\n    private isAfterTomorrow(date: D): boolean {\n        return this.adapter.daysFromToday(date) >= 2;\n    }\n\n    private hasSame(startDate: D, endDate: D, unit: string): string {\n        return this.adapter.hasSame(startDate, endDate, unit) ? 'yes' : 'no';\n    }\n}\n"]}