@ascentgl/ads-ui 0.0.1

package/esm2022/lib/components/form-fields/datepickers/date-picker/datepicker.module.mjs

@@ -0,0 +1,87 @@
+import { NgModule } from '@angular/core';
+import { DateAdapter, MatNativeDateModule } from '@angular/material/core';
+import { MatFormFieldModule } from '@angular/material/form-field';
+import { MatInputModule } from '@angular/material/input';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { ReactiveFormsModule } from '@angular/forms';
+import { AdsIconModule } from '@ascentgl/ads-icons';
+import { MatDatetimepickerModule } from '@mat-datetimepicker/core';
+import { MatIconModule } from '@angular/material/icon';
+import { CommonModule } from '@angular/common';
+import { AdsDatepickerComponent } from './datepicker.component';
+import { DateTimePickerFormatDirectiveModule } from '../datetime-picker/datetime-picker-format-directive';
+import { AdsInputTooltipComponent } from '../../common/input.tooltip.component';
+import { CustomDatetimeAdapter } from '../datetime-picker/custom-datetime.adapter';
+import { MatIconButton } from '@angular/material/button';
+import { AdsErrorComponent } from '../../common/error/error.component';
+import { AdsHintComponent } from '../../common/hint/hint.component';
+import { AdsSuccessComponent } from '../../common/success/success.component';
+import * as i0 from "@angular/core";
+export class AdsDatepickerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDatepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: AdsDatepickerModule, declarations: [AdsDatepickerComponent], imports: [CommonModule,
+            MatDatepickerModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatNativeDateModule,
+            ReactiveFormsModule,
+            AdsIconModule,
+            MatDatetimepickerModule,
+            MatIconModule,
+            DateTimePickerFormatDirectiveModule,
+            AdsInputTooltipComponent,
+            MatIconButton,
+            AdsErrorComponent,
+            AdsHintComponent,
+            AdsSuccessComponent], exports: [AdsDatepickerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDatepickerModule, providers: [
+            {
+                provide: DateAdapter,
+                useClass: CustomDatetimeAdapter,
+            },
+        ], imports: [CommonModule,
+            MatDatepickerModule,
+            MatFormFieldModule,
+            MatInputModule,
+            MatNativeDateModule,
+            ReactiveFormsModule,
+            AdsIconModule,
+            MatDatetimepickerModule,
+            MatIconModule,
+            DateTimePickerFormatDirectiveModule,
+            AdsInputTooltipComponent,
+            MatIconButton,
+            AdsErrorComponent,
+            AdsSuccessComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: AdsDatepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        MatDatepickerModule,
+                        MatFormFieldModule,
+                        MatInputModule,
+                        MatNativeDateModule,
+                        ReactiveFormsModule,
+                        AdsIconModule,
+                        MatDatetimepickerModule,
+                        MatIconModule,
+                        DateTimePickerFormatDirectiveModule,
+                        AdsInputTooltipComponent,
+                        MatIconButton,
+                        AdsErrorComponent,
+                        AdsHintComponent,
+                        AdsSuccessComponent,
+                    ],
+                    declarations: [AdsDatepickerComponent],
+                    exports: [AdsDatepickerComponent],
+                    providers: [
+                        {
+                            provide: DateAdapter,
+                            useClass: CustomDatetimeAdapter,
+                        },
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-fields/datepickers/date-picker/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9saWJzL2Fkcy11aS9zcmMvbGliL2NvbXBvbmVudHMvZm9ybS1maWVsZHMvZGF0ZXBpY2tlcnMvZGF0ZS1waWNrZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3B1YmxpYy1hcGknO1xuIl19

package/esm2022/lib/components/form-fields/datepickers/date-picker/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './datepicker.component';
+export * from './datepicker.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYWRzLXVpL3NyYy9saWIvY29tcG9uZW50cy9mb3JtLWZpZWxkcy9kYXRlcGlja2Vycy9kYXRlLXBpY2tlci9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0JBQXdCLENBQUM7QUFDdkMsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZGF0ZXBpY2tlci5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRlcGlja2VyLm1vZHVsZSc7XG4iXX0=

package/esm2022/lib/components/form-fields/datepickers/datetime-picker/custom-datetime-format.mjs

@@ -0,0 +1,36 @@
+export const FORMAT_TIME = 'HH:mm';
+export const FORMAT_DATE = 'MM/dd/yyyy';
+export const FORMAT_DATETIME = 'MM/dd/yyyy HH:mm';
+export class CustomDateTimeFormat {
+    constructor() {
+        this._parse = {
+            dateInput: FORMAT_DATE,
+            datetimeInput: FORMAT_DATETIME,
+            timeInput: FORMAT_TIME,
+        };
+        this._display = {
+            dateInput: FORMAT_DATE,
+            datetimeInput: FORMAT_DATETIME,
+            timeInput: FORMAT_TIME,
+        };
+    }
+    set parse(parse) {
+        this._parse = Object.assign({}, this._parse, parse);
+    }
+    get parse() {
+        return this._parse;
+    }
+    set display(display) {
+        this._display = Object.assign({}, this._display, display);
+    }
+    get display() {
+        return this._display;
+    }
+    updateParse(parse) {
+        this.parse = parse;
+    }
+    updateDisplay(display) {
+        this.display = display;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-fields/datepickers/datetime-picker/custom-datetime.adapter.mjs

@@ -0,0 +1,49 @@
+import { NativeDateAdapter } from '@angular/material/core';
+import { format } from 'date-fns';
+import { Injectable } from '@angular/core';
+import { FORMAT_DATETIME, FORMAT_TIME } from './custom-datetime-format';
+import * as i0 from "@angular/core";
+export class CustomDatetimeAdapter extends NativeDateAdapter {
+    constructor() {
+        super();
+    }
+    format(date, displayFormat) {
+        if (typeof displayFormat === 'string') {
+            return format(date, displayFormat);
+        }
+        else {
+            return super.format(date, displayFormat);
+        }
+    }
+    parse(value, parseFormat) {
+        if (parseFormat === FORMAT_TIME) {
+            /**
+             * we need to add date before we parse manually input time value
+             */
+            value = format(new Date(), 'yyyy-MM-dd') + ' ' + this.inferTime(value);
+        }
+        else if (parseFormat === FORMAT_DATETIME) {
+            const [date, time] = value.split(' ');
+            value = time ? date + ' ' + this.inferTime(time) : value;
+        }
+        return super.parse(value, parseFormat);
+    }
+    inferTime(value) {
+        /**
+         * this allows to construct valid time when only 1 or 2 characters are input
+         */
+        if (value.length === 1) {
+            return `0${value}:00`;
+        }
+        else if (value.length === 2) {
+            return `${value}:00`;
+        }
+        return value;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: CustomDatetimeAdapter, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: CustomDatetimeAdapter }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: CustomDatetimeAdapter, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-fields/datepickers/datetime-picker/datetime-picker-format-directive.mjs

@@ -0,0 +1,66 @@
+import { Directive, Inject, Input, NgModule, Optional } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { MAT_DATETIME_FORMATS } from '@mat-datetimepicker/core';
+import { CustomDateTimeFormat } from './custom-datetime-format';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./custom-datetime-format";
+export class DateTimePickerFormatDirective {
+    ngOnChanges() {
+        if (this.overrideDisplayFormat) {
+            this.format.updateDisplay(this.customDisplayFormat);
+            this.format.updateParse(this.customDisplayFormat);
+            this.ngControl.valueAccessor?.writeValue(this.ngControl.value);
+        }
+    }
+    constructor(format, ngControl) {
+        this.format = format;
+        this.ngControl = ngControl;
+        /** Custom display format that will override current format for this component */
+        this.customDisplayFormat = {};
+        /** Set to use custom display format, overriding the one, provided by locale */
+        this.overrideDisplayFormat = true;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirective, deps: [{ token: MAT_DATETIME_FORMATS }, { token: i1.NgControl, optional: true }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.1.1", type: DateTimePickerFormatDirective, selector: "[dateTimePickerFormat]", inputs: { customDisplayFormat: "customDisplayFormat", overrideDisplayFormat: "overrideDisplayFormat" }, providers: [
+            {
+                provide: MAT_DATETIME_FORMATS,
+                useClass: CustomDateTimeFormat,
+            },
+        ], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dateTimePickerFormat]',
+                    providers: [
+                        {
+                            provide: MAT_DATETIME_FORMATS,
+                            useClass: CustomDateTimeFormat,
+                        },
+                    ],
+                }]
+        }], ctorParameters: () => [{ type: i2.CustomDateTimeFormat, decorators: [{
+                    type: Inject,
+                    args: [MAT_DATETIME_FORMATS]
+                }] }, { type: i1.NgControl, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { customDisplayFormat: [{
+                type: Input
+            }], overrideDisplayFormat: [{
+                type: Input
+            }] } });
+export class DateTimePickerFormatDirectiveModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirectiveModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirectiveModule, declarations: [DateTimePickerFormatDirective], exports: [DateTimePickerFormatDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirectiveModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.1.1", ngImport: i0, type: DateTimePickerFormatDirectiveModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [DateTimePickerFormatDirective],
+                    exports: [DateTimePickerFormatDirective],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/components/form-fields/datepickers/datetime-picker/datetime-template.formatter.mjs

@@ -0,0 +1,171 @@
+export class DatetimeTemplateFormatter {
+    constructor() {
+        this.container = null;
+        this.isFirstRun = true;
+    }
+    run(view) {
+        /**
+         * make sure container has proper class to encapsulate styles
+         */
+        this.container = document.querySelector('mat-datetimepicker-content');
+        this.container?.classList.add('ads-datetimepicker-calendar');
+        /**
+         * if isFirstRun=true (we've just opened the picker)
+         * hide container to allow concealed rearranging
+         */
+        if (this.isFirstRun) {
+            this.container?.classList.add('hidden');
+        }
+        setTimeout(() => {
+            this.rearrangeTemplate(view);
+            this.isFirstRun = false;
+        });
+    }
+    reset() {
+        this.isFirstRun = true;
+    }
+    rearrangeTemplate(view) {
+        const calendar = document.querySelector('mat-datetimepicker-calendar');
+        if (!calendar)
+            return;
+        /**
+         * make sure calendar only has one "view" class
+         */
+        calendar.classList.remove('clock', 'month', 'year', 'multi-year');
+        calendar.classList.add(view);
+        const header = calendar.querySelector('.mat-datetimepicker-calendar-header');
+        const content = calendar.querySelector('.mat-datetimepicker-calendar-content');
+        if (!header || !content)
+            return;
+        /**
+         * get all the buttons that we need to rearrange
+         */
+        const yearButton = header.querySelector('.mat-datetimepicker-calendar-header-year');
+        const monthButton = content.querySelector('.mat-datetimepicker-calendar-period-button');
+        const prevButton = content.querySelector('.mat-datetimepicker-calendar-previous-button') ??
+            header.querySelector('.mat-datetimepicker-calendar-previous-button');
+        const nextButton = content.querySelector('.mat-datetimepicker-calendar-next-button') ??
+            header.querySelector('.mat-datetimepicker-calendar-next-button');
+        /**
+         * create headerLine1 that will contain month name, year value and year prev/next buttons
+         */
+        const headerLine1 = header.querySelector('.header.line-1') ?? document.createElement('div');
+        headerLine1.className = 'header line-1';
+        headerLine1.innerHTML = '';
+        /**
+         * create headerSubLine1 that will contain month name and year value
+         */
+        const headerSubLine1 = document.createElement('div');
+        headerSubLine1.className = 'sub-line-1';
+        if (yearButton) {
+            const svg = yearButton.querySelector('.arrow-down');
+            const monthShortcut = document.createElement('div');
+            if (view !== 'year' && view !== 'clock') {
+                monthShortcut.className = 'month-shortcut';
+                monthShortcut.innerHTML = monthButton?.textContent?.slice(0, 3) || '';
+                yearButton.prepend(monthShortcut);
+                /**
+                 * create arrow down icon
+                 */
+                const arrowSVG = `<svg xmlns="http://www.w3.org/2000/svg" width="11" height="8" viewBox="0 0 11 8" fill="none">
+                    <path d="M0.5 0.0178223L10.5 0.0178224L5.5 7.01782L0.5 0.0178223Z" />
+                  </svg>`;
+                const arrowDiv = document.createElement('div');
+                arrowDiv.className = 'arrow-down';
+                arrowDiv.innerHTML = arrowSVG;
+                /**
+                 * append arrow to the button
+                 */
+                yearButton.append(arrowDiv);
+            }
+            /**
+             * remove svg on a year view
+             */
+            if (svg && (view === 'year' || view === 'clock')) {
+                svg.remove();
+            }
+            /**
+             * remove svg on a year view
+             */
+            const monthEl = yearButton.querySelector('.month-shortcut');
+            if (monthEl && (view === 'year' || view === 'clock')) {
+                monthEl.remove();
+            }
+            /**
+             * append year to subLine1
+             */
+            headerSubLine1.append(yearButton);
+        }
+        /**
+         * only append headerSubLine1 to he headerLine1 if it has items
+         */
+        if (headerSubLine1.hasChildNodes() && view !== 'clock') {
+            headerLine1.append(headerSubLine1);
+        }
+        /**
+         * create headerSubLine2 that will contain year prev/next buttons
+         */
+        const headerSubLine2 = document.createElement('div');
+        headerSubLine2.className = 'sub-line-2';
+        if (prevButton) {
+            headerSubLine2.append(prevButton);
+        }
+        if (nextButton) {
+            headerSubLine2.append(nextButton);
+        }
+        /**
+         * only append headerSubLine2 to he headerLine1 if it has items
+         */
+        if (headerSubLine2.hasChildNodes()) {
+            headerLine1.append(headerSubLine2);
+        }
+        /**
+         * only append headerLine1 header if it has items
+         */
+        if (headerLine1.hasChildNodes()) {
+            header.prepend(headerLine1);
+        }
+        /**
+         * remove existing div to headerLine2 that will contain date and time information
+         */
+        const headerLine2 = header.querySelector('.mat-datetimepicker-calendar-header-date-time');
+        if (headerLine2) {
+            headerLine2.remove();
+        }
+        /**
+         * make sure calendar container is not hidden anymore
+         */
+        this.container?.classList.remove('hidden');
+        /**
+         * Add event listeners to the buttons to detect month changes
+         */
+        if (this.isFirstRun) {
+            this.addMonthChangeListeners(prevButton, nextButton);
+        }
+    }
+    addMonthChangeListeners(prevButton, nextButton) {
+        if (prevButton) {
+            prevButton.addEventListener('click', () => {
+                this.clearHeaderLine1();
+            });
+        }
+        if (nextButton) {
+            nextButton.addEventListener('click', () => {
+                this.clearHeaderLine1();
+            });
+        }
+    }
+    /**
+     *  Remove old month label and prevent duplicate arrow down
+     */
+    clearHeaderLine1() {
+        const monthLabel = document.querySelector('.month-shortcut');
+        const arrowIcon = document.querySelector('.arrow-down');
+        if (monthLabel && arrowIcon) {
+            monthLabel.remove();
+            arrowIcon.remove();
+            this.run('month');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime-template.formatter.js","sourceRoot":"","sources":["../../../../../../../../../libs/ads-ui/src/lib/components/form-fields/datepickers/datetime-picker/datetime-template.formatter.ts"],"names":[],"mappings":"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","sourcesContent":["import { MatCalendarView } from '@mat-datetimepicker/core/datetimepicker/calendar';\n\nexport class DatetimeTemplateFormatter {\n  private container: HTMLElement | null = null;\n  private isFirstRun = true;\n\n  run(view: MatCalendarView): void {\n    /**\n     * make sure container has proper class to encapsulate styles\n     */\n    this.container = document.querySelector('mat-datetimepicker-content');\n    this.container?.classList.add('ads-datetimepicker-calendar');\n\n    /**\n     * if isFirstRun=true (we've just opened the picker)\n     * hide container to allow concealed rearranging\n     */\n    if (this.isFirstRun) {\n      this.container?.classList.add('hidden');\n    }\n\n    setTimeout(() => {\n      this.rearrangeTemplate(view);\n      this.isFirstRun = false;\n    });\n  }\n\n  reset(): void {\n    this.isFirstRun = true;\n  }\n\n  private rearrangeTemplate(view: MatCalendarView): void {\n    const calendar: HTMLElement | null = document.querySelector('mat-datetimepicker-calendar');\n\n    if (!calendar) return;\n\n    /**\n     * make sure calendar only has one \"view\" class\n     */\n    calendar.classList.remove('clock', 'month', 'year', 'multi-year');\n    calendar.classList.add(view);\n\n    const header: HTMLElement | null = calendar.querySelector('.mat-datetimepicker-calendar-header');\n    const content: HTMLElement | null = calendar.querySelector('.mat-datetimepicker-calendar-content');\n\n    if (!header || !content) return;\n\n    /**\n     * get all the buttons that we need to rearrange\n     */\n    const yearButton = header.querySelector('.mat-datetimepicker-calendar-header-year');\n    const monthButton = content.querySelector('.mat-datetimepicker-calendar-period-button');\n    const prevButton =\n      content.querySelector('.mat-datetimepicker-calendar-previous-button') ??\n      header.querySelector('.mat-datetimepicker-calendar-previous-button');\n    const nextButton =\n      content.querySelector('.mat-datetimepicker-calendar-next-button') ??\n      header.querySelector('.mat-datetimepicker-calendar-next-button');\n\n    /**\n     * create headerLine1 that will contain month name, year value and year prev/next buttons\n     */\n    const headerLine1 = header.querySelector('.header.line-1') ?? document.createElement('div');\n    headerLine1.className = 'header line-1';\n    headerLine1.innerHTML = '';\n\n    /**\n     * create headerSubLine1 that will contain month name and year value\n     */\n    const headerSubLine1 = document.createElement('div');\n    headerSubLine1.className = 'sub-line-1';\n\n    if (yearButton) {\n      const svg: HTMLElement | null = yearButton.querySelector('.arrow-down');\n      const monthShortcut: HTMLElement | null = document.createElement('div');\n      if (view !== 'year' && view !== 'clock') {\n        monthShortcut.className = 'month-shortcut';\n        monthShortcut.innerHTML = monthButton?.textContent?.slice(0, 3) || '';\n        yearButton.prepend(monthShortcut);\n        /**\n         * create arrow down icon\n         */\n        const arrowSVG = `<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"11\" height=\"8\" viewBox=\"0 0 11 8\" fill=\"none\">\n                    <path d=\"M0.5 0.0178223L10.5 0.0178224L5.5 7.01782L0.5 0.0178223Z\" />\n                  </svg>`;\n\n        const arrowDiv = document.createElement('div');\n        arrowDiv.className = 'arrow-down';\n        arrowDiv.innerHTML = arrowSVG;\n        /**\n         * append arrow to the button\n         */\n        yearButton.append(arrowDiv);\n      }\n\n      /**\n       * remove svg on a year view\n       */\n      if (svg && (view === 'year' || view === 'clock')) {\n        svg.remove();\n      }\n\n      /**\n       * remove svg on a year view\n       */\n      const monthEl: HTMLElement | null = yearButton.querySelector('.month-shortcut');\n\n      if (monthEl && (view === 'year' || view === 'clock')) {\n        monthEl.remove();\n      }\n\n      /**\n       * append year to subLine1\n       */\n      headerSubLine1.append(yearButton);\n    }\n\n    /**\n     * only append headerSubLine1 to he headerLine1 if it has items\n     */\n    if (headerSubLine1.hasChildNodes() && view !== 'clock') {\n      headerLine1.append(headerSubLine1);\n    }\n\n    /**\n     * create headerSubLine2 that will contain year prev/next buttons\n     */\n    const headerSubLine2 = document.createElement('div');\n    headerSubLine2.className = 'sub-line-2';\n\n    if (prevButton) {\n      headerSubLine2.append(prevButton);\n    }\n\n    if (nextButton) {\n      headerSubLine2.append(nextButton);\n    }\n\n    /**\n     * only append headerSubLine2 to he headerLine1 if it has items\n     */\n    if (headerSubLine2.hasChildNodes()) {\n      headerLine1.append(headerSubLine2);\n    }\n\n    /**\n     * only append headerLine1 header if it has items\n     */\n    if (headerLine1.hasChildNodes()) {\n      header.prepend(headerLine1);\n    }\n\n    /**\n     * remove existing div to headerLine2 that will contain date and time information\n     */\n    const headerLine2 = header.querySelector('.mat-datetimepicker-calendar-header-date-time');\n\n    if (headerLine2) {\n      headerLine2.remove();\n    }\n\n    /**\n     * make sure calendar container is not hidden anymore\n     */\n    this.container?.classList.remove('hidden');\n\n    /**\n     * Add event listeners to the buttons to detect month changes\n     */\n\n    if (this.isFirstRun) {\n      this.addMonthChangeListeners(prevButton, nextButton);\n    }\n  }\n\n  private addMonthChangeListeners(prevButton: Element | null, nextButton: Element | null): void {\n    if (prevButton) {\n      prevButton.addEventListener('click', () => {\n        this.clearHeaderLine1();\n      });\n    }\n\n    if (nextButton) {\n      nextButton.addEventListener('click', () => {\n        this.clearHeaderLine1();\n      });\n    }\n  }\n\n  /**\n   *  Remove old month label and prevent duplicate arrow down\n   */\n  private clearHeaderLine1(): void {\n    const monthLabel = document.querySelector('.month-shortcut');\n    const arrowIcon = document.querySelector('.arrow-down');\n    if (monthLabel && arrowIcon) {\n      monthLabel.remove();\n      arrowIcon.remove();\n      this.run('month');\n    }\n  }\n}\n"]}