@cqa-lib/cqa-ui 1.0.99 → 1.0.100

package/esm2020/lib/filters/daterangepicker/daterangepicker.component.mjs

@@ -0,0 +1,234 @@
+import { Component, Input, Output, EventEmitter, ViewChild, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "./daterangepicker.directive";
+export class DaterangepickerComponent {
+    constructor() {
+        this.disabled = false;
+        this.autoApply = false;
+        this.alwaysShowCalendars = false;
+        this.opens = 'left';
+        this.drops = 'down';
+        this.datesUpdated = new EventEmitter();
+        this.cancelClicked = new EventEmitter();
+        this.applyClicked = new EventEmitter();
+        this.pickerOptions = {};
+        this.onChange = (value) => { };
+        this.onTouched = () => { };
+    }
+    ngOnInit() {
+        this.pickerOptions = {
+            startDate: this.startDate ? new Date(this.startDate) : undefined,
+            endDate: this.endDate ? new Date(this.endDate) : undefined,
+            minDate: this.minDate ? new Date(this.minDate) : undefined,
+            maxDate: this.maxDate ? new Date(this.maxDate) : undefined,
+            ranges: this.ranges,
+            autoApply: this.autoApply,
+            alwaysShowCalendars: this.alwaysShowCalendars,
+            opens: this.opens,
+            drops: this.drops,
+            isInvalidDate: this.isInvalidDate,
+            locale: {
+                format: 'MM/DD/YYYY',
+                separator: ' - ',
+                applyLabel: 'Apply',
+                cancelLabel: 'Cancel',
+                fromLabel: 'From',
+                toLabel: 'To',
+                customRangeLabel: 'Custom',
+                weekLabel: 'W',
+                daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+                monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
+                firstDay: 0
+            }
+        };
+    }
+    ngOnDestroy() {
+        // Cleanup handled by directive
+    }
+    onDatesUpdated(event) {
+        this.startDate = event.startDate || undefined;
+        this.endDate = event.endDate || undefined;
+        this.onChange({ start: event.startDate, end: event.endDate });
+        this.datesUpdated.emit(event);
+    }
+    onCancel() {
+        this.cancelClicked.emit();
+    }
+    onApply(event) {
+        this.applyClicked.emit(event);
+    }
+    // ControlValueAccessor implementation
+    writeValue(value) {
+        if (value) {
+            this.startDate = value.start || undefined;
+            this.endDate = value.end || undefined;
+        }
+        else {
+            this.startDate = undefined;
+            this.endDate = undefined;
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+    }
+    openPicker() {
+        if (this.disabled || !this.inputRef?.nativeElement)
+            return;
+        this.inputRef.nativeElement.focus();
+        this.inputRef.nativeElement.click();
+    }
+}
+DaterangepickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DaterangepickerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+DaterangepickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: DaterangepickerComponent, selector: "cqa-daterangepicker", inputs: { label: "label", placeholder: "placeholder", disabled: "disabled", startDate: "startDate", endDate: "endDate", minDate: "minDate", maxDate: "maxDate", ranges: "ranges", autoApply: "autoApply", alwaysShowCalendars: "alwaysShowCalendars", opens: "opens", drops: "drops", isInvalidDate: "isInvalidDate" }, outputs: { datesUpdated: "datesUpdated", cancelClicked: "cancelClicked", applyClicked: "applyClicked" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => DaterangepickerComponent),
+            multi: true
+        }
+    ], viewQueries: [{ propertyName: "inputRef", first: true, predicate: ["inputRef"], descendants: true, static: true }], ngImport: i0, template: `
+    <div class="cqa-ui-root">
+      <label *ngIf="label" class="form-label cqa-text-[#374151] cqa-text-[14px] cqa-font-medium cqa-block cqa-leading-[1.4] cqa-mb-2">
+        {{ label }}
+      </label>
+      <div class="cqa-daterangepicker-wrapper">
+        <input
+          #inputRef
+          type="text"
+          class="cqa-daterangepicker-input"
+          [placeholder]="placeholder || 'Start Date - End Date'"
+          [readonly]="true"
+          [disabled]="disabled"
+          cqaDaterangepicker
+          [options]="pickerOptions"
+          [startDate]="startDate"
+          [endDate]="endDate"
+          [minDate]="minDate"
+          [maxDate]="maxDate"
+          (datesUpdated)="onDatesUpdated($event)"
+          (cancelClicked)="onCancel()"
+          (applyClicked)="onApply($event)"
+        />
+        <button
+          type="button"
+          class="cqa-daterangepicker-icon"
+          (click)="openPicker()"
+          [disabled]="disabled"
+          aria-label="Open date range picker"
+        >
+          <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+                      <path d="M5.33398 1.33203V3.9987" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                      <path d="M10.666 1.33203V3.9987" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                      <path
+                        d="M12.6667 2.66797H3.33333C2.59695 2.66797 2 3.26492 2 4.0013V13.3346C2 14.071 2.59695 14.668 3.33333 14.668H12.6667C13.403 14.668 14 14.071 14 13.3346V4.0013C14 3.26492 13.403 2.66797 12.6667 2.66797Z"
+                        stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round" stroke-linejoin="round" />
+                      <path d="M2 6.66797H14" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                    </svg>
+        </button>
+      </div>
+    </div>
+  `, isInline: true, directives: [{ type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i2.DaterangepickerDirective, selector: "[cqaDaterangepicker]", inputs: ["options", "startDate", "endDate", "minDate", "maxDate"], outputs: ["datesUpdated", "cancelClicked", "applyClicked"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DaterangepickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'cqa-daterangepicker',
+                    template: `
+    <div class="cqa-ui-root">
+      <label *ngIf="label" class="form-label cqa-text-[#374151] cqa-text-[14px] cqa-font-medium cqa-block cqa-leading-[1.4] cqa-mb-2">
+        {{ label }}
+      </label>
+      <div class="cqa-daterangepicker-wrapper">
+        <input
+          #inputRef
+          type="text"
+          class="cqa-daterangepicker-input"
+          [placeholder]="placeholder || 'Start Date - End Date'"
+          [readonly]="true"
+          [disabled]="disabled"
+          cqaDaterangepicker
+          [options]="pickerOptions"
+          [startDate]="startDate"
+          [endDate]="endDate"
+          [minDate]="minDate"
+          [maxDate]="maxDate"
+          (datesUpdated)="onDatesUpdated($event)"
+          (cancelClicked)="onCancel()"
+          (applyClicked)="onApply($event)"
+        />
+        <button
+          type="button"
+          class="cqa-daterangepicker-icon"
+          (click)="openPicker()"
+          [disabled]="disabled"
+          aria-label="Open date range picker"
+        >
+          <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+                      <path d="M5.33398 1.33203V3.9987" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                      <path d="M10.666 1.33203V3.9987" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                      <path
+                        d="M12.6667 2.66797H3.33333C2.59695 2.66797 2 3.26492 2 4.0013V13.3346C2 14.071 2.59695 14.668 3.33333 14.668H12.6667C13.403 14.668 14 14.071 14 13.3346V4.0013C14 3.26492 13.403 2.66797 12.6667 2.66797Z"
+                        stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round" stroke-linejoin="round" />
+                      <path d="M2 6.66797H14" stroke="#0A0A0A" stroke-width="1.33333" stroke-linecap="round"
+                        stroke-linejoin="round" />
+                    </svg>
+        </button>
+      </div>
+    </div>
+  `,
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DaterangepickerComponent),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], propDecorators: { label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], startDate: [{
+                type: Input
+            }], endDate: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], ranges: [{
+                type: Input
+            }], autoApply: [{
+                type: Input
+            }], alwaysShowCalendars: [{
+                type: Input
+            }], opens: [{
+                type: Input
+            }], drops: [{
+                type: Input
+            }], isInvalidDate: [{
+                type: Input
+            }], datesUpdated: [{
+                type: Output
+            }], cancelClicked: [{
+                type: Output
+            }], applyClicked: [{
+                type: Output
+            }], inputRef: [{
+                type: ViewChild,
+                args: ['inputRef', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker.component.js","sourceRoot":"","sources":["../../../../../../src/lib/filters/daterangepicker/daterangepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,SAAS,EAAiC,UAAU,EAAE,MAAM,eAAe,CAAC;AAC7H,OAAO,EAAwB,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;;;;AA0DzE,MAAM,OAAO,wBAAwB;IAvDrC;QA0DW,aAAQ,GAAG,KAAK,CAAC;QAMjB,cAAS,GAAG,KAAK,CAAC;QAClB,wBAAmB,GAAG,KAAK,CAAC;QAC5B,UAAK,GAAgC,MAAM,CAAC;QAC5C,UAAK,GAA2B,MAAM,CAAC;QAGtC,iBAAY,GAAG,IAAI,YAAY,EAAoD,CAAC;QACpF,kBAAa,GAAG,IAAI,YAAY,EAAQ,CAAC;QACzC,iBAAY,GAAG,IAAI,YAAY,EAAoD,CAAC;QAI9F,kBAAa,GAA2B,EAAE,CAAC;QAEnC,aAAQ,GAAG,CAAC,KAAsD,EAAE,EAAE,GAAE,CAAC,CAAC;QAC1E,cAAS,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;KA6E9B;IA3EC,QAAQ;QACN,IAAI,CAAC,aAAa,GAAG;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;YAChE,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;YAC1D,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;YAC1D,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,SAAS;YAC1D,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,mBAAmB,EAAE,IAAI,CAAC,mBAAmB;YAC7C,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,MAAM,EAAE;gBACN,MAAM,EAAE,YAAY;gBACpB,SAAS,EAAE,KAAK;gBAChB,UAAU,EAAE,OAAO;gBACnB,WAAW,EAAE,QAAQ;gBACrB,SAAS,EAAE,MAAM;gBACjB,OAAO,EAAE,IAAI;gBACb,gBAAgB,EAAE,QAAQ;gBAC1B,SAAS,EAAE,GAAG;gBACd,UAAU,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC;gBACtD,UAAU,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,CAAC;gBACtI,QAAQ,EAAE,CAAC;aACZ;SACF,CAAC;IACJ,CAAC;IAED,WAAW;QACT,+BAA+B;IACjC,CAAC;IAED,cAAc,CAAC,KAAuD;QACpE,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,IAAI,SAAS,CAAC;QAC9C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,IAAI,SAAS,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,SAAS,EAAE,GAAG,EAAE,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,QAAQ;QACN,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,CAAC;IAC5B,CAAC;IAED,OAAO,CAAC,KAAuD;QAC7D,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED,sCAAsC;IACtC,UAAU,CAAC,KAAsD;QAC/D,IAAI,KAAK,EAAE;YACT,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,KAAK,IAAI,SAAS,CAAC;YAC1C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,GAAG,IAAI,SAAS,CAAC;SACvC;aAAM;YACL,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;YAC3B,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC;SAC1B;IACH,CAAC;IAED,gBAAgB,CAAC,EAAoE;QACnF,IAAI,CAAC,QAAQ,GAAG,EAAE,CAAC;IACrB,CAAC;IAED,iBAAiB,CAAC,EAAc;QAC9B,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED,gBAAgB,CAAC,UAAmB;QAClC,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;IAC7B,CAAC;IAED,UAAU;QACR,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa;YAAE,OAAO;QAC3D,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QACpC,IAAI,CAAC,QAAQ,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IACtC,CAAC;;qHApGU,wBAAwB;yGAAxB,wBAAwB,+cARxB;QACT;YACE,OAAO,EAAE,iBAAiB;YAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,CAAC,wBAAwB,CAAC;YACvD,KAAK,EAAE,IAAI;SACZ;KACF,8IAnDS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CT;2FASU,wBAAwB;kBAvDpC,SAAS;mBAAC;oBACT,QAAQ,EAAE,qBAAqB;oBAC/B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CT;oBACD,SAAS,EAAE;wBACT;4BACE,OAAO,EAAE,iBAAiB;4BAC1B,WAAW,EAAE,UAAU,CAAC,GAAG,EAAE,yBAAyB,CAAC;4BACvD,KAAK,EAAE,IAAI;yBACZ;qBACF;iBACF;8BAEU,KAAK;sBAAb,KAAK;gBACG,WAAW;sBAAnB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,OAAO;sBAAf,KAAK;gBACG,MAAM;sBAAd,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,mBAAmB;sBAA3B,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,KAAK;sBAAb,KAAK;gBACG,aAAa;sBAArB,KAAK;gBAEI,YAAY;sBAArB,MAAM;gBACG,aAAa;sBAAtB,MAAM;gBACG,YAAY;sBAArB,MAAM;gBAEkC,QAAQ;sBAAhD,SAAS;uBAAC,UAAU,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE","sourcesContent":["import { Component, Input, Output, EventEmitter, ViewChild, ElementRef, OnInit, OnDestroy, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DaterangepickerDirective, DateRangePickerOptions } from './daterangepicker.directive';\n\n@Component({\n  selector: 'cqa-daterangepicker',\n  template: `\n    <div class=\"cqa-ui-root\">\n      <label *ngIf=\"label\" class=\"form-label cqa-text-[#374151] cqa-text-[14px] cqa-font-medium cqa-block cqa-leading-[1.4] cqa-mb-2\">\n        {{ label }}\n      </label>\n      <div class=\"cqa-daterangepicker-wrapper\">\n        <input\n          #inputRef\n          type=\"text\"\n          class=\"cqa-daterangepicker-input\"\n          [placeholder]=\"placeholder || 'Start Date - End Date'\"\n          [readonly]=\"true\"\n          [disabled]=\"disabled\"\n          cqaDaterangepicker\n          [options]=\"pickerOptions\"\n          [startDate]=\"startDate\"\n          [endDate]=\"endDate\"\n          [minDate]=\"minDate\"\n          [maxDate]=\"maxDate\"\n          (datesUpdated)=\"onDatesUpdated($event)\"\n          (cancelClicked)=\"onCancel()\"\n          (applyClicked)=\"onApply($event)\"\n        />\n        <button\n          type=\"button\"\n          class=\"cqa-daterangepicker-icon\"\n          (click)=\"openPicker()\"\n          [disabled]=\"disabled\"\n          aria-label=\"Open date range picker\"\n        >\n          <svg width=\"16\" height=\"16\" viewBox=\"0 0 16 16\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\">\n                      <path d=\"M5.33398 1.33203V3.9987\" stroke=\"#0A0A0A\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\n                        stroke-linejoin=\"round\" />\n                      <path d=\"M10.666 1.33203V3.9987\" stroke=\"#0A0A0A\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\n                        stroke-linejoin=\"round\" />\n                      <path\n                        d=\"M12.6667 2.66797H3.33333C2.59695 2.66797 2 3.26492 2 4.0013V13.3346C2 14.071 2.59695 14.668 3.33333 14.668H12.6667C13.403 14.668 14 14.071 14 13.3346V4.0013C14 3.26492 13.403 2.66797 12.6667 2.66797Z\"\n                        stroke=\"#0A0A0A\" stroke-width=\"1.33333\" stroke-linecap=\"round\" stroke-linejoin=\"round\" />\n                      <path d=\"M2 6.66797H14\" stroke=\"#0A0A0A\" stroke-width=\"1.33333\" stroke-linecap=\"round\"\n                        stroke-linejoin=\"round\" />\n                    </svg>\n        </button>\n      </div>\n    </div>\n  `,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => DaterangepickerComponent),\n      multi: true\n    }\n  ]\n})\nexport class DaterangepickerComponent implements OnInit, OnDestroy, ControlValueAccessor {\n  @Input() label?: string;\n  @Input() placeholder?: string;\n  @Input() disabled = false;\n  @Input() startDate?: Date | string;\n  @Input() endDate?: Date | string;\n  @Input() minDate?: Date | string;\n  @Input() maxDate?: Date | string;\n  @Input() ranges?: any;\n  @Input() autoApply = false;\n  @Input() alwaysShowCalendars = false;\n  @Input() opens: 'left' | 'right' | 'center' = 'left';\n  @Input() drops: 'down' | 'up' | 'auto' = 'down';\n  @Input() isInvalidDate?: (date: Date) => boolean;\n\n  @Output() datesUpdated = new EventEmitter<{ startDate: Date | null; endDate: Date | null }>();\n  @Output() cancelClicked = new EventEmitter<void>();\n  @Output() applyClicked = new EventEmitter<{ startDate: Date | null; endDate: Date | null }>();\n\n  @ViewChild('inputRef', { static: true }) inputRef!: ElementRef<HTMLInputElement>;\n\n  pickerOptions: DateRangePickerOptions = {};\n\n  private onChange = (value: { start: Date | null; end: Date | null } | null) => {};\n  private onTouched = () => {};\n\n  ngOnInit(): void {\n    this.pickerOptions = {\n      startDate: this.startDate ? new Date(this.startDate) : undefined,\n      endDate: this.endDate ? new Date(this.endDate) : undefined,\n      minDate: this.minDate ? new Date(this.minDate) : undefined,\n      maxDate: this.maxDate ? new Date(this.maxDate) : undefined,\n      ranges: this.ranges,\n      autoApply: this.autoApply,\n      alwaysShowCalendars: this.alwaysShowCalendars,\n      opens: this.opens,\n      drops: this.drops,\n      isInvalidDate: this.isInvalidDate,\n      locale: {\n        format: 'MM/DD/YYYY',\n        separator: ' - ',\n        applyLabel: 'Apply',\n        cancelLabel: 'Cancel',\n        fromLabel: 'From',\n        toLabel: 'To',\n        customRangeLabel: 'Custom',\n        weekLabel: 'W',\n        daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],\n        monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],\n        firstDay: 0\n      }\n    };\n  }\n\n  ngOnDestroy(): void {\n    // Cleanup handled by directive\n  }\n\n  onDatesUpdated(event: { startDate: Date | null; endDate: Date | null }): void {\n    this.startDate = event.startDate || undefined;\n    this.endDate = event.endDate || undefined;\n    this.onChange({ start: event.startDate, end: event.endDate });\n    this.datesUpdated.emit(event);\n  }\n\n  onCancel(): void {\n    this.cancelClicked.emit();\n  }\n\n  onApply(event: { startDate: Date | null; endDate: Date | null }): void {\n    this.applyClicked.emit(event);\n  }\n\n  // ControlValueAccessor implementation\n  writeValue(value: { start: Date | null; end: Date | null } | null): void {\n    if (value) {\n      this.startDate = value.start || undefined;\n      this.endDate = value.end || undefined;\n    } else {\n      this.startDate = undefined;\n      this.endDate = undefined;\n    }\n  }\n\n  registerOnChange(fn: (value: { start: Date | null; end: Date | null } | null) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n  }\n\n  openPicker(): void {\n    if (this.disabled || !this.inputRef?.nativeElement) return;\n    this.inputRef.nativeElement.focus();\n    this.inputRef.nativeElement.click();\n  }\n}\n\n"]}

package/esm2020/lib/filters/daterangepicker/daterangepicker.directive.mjs

@@ -0,0 +1,322 @@
+import { Directive, Input, Output, EventEmitter, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as jquery from 'jquery';
+import * as momentImport from 'moment';
+import 'daterangepicker';
+import * as i0 from "@angular/core";
+// Normalize module default/namespace interop for both ESM and CJS builds.
+const $ = jquery.default || jquery;
+const moment = momentImport.default || momentImport;
+// Ensure globals are present for the daterangepicker plugin registration.
+if (typeof window !== 'undefined') {
+    window.jQuery = window.jQuery || $;
+    window.$ = window.$ || $;
+    window.moment = window.moment || moment;
+}
+export class DaterangepickerDirective {
+    constructor(el) {
+        this.el = el;
+        this.options = {};
+        this.datesUpdated = new EventEmitter();
+        this.cancelClicked = new EventEmitter();
+        this.applyClicked = new EventEmitter();
+        this.onChange = (value) => { };
+        this.onTouched = () => { };
+    }
+    /**
+     * Safely update the input text to avoid "Invalid date" or "undefined" strings.
+     */
+    updateInputValue(start, end) {
+        if (typeof window.moment === 'undefined')
+            return;
+        const m = window.moment;
+        const format = (this.options?.locale && this.options.locale.format) || 'MM/DD/YYYY';
+        const separator = (this.options?.locale && this.options.locale.separator) || ' - ';
+        const hasStart = start && m.isMoment(start);
+        const hasEnd = end && m.isMoment(end);
+        if (hasStart && hasEnd) {
+            try {
+                const text = `${start.format(format)}${separator}${end.format(format)}`;
+                $(this.el.nativeElement).val(text);
+            }
+            catch { }
+        }
+        else {
+            try {
+                $(this.el.nativeElement).val('');
+            }
+            catch { }
+        }
+    }
+    ngOnInit() {
+        this.initDaterangepicker();
+    }
+    ngOnChanges(changes) {
+        if (this.pickerInstance) {
+            if (changes['startDate'] || changes['endDate']) {
+                this.updateDates();
+            }
+            if (changes['minDate'] || changes['maxDate']) {
+                this.updateMinMaxDates();
+            }
+            if (changes['options']) {
+                this.destroyPicker();
+                this.initDaterangepicker();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.destroyPicker();
+    }
+    initDaterangepicker() {
+        if (typeof $ === 'undefined' || typeof $.fn.daterangepicker === 'undefined') {
+            console.error('jQuery and daterangepicker must be loaded');
+            return;
+        }
+        // Check if moment.js is available
+        if (typeof window.moment === 'undefined') {
+            console.error('moment.js must be loaded for daterangepicker to work');
+            return;
+        }
+        // Resolve parent element to scope styles; default to closest .cqa-ui-daterange-picker, fallback to body.
+        const parentElCandidate = $(this.el.nativeElement).closest('.cqa-ui-daterange-picker');
+        const resolvedParentEl = this.options?.parentEl
+            ? this.options.parentEl
+            : (parentElCandidate && parentElCandidate.length ? parentElCandidate : 'body');
+        const baseOptions = {
+            opens: 'left',
+            drops: 'down',
+            autoApply: true,
+            autoUpdateInput: false,
+            locale: {
+                format: 'MM/DD/YYYY',
+                separator: ' - ',
+                applyLabel: 'Apply',
+                cancelLabel: 'Cancel',
+                fromLabel: 'From',
+                toLabel: 'To',
+                customRangeLabel: 'Custom',
+                weekLabel: 'W',
+                daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+                monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],
+                firstDay: 0
+            },
+            parentEl: resolvedParentEl
+        };
+        // Merge options but force-disable plugin autoUpdateInput to avoid invalid values.
+        const defaultOptions = {
+            ...baseOptions,
+            ...this.options,
+            locale: {
+                ...baseOptions.locale,
+                ...(this.options?.locale || {})
+            },
+            autoUpdateInput: false
+        };
+        // Convert Date objects to moment objects for daterangepicker
+        const toMoment = (d) => {
+            if (!d)
+                return null;
+            if (typeof d === 'string') {
+                const lower = d.trim().toLowerCase();
+                if (lower === 'undefined' || lower === 'null' || lower === '')
+                    return null;
+            }
+            if (moment.isMoment && moment.isMoment(d))
+                return d;
+            const date = typeof d === 'string' ? new Date(d) : d;
+            if (date instanceof Date && !isNaN(date.getTime())) {
+                return moment(date);
+            }
+            return null;
+        };
+        const startMoment = toMoment(this.startDate);
+        const endMoment = toMoment(this.endDate);
+        const minMoment = toMoment(this.minDate);
+        const maxMoment = toMoment(this.maxDate);
+        if (startMoment)
+            defaultOptions.startDate = startMoment;
+        if (endMoment)
+            defaultOptions.endDate = endMoment;
+        if (minMoment)
+            defaultOptions.minDate = minMoment;
+        if (maxMoment)
+            defaultOptions.maxDate = maxMoment;
+        // If no initial dates, ensure the input is blank before plugin init.
+        if (!startMoment && !endMoment) {
+            try {
+                $(this.el.nativeElement).val('');
+            }
+            catch { }
+        }
+        // Initialize the picker
+        $(this.el.nativeElement).daterangepicker(defaultOptions, (start, end, label) => {
+            const startDate = start ? start.toDate() : null;
+            const endDate = end ? end.toDate() : null;
+            this.onChange({ start: startDate, end: endDate });
+            this.datesUpdated.emit({ startDate, endDate });
+            this.applyClicked.emit({ startDate, endDate });
+            this.updateInputValue(start, end);
+        });
+        this.pickerInstance = $(this.el.nativeElement).data('daterangepicker');
+        // Ensure the overlay gets the styling scope class if not already present.
+        if (this.pickerInstance?.container) {
+            const c = this.pickerInstance.container;
+            if (!c.hasClass('cqa-ui-daterange-picker')) {
+                c.addClass('cqa-ui-daterange-picker');
+            }
+        }
+        // Handle cancel event
+        $(this.el.nativeElement).on('cancel.daterangepicker', () => {
+            this.cancelClicked.emit();
+            this.updateInputValue(null, null);
+        });
+        // Update initial value if provided
+        this.updateDates();
+    }
+    updateDates() {
+        if (!this.pickerInstance)
+            return;
+        if (typeof window.moment === 'undefined')
+            return;
+        const moment = window.moment;
+        // Convert Date objects to moment objects
+        const toMoment = (d) => {
+            if (!d)
+                return null;
+            if (typeof d === 'string') {
+                const lower = d.trim().toLowerCase();
+                if (lower === 'undefined' || lower === 'null' || lower === '')
+                    return null;
+            }
+            if (moment.isMoment && moment.isMoment(d))
+                return d;
+            const date = typeof d === 'string' ? new Date(d) : d;
+            if (date instanceof Date && !isNaN(date.getTime())) {
+                return moment(date);
+            }
+            return null;
+        };
+        const startMoment = toMoment(this.startDate);
+        const endMoment = toMoment(this.endDate);
+        if (startMoment) {
+            this.pickerInstance.setStartDate(startMoment);
+        }
+        if (endMoment) {
+            this.pickerInstance.setEndDate(endMoment);
+        }
+        // Update input text to reflect current values
+        this.updateInputValue(startMoment, endMoment);
+    }
+    updateMinMaxDates() {
+        if (!this.pickerInstance)
+            return;
+        if (typeof window.moment === 'undefined')
+            return;
+        const moment = window.moment;
+        // Convert Date objects to moment objects
+        const toMoment = (d) => {
+            if (!d)
+                return null;
+            if (moment.isMoment && moment.isMoment(d))
+                return d;
+            const date = typeof d === 'string' ? new Date(d) : d;
+            if (date instanceof Date && !isNaN(date.getTime())) {
+                return moment(date);
+            }
+            return null;
+        };
+        const minMoment = toMoment(this.minDate);
+        const maxMoment = toMoment(this.maxDate);
+        if (minMoment) {
+            this.pickerInstance.setMinDate(minMoment);
+        }
+        if (maxMoment) {
+            this.pickerInstance.setMaxDate(maxMoment);
+        }
+    }
+    destroyPicker() {
+        if (this.pickerInstance && typeof $ !== 'undefined') {
+            $(this.el.nativeElement).off('cancel.daterangepicker');
+            $(this.el.nativeElement).data('daterangepicker')?.remove();
+            this.pickerInstance = null;
+        }
+    }
+    // ControlValueAccessor implementation
+    writeValue(value) {
+        if (value && (value.start || value.end)) {
+            // Validate dates before setting
+            const isValidDate = (d) => {
+                return d !== null && d instanceof Date && !isNaN(d.getTime());
+            };
+            this.startDate = (value.start && isValidDate(value.start)) ? value.start : undefined;
+            this.endDate = (value.end && isValidDate(value.end)) ? value.end : undefined;
+            this.updateDates();
+        }
+        else if (value === null || (value && !value.start && !value.end)) {
+            this.startDate = undefined;
+            this.endDate = undefined;
+            if (this.pickerInstance) {
+                try {
+                    const m = window.moment;
+                    if (m) {
+                        // Reset picker internals to a safe value instead of null to avoid "Invalid date"
+                        this.pickerInstance.setStartDate(m());
+                        this.pickerInstance.setEndDate(m());
+                    }
+                    this.updateInputValue(null, null);
+                }
+                catch { }
+            }
+        }
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        if (this.el.nativeElement) {
+            this.el.nativeElement.disabled = isDisabled;
+        }
+    }
+}
+DaterangepickerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DaterangepickerDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+DaterangepickerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.4.0", type: DaterangepickerDirective, selector: "[cqaDaterangepicker]", inputs: { options: "options", startDate: "startDate", endDate: "endDate", minDate: "minDate", maxDate: "maxDate" }, outputs: { datesUpdated: "datesUpdated", cancelClicked: "cancelClicked", applyClicked: "applyClicked" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => DaterangepickerDirective),
+            multi: true
+        }
+    ], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: DaterangepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[cqaDaterangepicker]',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => DaterangepickerDirective),
+                            multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { options: [{
+                type: Input
+            }], startDate: [{
+                type: Input
+            }], endDate: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], datesUpdated: [{
+                type: Output
+            }], cancelClicked: [{
+                type: Output
+            }], applyClicked: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker.directive.js","sourceRoot":"","sources":["../../../../../../src/lib/filters/daterangepicker/daterangepicker.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, Input, Output, EventEmitter, OnInit, OnDestroy, OnChanges, SimpleChanges, forwardRef } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport * as jquery from 'jquery';\nimport * as momentImport from 'moment';\nimport 'daterangepicker';\n\n// Normalize module default/namespace interop for both ESM and CJS builds.\nconst $: any = (jquery as any).default || (jquery as any);\nconst moment: any = (momentImport as any).default || (momentImport as any);\n\n// Ensure globals are present for the daterangepicker plugin registration.\nif (typeof window !== 'undefined') {\n  (window as any).jQuery = (window as any).jQuery || $;\n  (window as any).$ = (window as any).$ || $;\n  (window as any).moment = (window as any).moment || moment;\n}\n\nexport interface DateRangePickerOptions {\n  startDate?: Date | string;\n  endDate?: Date | string;\n  minDate?: Date | string;\n  maxDate?: Date | string;\n  locale?: any;\n  ranges?: any;\n  opens?: 'left' | 'right' | 'center';\n  drops?: 'down' | 'up' | 'auto';\n  buttonClasses?: string;\n  applyButtonClasses?: string;\n  cancelButtonClasses?: string;\n  autoApply?: boolean;\n  alwaysShowCalendars?: boolean;\n  showDropdowns?: boolean;\n  showWeekNumbers?: boolean;\n  showISOWeekNumbers?: boolean;\n  singleDatePicker?: boolean;\n  timePicker?: boolean;\n  timePicker24Hour?: boolean;\n  timePickerIncrement?: number;\n  timePickerSeconds?: boolean;\n  linkedCalendars?: boolean;\n  autoUpdateInput?: boolean;\n  isInvalidDate?: (date: Date) => boolean;\n  isCustomDate?: (date: Date) => string | boolean;\n  parentEl?: string;\n}\n\n@Directive({\n  selector: '[cqaDaterangepicker]',\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => DaterangepickerDirective),\n      multi: true\n    }\n  ]\n})\nexport class DaterangepickerDirective implements OnInit, OnDestroy, OnChanges, ControlValueAccessor {\n  @Input() options: DateRangePickerOptions = {};\n  @Input() startDate?: Date | string;\n  @Input() endDate?: Date | string;\n  @Input() minDate?: Date | string;\n  @Input() maxDate?: Date | string;\n  @Output() datesUpdated = new EventEmitter<{ startDate: Date | null; endDate: Date | null }>();\n  @Output() cancelClicked = new EventEmitter<void>();\n  @Output() applyClicked = new EventEmitter<{ startDate: Date | null; endDate: Date | null }>();\n\n  private pickerInstance: any;\n  private onChange = (value: any) => {};\n  private onTouched = () => {};\n\n  /**\n   * Safely update the input text to avoid \"Invalid date\" or \"undefined\" strings.\n   */\n  private updateInputValue(start: any, end: any): void {\n    if (typeof (window as any).moment === 'undefined') return;\n    const m = (window as any).moment;\n    const format = (this.options?.locale && this.options.locale.format) || 'MM/DD/YYYY';\n    const separator = (this.options?.locale && this.options.locale.separator) || ' - ';\n\n    const hasStart = start && m.isMoment(start);\n    const hasEnd = end && m.isMoment(end);\n\n    if (hasStart && hasEnd) {\n      try {\n        const text = `${start.format(format)}${separator}${end.format(format)}`;\n        $(this.el.nativeElement).val(text);\n      } catch {}\n    } else {\n      try {\n        $(this.el.nativeElement).val('');\n      } catch {}\n    }\n  }\n\n  constructor(private el: ElementRef) {}\n\n  ngOnInit(): void {\n    this.initDaterangepicker();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (this.pickerInstance) {\n      if (changes['startDate'] || changes['endDate']) {\n        this.updateDates();\n      }\n      if (changes['minDate'] || changes['maxDate']) {\n        this.updateMinMaxDates();\n      }\n      if (changes['options']) {\n        this.destroyPicker();\n        this.initDaterangepicker();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroyPicker();\n  }\n\n  private initDaterangepicker(): void {\n    if (typeof $ === 'undefined' || typeof ($.fn as any).daterangepicker === 'undefined') {\n      console.error('jQuery and daterangepicker must be loaded');\n      return;\n    }\n\n    // Check if moment.js is available\n    if (typeof (window as any).moment === 'undefined') {\n      console.error('moment.js must be loaded for daterangepicker to work');\n      return;\n    }\n\n    // Resolve parent element to scope styles; default to closest .cqa-ui-daterange-picker, fallback to body.\n    const parentElCandidate = $(this.el.nativeElement).closest('.cqa-ui-daterange-picker');\n    const resolvedParentEl = this.options?.parentEl\n      ? this.options.parentEl\n      : (parentElCandidate && parentElCandidate.length ? parentElCandidate : 'body');\n\n    const baseOptions: DateRangePickerOptions = {\n      opens: 'left',\n      drops: 'down',\n      autoApply: true,\n      autoUpdateInput: false, // we manage the input ourselves to prevent \"Invalid date\"\n      locale: {\n        format: 'MM/DD/YYYY',\n        separator: ' - ',\n        applyLabel: 'Apply',\n        cancelLabel: 'Cancel',\n        fromLabel: 'From',\n        toLabel: 'To',\n        customRangeLabel: 'Custom',\n        weekLabel: 'W',\n        daysOfWeek: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],\n        monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'],\n        firstDay: 0\n      },\n      parentEl: resolvedParentEl as any\n    };\n\n    // Merge options but force-disable plugin autoUpdateInput to avoid invalid values.\n    const defaultOptions: DateRangePickerOptions = {\n      ...baseOptions,\n      ...this.options,\n      locale: {\n        ...baseOptions.locale,\n        ...(this.options?.locale || {})\n      },\n      autoUpdateInput: false\n    };\n\n    // Convert Date objects to moment objects for daterangepicker\n    const toMoment = (d: Date | string | null | undefined): any => {\n      if (!d) return null;\n      if (typeof d === 'string') {\n        const lower = d.trim().toLowerCase();\n        if (lower === 'undefined' || lower === 'null' || lower === '') return null;\n      }\n      if (moment.isMoment && moment.isMoment(d)) return d;\n      const date = typeof d === 'string' ? new Date(d) : d;\n      if (date instanceof Date && !isNaN(date.getTime())) {\n        return moment(date);\n      }\n      return null;\n    };\n    \n    const startMoment = toMoment(this.startDate);\n    const endMoment = toMoment(this.endDate);\n    const minMoment = toMoment(this.minDate);\n    const maxMoment = toMoment(this.maxDate);\n    \n    if (startMoment) defaultOptions.startDate = startMoment;\n    if (endMoment) defaultOptions.endDate = endMoment;\n    if (minMoment) defaultOptions.minDate = minMoment;\n    if (maxMoment) defaultOptions.maxDate = maxMoment;\n\n    // If no initial dates, ensure the input is blank before plugin init.\n    if (!startMoment && !endMoment) {\n      try { $(this.el.nativeElement).val(''); } catch {}\n    }\n\n    // Initialize the picker\n    $(this.el.nativeElement).daterangepicker(defaultOptions, (start: any, end: any, label: string) => {\n      const startDate = start ? start.toDate() : null;\n      const endDate = end ? end.toDate() : null;\n      \n      this.onChange({ start: startDate, end: endDate });\n      this.datesUpdated.emit({ startDate, endDate });\n      this.applyClicked.emit({ startDate, endDate });\n      this.updateInputValue(start, end);\n    });\n\n    this.pickerInstance = $(this.el.nativeElement).data('daterangepicker');\n\n    // Ensure the overlay gets the styling scope class if not already present.\n    if (this.pickerInstance?.container) {\n      const c = this.pickerInstance.container;\n      if (!c.hasClass('cqa-ui-daterange-picker')) {\n        c.addClass('cqa-ui-daterange-picker');\n      }\n    }\n\n    // Handle cancel event\n    $(this.el.nativeElement).on('cancel.daterangepicker', () => {\n      this.cancelClicked.emit();\n      this.updateInputValue(null, null);\n    });\n\n    // Update initial value if provided\n    this.updateDates();\n  }\n\n  private updateDates(): void {\n    if (!this.pickerInstance) return;\n    if (typeof (window as any).moment === 'undefined') return;\n\n    const moment = (window as any).moment;\n    \n    // Convert Date objects to moment objects\n    const toMoment = (d: Date | string | null | undefined): any => {\n      if (!d) return null;\n      if (typeof d === 'string') {\n        const lower = d.trim().toLowerCase();\n        if (lower === 'undefined' || lower === 'null' || lower === '') return null;\n      }\n      if (moment.isMoment && moment.isMoment(d)) return d;\n      const date = typeof d === 'string' ? new Date(d) : d;\n      if (date instanceof Date && !isNaN(date.getTime())) {\n        return moment(date);\n      }\n      return null;\n    };\n    \n    const startMoment = toMoment(this.startDate);\n    const endMoment = toMoment(this.endDate);\n    \n    if (startMoment) {\n      this.pickerInstance.setStartDate(startMoment);\n    }\n    \n    if (endMoment) {\n      this.pickerInstance.setEndDate(endMoment);\n    }\n    \n    // Update input text to reflect current values\n    this.updateInputValue(startMoment, endMoment);\n  }\n\n  private updateMinMaxDates(): void {\n    if (!this.pickerInstance) return;\n    if (typeof (window as any).moment === 'undefined') return;\n\n    const moment = (window as any).moment;\n    \n    // Convert Date objects to moment objects\n    const toMoment = (d: Date | string | null | undefined): any => {\n      if (!d) return null;\n      if (moment.isMoment && moment.isMoment(d)) return d;\n      const date = typeof d === 'string' ? new Date(d) : d;\n      if (date instanceof Date && !isNaN(date.getTime())) {\n        return moment(date);\n      }\n      return null;\n    };\n    \n    const minMoment = toMoment(this.minDate);\n    const maxMoment = toMoment(this.maxDate);\n    \n    if (minMoment) {\n      this.pickerInstance.setMinDate(minMoment);\n    }\n    if (maxMoment) {\n      this.pickerInstance.setMaxDate(maxMoment);\n    }\n  }\n\n  private destroyPicker(): void {\n    if (this.pickerInstance && typeof $ !== 'undefined') {\n      $(this.el.nativeElement).off('cancel.daterangepicker');\n      $(this.el.nativeElement).data('daterangepicker')?.remove();\n      this.pickerInstance = null;\n    }\n  }\n\n  // ControlValueAccessor implementation\n  writeValue(value: { start: Date | null; end: Date | null } | null): void {\n    if (value && (value.start || value.end)) {\n      // Validate dates before setting\n      const isValidDate = (d: Date | null): boolean => {\n        return d !== null && d instanceof Date && !isNaN(d.getTime());\n      };\n      \n      this.startDate = (value.start && isValidDate(value.start)) ? value.start : undefined;\n      this.endDate = (value.end && isValidDate(value.end)) ? value.end : undefined;\n      this.updateDates();\n    } else if (value === null || (value && !value.start && !value.end)) {\n      this.startDate = undefined;\n      this.endDate = undefined;\n      if (this.pickerInstance) {\n        try {\n          const m = (window as any).moment;\n          if (m) {\n            // Reset picker internals to a safe value instead of null to avoid \"Invalid date\"\n            this.pickerInstance.setStartDate(m());\n            this.pickerInstance.setEndDate(m());\n          }\n          this.updateInputValue(null, null);\n        } catch {}\n      }\n    }\n  }\n\n  registerOnChange(fn: (value: any) => void): void {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn;\n  }\n\n  setDisabledState(isDisabled: boolean): void {\n    if (this.el.nativeElement) {\n      this.el.nativeElement.disabled = isDisabled;\n    }\n  }\n}\n\n"]}