primekit 1.0.11 → 1.0.13

package/src/lib/lib/atomix-daterange-calendar/atomix-daterange-calendar.component.ts

@@ -1,717 +0,0 @@
-import {
-  Component,
-  EventEmitter,
-  Input,
-  Output,
-  ViewChild,
-  OnChanges,
-  SimpleChanges,
-  OnInit,
-  OnDestroy,
-  Renderer2,
-} from '@angular/core';
-import { OverlayPanel } from 'primeng/overlaypanel';
-import { DatePipe } from '@angular/common';
-
-@Component({
-  selector: 'atomix-daterange-calendar',
-  templateUrl: './atomix-daterange-calendar.component.html',
-  styleUrls: ['./atomix-daterange-calendar.component.scss'],
-})
-export class AtomixDaterangeCalendarComponent
-  implements OnChanges, OnInit, OnDestroy
-{
-  @Input() placeholder: string = '';
-  @Input() styleClass: string = '';
-  @Input() selectionMode: 'range' = 'range';
-  @Input() inputStyleClass: string = '';
-  @Input() inline: boolean = false;
-  @Input() disabled: boolean = false;
-  @Input() selectedDate: any = null;
-  @Input() maxDate!: Date;
-  @Input() minDate!: Date;
-  @Input() defaultPreset:
-    | 'today'
-    | 'yesterday'
-    | 'last7days'
-    | 'last30days'
-    | 'last3months'
-    | 'last6months'
-    | 'last1year'
-    | null = null;
-  @Input() preservePreset: boolean = false;
-
-  customRangeMode: boolean = false;
-  selectedPreset: string | null = null; // 'today' | 'yesterday' | 'last7days' | 'last30days' | 'last3months' | 'last6months' | 'last1year' | 'custom' | null
-  @ViewChild('overlayPanel') overlayPanel?: OverlayPanel;
-  @Output() dateRangeChange = new EventEmitter<any>();
-
-  // internal model bound to p-calendar to avoid changing external selection during first-click selection
-  modelDate: Date[] | null = null;
-
-  enLocale = {
-    firstDayOfWeek: 0,
-    dayNames: [
-      'Sunday',
-      'Monday',
-      'Tuesday',
-      'Wednesday',
-      'Thursday',
-      'Friday',
-      'Saturday',
-    ],
-    dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
-    dayNamesMin: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
-    monthNames: [
-      'January',
-      'February',
-      'March',
-      'April',
-      'May',
-      'June',
-      'July',
-      'August',
-      'September',
-      'October',
-      'November',
-      'December',
-    ],
-    monthNamesShort: [
-      'Jan',
-      'Feb',
-      'Mar',
-      'Apr',
-      'May',
-      'Jun',
-      'Jul',
-      'Aug',
-      'Sep',
-      'Oct',
-      'Nov',
-      'Dec',
-    ],
-    today: 'Today',
-    clear: 'Clear',
-  };
-
-  // temporary storage for overlay session
-  private _overlayInitialDate: Date[] | null = null;
-  private _overlayInitialPreset: string | null = null;
-  private _calendarObservers: MutationObserver[] = [];
-  private _observedElements: Element[] = [];
-  private _parentObservers: MutationObserver[] = [];
-  private _observedParentElements: Element[] = [];
-  private _updateRafId: number | null = null; // requestAnimationFrame id
-
-  constructor(
-    private datePipe: DatePipe,
-    private renderer: Renderer2
-  ) {}
-
-  ngOnInit(): void {
-    if (!this.selectedDate && this.defaultPreset) {
-      this.applyPreset(this.defaultPreset);
-    }
-    // initialize internal model
-    this.modelDate = this.selectedDate ? [...this.selectedDate] : null;
-    // initial class update if there is a pre-selected range
-    this._scheduleUpdate();
-    // start observers if inline calendar is used
-    if (this.inline) {
-      this._startCalendarObservers();
-    }
-  }
-
-  ngOnChanges(changes: SimpleChanges): void {
-    if (changes['selectedDate']) {
-      const sel = changes['selectedDate'].currentValue as Date[] | null;
-      if (sel && Array.isArray(sel) && sel.length === 2 && sel[0] && sel[1]) {
-        const preset = this.detectPreset(sel[0], sel[1]);
-        this.selectedPreset = preset ?? 'custom';
-        // sync internal model when external value changes
-        this.modelDate = [...sel];
-      } else if (sel == null) {
-        this.selectedPreset = null;
-        this.modelDate = null;
-      }
-    }
-  }
-
-  onInputKeyDown(event: KeyboardEvent) {
-    if (event.key === 'Enter' || event.key === ' ') {
-      try {
-        this.overlayPanel?.toggle(event as any);
-      } catch (e) {}
-      event.preventDefault();
-    }
-  }
-
-  onOverlayShow(): void {
-    // store a deep copy of current selection/preset when overlay opens
-    if (this.selectedDate && Array.isArray(this.selectedDate)) {
-      this._overlayInitialDate = (this.selectedDate as Date[]).map((d) =>
-        d ? new Date(d.getFullYear(), d.getMonth(), d.getDate()) : d
-      );
-    } else {
-      this._overlayInitialDate = null;
-    }
-    this._overlayInitialPreset = this.selectedPreset;
-    // ensure calendar model shows the currently committed selection when opening
-    this.modelDate = this.selectedDate ? [...this.selectedDate] : null;
-    // ensure preset buttons reflect current selection when overlay opens
-    if (
-      this.selectedDate &&
-      Array.isArray(this.selectedDate) &&
-      this.selectedDate.length === 2
-    ) {
-      const preset = this.detectPreset(
-        this.selectedDate[0],
-        this.selectedDate[1]
-      );
-      this.selectedPreset = preset ?? 'custom';
-    } else if (!this.selectedDate) {
-      this.selectedPreset = null;
-    }
-    // add start/end classes to range cells for styling
-    this._scheduleUpdate();
-    // observe DOM changes (PrimeNG may re-render inside overlay)
-    this._startCalendarObservers();
-  }
-
-  onOverlayHide(): void {
-    // if internal calendar model has an incomplete selection (partial range) revert to initial
-    const model = this.modelDate;
-    const isPartialModel = Boolean(
-      model && Array.isArray(model) && model.length > 0 && model[0] && !model[1]
-    );
-    if (isPartialModel) {
-      this.selectedDate = this._overlayInitialDate;
-      this.selectedPreset = this._overlayInitialPreset;
-      // reset internal model to synced value
-      this.modelDate = this.selectedDate ? [...this.selectedDate] : null;
-    }
-    this._overlayInitialDate = null;
-    this._overlayInitialPreset = null;
-    this.customRangeMode = false;
-    // cleanup any start/end classes to avoid stale classes
-    this._scheduleUpdate();
-    // stop observing
-    this._stopCalendarObservers();
-  }
-
-  onModelChange(dateRange: Date[] | null) {
-    // When user clicks a first date, PrimeNG may emit an array with 1 value. We don't want to
-    // update the external selectedDate until the range is completed (two dates) so that
-    // the calendar does not jump back to a previously selected end date's month.
-    this.modelDate = dateRange ? [...dateRange] : null;
-    if (
-      dateRange &&
-      Array.isArray(dateRange) &&
-      dateRange.length === 2 &&
-      dateRange[0] &&
-      dateRange[1]
-    ) {
-      this.selectedPreset = this.detectPreset(dateRange[0], dateRange[1]);
-      this.customRangeMode = false;
-      this.selectedDate = [...dateRange];
-      this.dateRangeChange.emit(this.selectedDate);
-      // close overlay like when applying a preset
-      try {
-        this.overlayPanel?.hide();
-      } catch (e) {}
-    } else if (!dateRange) {
-      // cleared selection
-      this.selectedPreset = null;
-      this.customRangeMode = false;
-      this.selectedDate = null;
-      this.dateRangeChange.emit(null);
-    } else {
-      // single date selecting (partial range) - do not emit change yet; just keep internal model
-      // so the calendar's view remains where the user navigated to.
-      this.selectedPreset = null;
-      this.customRangeMode = false;
-    }
-    // update start/end classes while user is selecting or when range completes
-    this._scheduleUpdate();
-  }
-
-  // Called when the calendar's visible month/year changes
-  onCalendarViewChanged(event?: any): void {
-    // Reapply classes after PrimeNG re-render
-    this._scheduleUpdate();
-    // Reattach observers after a small delay since PrimeNG will likely replace DOM nodes
-    setTimeout(() => {
-      try {
-        this._stopCalendarObservers();
-        this._startCalendarObservers();
-      } catch (e) {}
-    }, 40);
-  }
-
-  get hasSelection(): boolean {
-    return Boolean(
-      this.selectedDate &&
-        Array.isArray(this.selectedDate) &&
-        (this.selectedDate as Date[]).length === 2 &&
-        !!(this.selectedDate as Date[])[0] &&
-        !!(this.selectedDate as Date[])[1]
-    );
-  }
-
-  private normalizeDate(d: Date): Date {
-    return new Date(d.getFullYear(), d.getMonth(), d.getDate());
-  }
-
-  private isSameDate(a: Date, b: Date): boolean {
-    return (
-      a.getFullYear() === b.getFullYear() &&
-      a.getMonth() === b.getMonth() &&
-      a.getDate() === b.getDate()
-    );
-  }
-
-  private detectPreset(startRaw: Date, endRaw: Date): string | null {
-    const start = this.normalizeDate(startRaw);
-    const end = this.normalizeDate(endRaw);
-    const today = this.normalizeDate(new Date());
-    // today
-    if (this.isSameDate(start, today) && this.isSameDate(end, today))
-      return 'today';
-    // yesterday
-    const y = new Date(today);
-    y.setDate(y.getDate() - 1);
-    if (this.isSameDate(start, y) && this.isSameDate(end, y))
-      return 'yesterday';
-    // last7days (last 7 days including today: start = today - 6, end = today)
-    const l7End = new Date(today);
-    const l7Start = new Date(today);
-    l7Start.setDate(today.getDate() - 6);
-    if (this.isSameDate(start, l7Start) && this.isSameDate(end, l7End))
-      return 'last7days';
-    // last30days (last 30 days including today: start = today - 29, end = today)
-    const l30End = new Date(today);
-    const l30Start = new Date(today);
-    l30Start.setDate(today.getDate() - 29);
-    if (this.isSameDate(start, l30Start) && this.isSameDate(end, l30End))
-      return 'last30days';
-    // last3months (last 3 months including today: start = today - 3 months, end = today)
-    const l3mEnd = new Date(today);
-    const l3mStart = new Date(today);
-    l3mStart.setMonth(today.getMonth() - 3);
-    if (this.isSameDate(start, l3mStart) && this.isSameDate(end, l3mEnd))
-      return 'last3months';
-    // last6months (last 6 months including today: start = today - 6 months, end = today)
-    const l6mEnd = new Date(today);
-    const l6mStart = new Date(today);
-    l6mStart.setMonth(today.getMonth() - 6);
-    if (this.isSameDate(start, l6mStart) && this.isSameDate(end, l6mEnd))
-      return 'last6months';
-    // last1year (last 1 year including today: start = today - 1 year, end = today)
-    const l1yEnd = new Date(today);
-    const l1yStart = new Date(today);
-    l1yStart.setFullYear(today.getFullYear() - 1);
-    if (this.isSameDate(start, l1yStart) && this.isSameDate(end, l1yEnd))
-      return 'last1year';
-    return null;
-  }
-
-  clearDateRange() {
-    this.selectedDate = null;
-    this.dateRangeChange.emit(this.selectedDate);
-    this.selectedPreset = null;
-    this.customRangeMode = false;
-    this.modelDate = null;
-  }
-
-  resetAndClose() {
-    this.clearDateRange();
-    if (this.overlayPanel) {
-      try {
-        this.overlayPanel.hide();
-      } catch (e) {}
-    }
-  }
-
-  clearAndStop(event: Event) {
-    this.clearDateRange();
-    try {
-      this.overlayPanel?.hide();
-    } catch (e) {}
-    event.stopPropagation();
-  }
-
-  toggleCustomRange() {
-    this.customRangeMode = !this.customRangeMode;
-    if (this.customRangeMode) this.selectedPreset = 'custom';
-  }
-
-  applyCustomRange() {
-    // ensure external selectedDate is in sync with internal model
-    this.selectedDate = this.modelDate ? [...this.modelDate] : null;
-    this.dateRangeChange.emit(this.selectedDate);
-    if (this.overlayPanel) {
-      try {
-        this.overlayPanel.hide();
-      } catch (e) {}
-    }
-    this.customRangeMode = false;
-    this.selectedPreset = 'custom';
-  }
-
-  getDateRangeLabel() {
-    // Check the internal model first to show real-time updates while selecting
-    const dateArray = this.modelDate || this.selectedDate;
-    if (!dateArray || !Array.isArray(dateArray)) return '';
-
-    const [start, end] = dateArray as (Date | null)[];
-    const arrow = '\u2794';
-
-    // Show just the first date with an arrow if only first date is selected
-    if (start && !end) {
-      const startStr = this.datePipe.transform(start, 'MM/dd/yyyy');
-      return `${startStr} ${arrow} `;
-    }
-
-    // Show the complete range if both dates are selected
-    if (start && end) {
-      const startStr = this.datePipe.transform(start, 'MM/dd/yyyy');
-      const endStr = this.datePipe.transform(end, 'MM/dd/yyyy');
-      return `${startStr} ${arrow} ${endStr}`;
-    }
-
-    return '';
-  }
-
-  applyPreset(
-    preset:
-      | 'today'
-      | 'yesterday'
-      | 'last7days'
-      | 'last30days'
-      | 'last3months'
-      | 'last6months'
-      | 'last1year'
-  ) {
-    const today = new Date();
-    let start: Date | null = null;
-    let end: Date | null = null;
-    switch (preset) {
-      case 'today':
-        start = end = new Date(
-          today.getFullYear(),
-          today.getMonth(),
-          today.getDate()
-        );
-        break;
-      case 'yesterday':
-        const y = new Date(today);
-        y.setDate(y.getDate() - 1);
-        start = end = new Date(y.getFullYear(), y.getMonth(), y.getDate());
-        break;
-      case 'last7days': {
-        end = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-        start = new Date(end);
-        start.setDate(end.getDate() - 6);
-        break;
-      }
-      case 'last30days': {
-        end = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-        start = new Date(end);
-        start.setDate(end.getDate() - 29);
-        break;
-      }
-      case 'last3months': {
-        end = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-        start = new Date(end);
-        start.setMonth(end.getMonth() - 3);
-        break;
-      }
-      case 'last6months': {
-        end = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-        start = new Date(end);
-        start.setMonth(end.getMonth() - 6);
-        break;
-      }
-      case 'last1year': {
-        end = new Date(today.getFullYear(), today.getMonth(), today.getDate());
-        start = new Date(end);
-        start.setFullYear(end.getFullYear() - 1);
-        break;
-      }
-      default:
-        break;
-    }
-    if (start && end) {
-      this.selectedDate = [start, end];
-      this.modelDate = [start, end];
-      if (this.preservePreset) {
-        this.selectedDate = [start, end, { presets: preset }];
-      }
-      this.dateRangeChange.emit(this.selectedDate);
-      this.selectedPreset = preset;
-      this.customRangeMode = false;
-    }
-    try {
-      this.overlayPanel?.hide();
-    } catch (e) {}
-    // ensure we update start/end classes after applying a preset
-    this._scheduleUpdate();
-  }
-
-  onDateRangeChange(dateRange: Date[] | null): void {
-    this.dateRangeChange.emit(dateRange);
-    if (dateRange && Array.isArray(dateRange)) {
-      this.selectedPreset = this.detectPreset(dateRange[0], dateRange[1]);
-      this.customRangeMode = false;
-    } else if (!dateRange) {
-      this.selectedPreset = null;
-      this.customRangeMode = false;
-    }
-    this._scheduleUpdate();
-  }
-
-  ngOnDestroy(): void {
-    this._stopCalendarObservers();
-    this._cancelScheduledUpdate();
-  }
-
-  // Walk the rendered calendar DOM(s) (overlay + inline) and add start-range/end-range classes
-  private _updateStartEndRangeClasses(): void {
-    try {
-      const calendarElements = this._getCalendarElements();
-
-      calendarElements.forEach((calEl: Element) => {
-        // Remove existing classes from spans first
-        const allSpans = calEl.querySelectorAll('td > span');
-        allSpans.forEach((span) => {
-          this.renderer.removeClass(span, 'start-range');
-          this.renderer.removeClass(span, 'end-range');
-          this.renderer.removeClass(span, 'between-range');
-        });
-
-        // Collect span/date pairs, prefer data-date attribute
-        // Cache header month/year for this calendar to avoid querying per-span
-        const panelNode = calEl.closest('.p-datepicker') || calEl;
-        const headerMonthNode = (panelNode as Element).querySelector(
-          '.p-datepicker-header .p-datepicker-title .p-datepicker-month'
-        );
-        const headerYearNode = (panelNode as Element).querySelector(
-          '.p-datepicker-header .p-datepicker-title .p-datepicker-year'
-        );
-        const headerMonthIdx =
-          headerMonthNode && headerMonthNode.textContent
-            ? (this.enLocale.monthNames || []).indexOf(
-                headerMonthNode.textContent.trim()
-              )
-            : NaN;
-        const headerYearVal =
-          headerYearNode && headerYearNode.textContent
-            ? parseInt(headerYearNode.textContent.trim(), 10)
-            : NaN;
-        const items: { dt: Date; span: Element; td?: HTMLElement | null }[] =
-          [];
-        const spans = calEl.querySelectorAll('td > span.p-highlight');
-        spans.forEach((span) => {
-          const td = span.closest('td') as HTMLElement | null;
-          // Try to read data-date attribute, which some PrimeNG versions render on span/td
-          let dataDate = span.getAttribute('data-date');
-          if (!dataDate && td) dataDate = td.getAttribute('data-date');
-          if (dataDate) {
-            const parts = dataDate.split('-').map((p) => parseInt(p, 10));
-            if (parts.length >= 3 && parts.every((n) => !isNaN(n))) {
-              const [y, m, d] = parts;
-              const dt = new Date(y, m - 1, d);
-              items.push({ dt, td, span });
-              return;
-            }
-          }
-          // Fallback: parse day number and infer month/year from nearby header in the same .p-datepicker
-          const dayText = (span.textContent || '').trim();
-          const day = parseInt(dayText, 10);
-          if (!isNaN(day) && td) {
-            // Use cached header month/year when available
-            if (!isNaN(headerMonthIdx) && !isNaN(headerYearVal)) {
-              const dt = new Date(headerYearVal, headerMonthIdx, day);
-              items.push({ dt, td, span });
-              return;
-            }
-          }
-          // last resort: ignore span if date cannot be determined
-        });
-
-        if (items.length === 0) return;
-
-        // Sort items to find min/max (start & end)
-        items.sort((a, b) => a.dt.getTime() - b.dt.getTime());
-        const detectedStart = items[0].dt;
-        const detectedEnd = items[items.length - 1].dt;
-
-        // Preferred range is modelDate/selectedDate if present
-        const range =
-          this.selectedDate && this.selectedDate.length === 2
-            ? this.selectedDate
-            : this.modelDate && this.modelDate.length === 2
-              ? this.modelDate
-              : [detectedStart, detectedEnd];
-        const startDate =
-          range && range[0]
-            ? this.normalizeDate(range[0] as Date)
-            : detectedStart;
-        const endDate =
-          range && range[1]
-            ? this.normalizeDate(range[1] as Date)
-            : detectedEnd;
-
-        // For each item, add start-range,end-range, or between-range based on date
-        const sTime = startDate.getTime();
-        const eTime = endDate.getTime();
-        for (const it of items) {
-          const t = it.dt.getTime();
-          if (sTime === eTime && t === sTime) {
-            // single-day range, mark both start & end
-            this.renderer.addClass(it.span, 'start-range');
-            this.renderer.addClass(it.span, 'end-range');
-          } else if (t === sTime) {
-            this.renderer.addClass(it.span, 'start-range');
-          } else if (t === eTime) {
-            this.renderer.addClass(it.span, 'end-range');
-          } else if (t > sTime && t < eTime) {
-            this.renderer.addClass(it.span, 'between-range');
-          }
-        }
-      });
-    } catch (e) {
-      // ignore DOM errors (e.g., server-side rendering / missing elements)
-    }
-  }
-
-  private isoDate(d: Date): string {
-    const y = d.getFullYear();
-    const m = String(d.getMonth() + 1).padStart(2, '0');
-    const day = String(d.getDate()).padStart(2, '0');
-    return `${y}-${m}-${day}`;
-  }
-
-  private _findElementByDate(date?: Date): HTMLElement | undefined {
-    if (!date) return undefined;
-    const y = date.getFullYear();
-    const m = date.getMonth() + 1; // 1..12
-    const d = date.getDate();
-    const isoUnpadded = `${y}-${m}-${d}`; // e.g. 2025-11-1
-    const isoPadded = `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`; // 2025-11-01
-    const selectors = [
-      `[data-date="${isoUnpadded}"]`,
-      `[data-date="${isoPadded}"]`,
-    ];
-    for (const sel of selectors) {
-      const foundInOverlay = document.querySelector(
-        `.atomix-overlay-calendar ${sel}`
-      ) as HTMLElement | null;
-      if (foundInOverlay)
-        return (
-          (foundInOverlay.closest('td') as HTMLElement | null) || foundInOverlay
-        );
-    }
-    for (const sel of selectors) {
-      const found = document.querySelector(sel) as HTMLElement | null;
-      if (found) return (found.closest('td') as HTMLElement | null) || found;
-    }
-    return undefined;
-  }
-
-  private _startCalendarObservers(): void {
-    // stop first to avoid duplicates
-    this._stopCalendarObservers();
-    try {
-      const calEls = this._getCalendarElements();
-      try {
-        const panel = this.overlayPanel as any;
-        if (panel && panel.el && panel.el.nativeElement) {
-          const el = panel.el.nativeElement.querySelector('.p-datepicker');
-          if (el) calEls.push(el as Element);
-        }
-      } catch (e) {}
-
-      calEls.forEach((el) => {
-        const obs = new MutationObserver(() => {
-          // Reapply classes after DOM changes (debounced)
-          this._scheduleUpdate();
-        });
-        // Watch childList, subtree and class attribute changes (span class toggles are common)
-        obs.observe(el, {
-          childList: true,
-          subtree: true,
-          attributes: true,
-          attributeFilter: ['class'],
-        });
-        this._calendarObservers.push(obs);
-        this._observedElements.push(el);
-        // Also observe parent - if PrimeNG replaces the .p-datepicker element, parent childList changes will fire
-        const parent = el.parentElement;
-        if (parent && this._observedParentElements.indexOf(parent) === -1) {
-          const parentObs = new MutationObserver(() => {
-            // reattach observers since the calEl may have been replaced
-            this._scheduleUpdate();
-            // detach and re-attach observers after DOM settles
-            setTimeout(() => {
-              try {
-                this._stopCalendarObservers();
-                this._startCalendarObservers();
-              } catch (e) {}
-            }, 100); // slightly larger delay to let PrimeNG finish the month rendering
-          });
-          parentObs.observe(parent, { childList: true, subtree: false });
-          this._parentObservers.push(parentObs);
-          this._observedParentElements.push(parent);
-        }
-      });
-    } catch (e) {
-      // ignore
-    }
-  }
-
-  private _stopCalendarObservers(): void {
-    try {
-      this._calendarObservers.forEach((obs) => obs.disconnect());
-      this._parentObservers.forEach((obs) => obs.disconnect());
-    } catch (e) {}
-    this._calendarObservers = [];
-    this._observedElements = [];
-    this._parentObservers = [];
-    this._observedParentElements = [];
-  }
-
-  private _scheduleUpdate(): void {
-    if (this._updateRafId != null) return; // already scheduled
-    this._updateRafId = window.requestAnimationFrame(() => {
-      this._updateRafId = null;
-      this._updateStartEndRangeClasses();
-    });
-  }
-
-  private _cancelScheduledUpdate(): void {
-    if (this._updateRafId != null) {
-      window.cancelAnimationFrame(this._updateRafId);
-      this._updateRafId = null;
-    }
-  }
-
-  private _getCalendarElements(): Element[] {
-    const calEls: Element[] = [];
-    const overlayCal = document.querySelector(
-      '.atomix-overlay-calendar .p-datepicker'
-    );
-    const inlineCal = document.querySelector('.inline-calendar .p-datepicker');
-    if (overlayCal) calEls.push(overlayCal);
-    if (inlineCal) calEls.push(inlineCal);
-    try {
-      const panel = this.overlayPanel as any;
-      if (panel && panel.el && panel.el.nativeElement) {
-        const el = panel.el.nativeElement.querySelector('.p-datepicker');
-        if (el) calEls.push(el as Element);
-      }
-    } catch (e) {}
-    // remove duplicates
-    return Array.from(new Set(calEls));
-  }
-}