@wlcm/angular 18.2.25 → 18.2.28

package/datepicker/esm2022/lib/components/single/datepicker-input-container/datepicker-input-container.component.mjs

@@ -0,0 +1,92 @@
+import { Component, ElementRef, Host, Inject, ViewContainerRef, contentChild, forwardRef, inject, } from '@angular/core';
+import { MatDateSelectionModel, MatSingleDateSelectionModel } from '@angular/material/datepicker';
+import { WLCM_FORM_FIELD, WLCM_INPUT_BINDER } from '@wlcm/angular/forms';
+import { WlcmDatepickerInputDirective } from '../../../directives/single/datepicker-input.directive';
+import { WlcmDatepickerPanelComponent } from '../datepicker-panel/datepicker-panel.component';
+import { BehaviorSubject, EMPTY, switchMap, fromEvent, merge, map } from 'rxjs';
+import { WlcmDatepickerTrigger } from '../../../directives/datepicker-trigger.base';
+import { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+import { Overlay } from '@angular/cdk/overlay';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/material/datepicker";
+export class WlcmDatepickerInputContainerComponent extends WlcmDatepickerTrigger {
+    constructor(overlay, viewContainerRef, selectionModel, formField) {
+        super(overlay, viewContainerRef, selectionModel);
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.selectionModel = selectionModel;
+        this.formField = formField;
+        this._focusStream$ = new BehaviorSubject(EMPTY);
+        this._blurStream$ = new BehaviorSubject(EMPTY);
+        this.focus$ = this._focusStream$.pipe(switchMap((stream) => stream));
+        this.blur$ = this._blurStream$.pipe(switchMap((stream) => stream));
+        this.inputRef = contentChild(WlcmDatepickerInputDirective, {
+            read: ElementRef,
+        });
+        this.componentType = WlcmDatepickerPanelComponent;
+        this.focus = () => {
+            if (this.selectOnly())
+                return this.open();
+            this.inputElement?.focus();
+        };
+        this.isFocused = () => {
+            return this.inputElement === document.activeElement || this.isOpen;
+        };
+    }
+    ngAfterContentInit() {
+        this.attachFocusBlurListeners();
+    }
+    ngAfterViewInit() {
+        this.connectedTo = this.formField.inputContainer;
+    }
+    get inputElement() {
+        return this.inputRef()?.nativeElement;
+    }
+    attachFocusBlurListeners() {
+        const voidFn = () => { };
+        const inputFocus = fromEvent(this.inputElement, 'focus');
+        const inputBlur = fromEvent(this.inputElement, 'blur');
+        const focusObservables = [inputFocus, this.opened];
+        const blurObservables = [inputBlur, this.closed];
+        this._focusStream$.next(merge(...focusObservables).pipe(map(voidFn)));
+        this._blurStream$.next(merge(...blurObservables).pipe(map(voidFn)));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerInputContainerComponent, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.MatDateSelectionModel }, { token: WLCM_FORM_FIELD, host: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.6", type: WlcmDatepickerInputContainerComponent, isStandalone: true, selector: "wlcm-datepicker-input-container", host: { classAttribute: "wlcm-datepicker-input-container" }, providers: [
+            {
+                provide: WLCM_INPUT_BINDER,
+                useFactory: () => {
+                    const input = inject(WlcmDatepickerInputContainerComponent, { self: true });
+                    return { bind: () => input };
+                },
+            },
+            { provide: NG_VALIDATORS, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },
+            { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },
+            { provide: WlcmDatepickerTrigger, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent) },
+            { provide: MatDateSelectionModel, useClass: MatSingleDateSelectionModel },
+        ], queries: [{ propertyName: "inputRef", first: true, predicate: WlcmDatepickerInputDirective, descendants: true, read: ElementRef, isSignal: true }], exportAs: ["wlcmDatepicker"], usesInheritance: true, ngImport: i0, template: "<ng-content select=\"[wlcmDatepickerInput]\"></ng-content>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerInputContainerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'wlcm-datepicker-input-container', host: { class: 'wlcm-datepicker-input-container' }, exportAs: 'wlcmDatepicker', standalone: true, imports: [CommonModule], providers: [
+                        {
+                            provide: WLCM_INPUT_BINDER,
+                            useFactory: () => {
+                                const input = inject(WlcmDatepickerInputContainerComponent, { self: true });
+                                return { bind: () => input };
+                            },
+                        },
+                        { provide: NG_VALIDATORS, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },
+                        { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },
+                        { provide: WlcmDatepickerTrigger, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent) },
+                        { provide: MatDateSelectionModel, useClass: MatSingleDateSelectionModel },
+                    ], template: "<ng-content select=\"[wlcmDatepickerInput]\"></ng-content>\n" }]
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.MatDateSelectionModel }, { type: undefined, decorators: [{
+                    type: Host
+                }, {
+                    type: Inject,
+                    args: [WLCM_FORM_FIELD]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-input-container.component.js","sourceRoot":"","sources":["../../../../../../../../modules/datepicker/src/lib/components/single/datepicker-input-container/datepicker-input-container.component.ts","../../../../../../../../modules/datepicker/src/lib/components/single/datepicker-input-container/datepicker-input-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterContentInit,\n  Component,\n  ElementRef,\n  Host,\n  Inject,\n  Signal,\n  ViewContainerRef,\n  contentChild,\n  forwardRef,\n  inject,\n} from '@angular/core';\nimport { MatDateSelectionModel, MatSingleDateSelectionModel } from '@angular/material/datepicker';\nimport { WLCM_FORM_FIELD, WLCM_INPUT_BINDER, WlcmFormField, WlcmFormFieldInput } from '@wlcm/angular/forms';\nimport { WlcmDatepickerInputDirective } from '../../../directives/single/datepicker-input.directive';\nimport { WlcmDatepickerPanelComponent } from '../datepicker-panel/datepicker-panel.component';\nimport { BehaviorSubject, Observable, EMPTY, switchMap, fromEvent, merge, map } from 'rxjs';\nimport { WlcmDatepickerTrigger } from '../../../directives/datepicker-trigger.base';\nimport { NG_VALIDATORS, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { CommonModule } from '@angular/common';\nimport { Overlay } from '@angular/cdk/overlay';\n\n@Component({\n  selector: 'wlcm-datepicker-input-container',\n  host: { class: 'wlcm-datepicker-input-container' },\n  exportAs: 'wlcmDatepicker',\n  standalone: true,\n  imports: [CommonModule],\n  templateUrl: './datepicker-input-container.component.html',\n  styleUrl: './datepicker-input-container.component.scss',\n  providers: [\n    {\n      provide: WLCM_INPUT_BINDER,\n      useFactory: () => {\n        const input = inject(WlcmDatepickerInputContainerComponent, { self: true });\n\n        return { bind: () => input };\n      },\n    },\n    { provide: NG_VALIDATORS, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },\n    { provide: NG_VALUE_ACCESSOR, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent), multi: true },\n    { provide: WlcmDatepickerTrigger, useExisting: forwardRef(() => WlcmDatepickerInputContainerComponent) },\n    { provide: MatDateSelectionModel, useClass: MatSingleDateSelectionModel },\n  ],\n})\nexport class WlcmDatepickerInputContainerComponent<T>\n  extends WlcmDatepickerTrigger<WlcmDatepickerPanelComponent<T>>\n  implements WlcmFormFieldInput, AfterContentInit\n{\n  private readonly _focusStream$: BehaviorSubject<Observable<void>> = new BehaviorSubject(EMPTY as Observable<void>);\n\n  private readonly _blurStream$: BehaviorSubject<Observable<void>> = new BehaviorSubject(EMPTY as Observable<void>);\n\n  focus$: Observable<unknown> = this._focusStream$.pipe(switchMap((stream: Observable<unknown>) => stream));\n\n  blur$: Observable<unknown> = this._blurStream$.pipe(switchMap((stream: Observable<unknown>) => stream));\n\n  inputRef: Signal<ElementRef<HTMLInputElement> | undefined> = contentChild(WlcmDatepickerInputDirective, {\n    read: ElementRef,\n  });\n\n  protected override componentType = WlcmDatepickerPanelComponent;\n\n  protected override connectedTo!: ElementRef<HTMLElement>;\n\n  constructor(\n    protected override overlay: Overlay,\n    protected override viewContainerRef: ViewContainerRef,\n    protected override selectionModel: MatDateSelectionModel<Date>,\n    @Host() @Inject(WLCM_FORM_FIELD) private formField: WlcmFormField,\n  ) {\n    super(overlay, viewContainerRef, selectionModel);\n  }\n\n  ngAfterContentInit(): void {\n    this.attachFocusBlurListeners();\n  }\n\n  ngAfterViewInit(): void {\n    this.connectedTo = this.formField.inputContainer;\n  }\n\n  focus = (): void => {\n    if (this.selectOnly()) return this.open();\n\n    this.inputElement?.focus();\n  };\n\n  isFocused = (): boolean => {\n    return this.inputElement === document.activeElement || this.isOpen;\n  };\n\n  private get inputElement(): HTMLInputElement | undefined {\n    return this.inputRef()?.nativeElement;\n  }\n\n  private attachFocusBlurListeners(): void {\n    const voidFn = () => {};\n\n    const inputFocus: Observable<Event> = fromEvent(this.inputElement!, 'focus');\n\n    const inputBlur: Observable<Event> = fromEvent(this.inputElement!, 'blur');\n\n    const focusObservables: Observable<unknown>[] = [inputFocus, this.opened];\n\n    const blurObservables: Observable<unknown>[] = [inputBlur, this.closed];\n\n    this._focusStream$.next(merge(...focusObservables).pipe(map(voidFn)));\n\n    this._blurStream$.next(merge(...blurObservables).pipe(map(voidFn)));\n  }\n}\n","<ng-content select=\"[wlcmDatepickerInput]\"></ng-content>\n"]}

package/datepicker/esm2022/lib/components/single/datepicker-panel/datepicker-panel.component.mjs

@@ -0,0 +1,33 @@
+import { Component, Inject, viewChild } from '@angular/core';
+import { MatCalendar, MatDateSelectionModel, MatDatepickerModule } from '@angular/material/datepicker';
+import { WlcmCalendarHeaderComponent } from '../../calendar-header/calendar-header.component';
+import { WlcmDatepickerTrigger } from '../../../directives/datepicker-trigger.base';
+import { WLCM_DATEPICKER_CONFIG } from '../../../constants/datepicker.constants';
+import { WlcmCalendarDirective } from '../../../directives/calendar.directive';
+import { CommonModule } from '@angular/common';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/datepicker";
+import * as i2 from "../../../directives/datepicker-trigger.base";
+export class WlcmDatepickerPanelComponent {
+    constructor(selectionModel, trigger, config) {
+        this.selectionModel = selectionModel;
+        this.trigger = trigger;
+        this.config = config;
+        this.headerComponent = WlcmCalendarHeaderComponent;
+        this.matCalendar = viewChild(MatCalendar);
+    }
+    select(date) {
+        this.selectionModel.updateSelection(date, this);
+        this.trigger.close();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerPanelComponent, deps: [{ token: i1.MatDateSelectionModel }, { token: i2.WlcmDatepickerTrigger }, { token: WLCM_DATEPICKER_CONFIG }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.6", type: WlcmDatepickerPanelComponent, isStandalone: true, selector: "wlcm-datepicker-panel", host: { classAttribute: "wlcm-datepicker-panel" }, viewQueries: [{ propertyName: "matCalendar", first: true, predicate: MatCalendar, descendants: true, isSignal: true }], ngImport: i0, template: "<mat-calendar\n  wlcmCalendar\n  [minDate]=\"config.minDate?.()\"\n  [maxDate]=\"config.maxDate?.()\"\n  [startAt]=\"selectionModel.selection\"\n  [selected]=\"selectionModel.selection\"\n  [headerComponent]=\"headerComponent\"\n  (selectedChange)=\"select($event)\"\n></mat-calendar>\n", styles: [""], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatDatepickerModule }, { kind: "component", type: i1.MatCalendar, selector: "mat-calendar", inputs: ["headerComponent", "startAt", "startView", "selected", "minDate", "maxDate", "dateFilter", "dateClass", "comparisonStart", "comparisonEnd", "startDateAccessibleName", "endDateAccessibleName"], outputs: ["selectedChange", "yearSelected", "monthSelected", "viewChanged", "_userSelection", "_userDragDrop"], exportAs: ["matCalendar"] }, { kind: "directive", type: WlcmCalendarDirective, selector: "[wlcmCalendar]" }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerPanelComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'wlcm-datepicker-panel', host: { class: 'wlcm-datepicker-panel' }, standalone: true, imports: [CommonModule, MatDatepickerModule, WlcmCalendarDirective], template: "<mat-calendar\n  wlcmCalendar\n  [minDate]=\"config.minDate?.()\"\n  [maxDate]=\"config.maxDate?.()\"\n  [startAt]=\"selectionModel.selection\"\n  [selected]=\"selectionModel.selection\"\n  [headerComponent]=\"headerComponent\"\n  (selectedChange)=\"select($event)\"\n></mat-calendar>\n" }]
+        }], ctorParameters: () => [{ type: i1.MatDateSelectionModel }, { type: i2.WlcmDatepickerTrigger }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [WLCM_DATEPICKER_CONFIG]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2022/lib/constants/datepicker.constants.mjs

@@ -0,0 +1,23 @@
+import { InjectionToken } from '@angular/core';
+import { DateAdapter, MAT_DATE_FORMATS, MAT_DATE_LOCALE } from '@angular/material/core';
+import { WlcmDateAdapter } from '../models/date-picker.models';
+import { enUS } from 'date-fns/locale';
+export const WLCM_DEFAULT_DATE_FORMATS = {
+    parse: {
+        dateInput: 'MMM/dd/yyyy',
+    },
+    display: {
+        dateInput: 'MMM/dd/yyyy',
+        monthYearLabel: 'MMMM yyyy',
+        dateA11yLabel: 'MMM/dd/yyyy',
+        monthYearA11yLabel: 'MMM yyyy',
+    },
+};
+export const WLCM_DEFAULT_DATEPICKER_PROVIDERS = [
+    { provide: MAT_DATE_LOCALE, useValue: enUS },
+    { provide: MAT_DATE_FORMATS, useValue: WLCM_DEFAULT_DATE_FORMATS },
+    { provide: DateAdapter, useClass: WlcmDateAdapter, deps: [MAT_DATE_LOCALE] },
+];
+export const WLCM_DATEPICKER_CONFIG = new InjectionToken('WLCM_DATEPICKER_CONFIG', { providedIn: 'root', factory: () => ({ selectOnly: false }) });
+export const WLCM_DATEPICKER_INPUT_CLASS = 'wlcm-datepicker-input';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZXBpY2tlci5jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL2RhdGVwaWNrZXIvc3JjL2xpYi9jb25zdGFudHMvZGF0ZXBpY2tlci5jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUN6RCxPQUFPLEVBQUUsV0FBVyxFQUFFLGdCQUFnQixFQUFFLGVBQWUsRUFBa0IsTUFBTSx3QkFBd0IsQ0FBQztBQUV4RyxPQUFPLEVBQUUsZUFBZSxFQUF3QixNQUFNLDhCQUE4QixDQUFDO0FBQ3JGLE9BQU8sRUFBRSxJQUFJLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUV2QyxNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBbUI7SUFDdkQsS0FBSyxFQUFFO1FBQ0wsU0FBUyxFQUFFLGFBQWE7S0FDekI7SUFDRCxPQUFPLEVBQUU7UUFDUCxTQUFTLEVBQUUsYUFBYTtRQUN4QixjQUFjLEVBQUUsV0FBVztRQUMzQixhQUFhLEVBQUUsYUFBYTtRQUM1QixrQkFBa0IsRUFBRSxVQUFVO0tBQy9CO0NBQ0YsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGlDQUFpQyxHQUFlO0lBQzNELEVBQUUsT0FBTyxFQUFFLGVBQWUsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO0lBQzVDLEVBQUUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLFFBQVEsRUFBRSx5QkFBeUIsRUFBRTtJQUNsRSxFQUFFLE9BQU8sRUFBRSxXQUFXLEVBQUUsUUFBUSxFQUFFLGVBQWUsRUFBRSxJQUFJLEVBQUUsQ0FBQyxlQUFlLENBQUMsRUFBRTtDQUM3RSxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sc0JBQXNCLEdBQXlDLElBQUksY0FBYyxDQUM1Rix3QkFBd0IsRUFDeEIsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyxDQUFDLEVBQUUsVUFBVSxFQUFFLEtBQUssRUFBRSxDQUFDLEVBQUUsQ0FDL0QsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLDJCQUEyQixHQUFHLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBEYXRlQWRhcHRlciwgTUFUX0RBVEVfRk9STUFUUywgTUFUX0RBVEVfTE9DQUxFLCBNYXREYXRlRm9ybWF0cyB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xuXG5pbXBvcnQgeyBXbGNtRGF0ZUFkYXB0ZXIsIFdsY21EYXRlcGlja2VyQ29uZmlnIH0gZnJvbSAnLi4vbW9kZWxzL2RhdGUtcGlja2VyLm1vZGVscyc7XG5pbXBvcnQgeyBlblVTIH0gZnJvbSAnZGF0ZS1mbnMvbG9jYWxlJztcblxuZXhwb3J0IGNvbnN0IFdMQ01fREVGQVVMVF9EQVRFX0ZPUk1BVFM6IE1hdERhdGVGb3JtYXRzID0ge1xuICBwYXJzZToge1xuICAgIGRhdGVJbnB1dDogJ01NTS9kZC95eXl5JyxcbiAgfSxcbiAgZGlzcGxheToge1xuICAgIGRhdGVJbnB1dDogJ01NTS9kZC95eXl5JyxcbiAgICBtb250aFllYXJMYWJlbDogJ01NTU0geXl5eScsXG4gICAgZGF0ZUExMXlMYWJlbDogJ01NTS9kZC95eXl5JyxcbiAgICBtb250aFllYXJBMTF5TGFiZWw6ICdNTU0geXl5eScsXG4gIH0sXG59O1xuXG5leHBvcnQgY29uc3QgV0xDTV9ERUZBVUxUX0RBVEVQSUNLRVJfUFJPVklERVJTOiBQcm92aWRlcltdID0gW1xuICB7IHByb3ZpZGU6IE1BVF9EQVRFX0xPQ0FMRSwgdXNlVmFsdWU6IGVuVVMgfSxcbiAgeyBwcm92aWRlOiBNQVRfREFURV9GT1JNQVRTLCB1c2VWYWx1ZTogV0xDTV9ERUZBVUxUX0RBVEVfRk9STUFUUyB9LFxuICB7IHByb3ZpZGU6IERhdGVBZGFwdGVyLCB1c2VDbGFzczogV2xjbURhdGVBZGFwdGVyLCBkZXBzOiBbTUFUX0RBVEVfTE9DQUxFXSB9LFxuXTtcblxuZXhwb3J0IGNvbnN0IFdMQ01fREFURVBJQ0tFUl9DT05GSUc6IEluamVjdGlvblRva2VuPFdsY21EYXRlcGlja2VyQ29uZmlnPiA9IG5ldyBJbmplY3Rpb25Ub2tlbihcbiAgJ1dMQ01fREFURVBJQ0tFUl9DT05GSUcnLFxuICB7IHByb3ZpZGVkSW46ICdyb290JywgZmFjdG9yeTogKCkgPT4gKHsgc2VsZWN0T25seTogZmFsc2UgfSkgfSxcbik7XG5cbmV4cG9ydCBjb25zdCBXTENNX0RBVEVQSUNLRVJfSU5QVVRfQ0xBU1MgPSAnd2xjbS1kYXRlcGlja2VyLWlucHV0JztcbiJdfQ==

package/datepicker/esm2022/lib/constants/range/date-range-picker.constants.mjs

@@ -0,0 +1,5 @@
+import { InjectionToken } from '@angular/core';
+import { WlcmDateRangePickerBottomPanelComponent } from '../../components/range/date-range-picker-bottom-panel/date-range-picker-bottom-panel.component';
+export const WLCM_DATE_RANGE_PICKER_CONFIG = new InjectionToken('WLCM_DATE_RANGE_PICKER_CONFIG', { providedIn: 'root', factory: () => ({}) });
+export const WLCM_DATE_RANGE_PICKER_BP = new InjectionToken('WLCM_DATE_RANGE_PICKER_BP', { providedIn: 'root', factory: () => WlcmDateRangePickerBottomPanelComponent });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1yYW5nZS1waWNrZXIuY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRlcGlja2VyL3NyYy9saWIvY29uc3RhbnRzL3JhbmdlL2RhdGUtcmFuZ2UtcGlja2VyLmNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFRLE1BQU0sZUFBZSxDQUFDO0FBRXJELE9BQU8sRUFBRSx1Q0FBdUMsRUFBRSxNQUFNLGdHQUFnRyxDQUFDO0FBRXpKLE1BQU0sQ0FBQyxNQUFNLDZCQUE2QixHQUE4QyxJQUFJLGNBQWMsQ0FDeEcsK0JBQStCLEVBQy9CLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQyxFQUFFLENBQUMsRUFBRSxDQUM1QyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQWtDLElBQUksY0FBYyxDQUN4RiwyQkFBMkIsRUFDM0IsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLEVBQUUsQ0FBQyx1Q0FBdUMsRUFBRSxDQUMvRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFR5cGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFdsY21EYXRlUmFuZ2VQaWNrZXJDb25maWcgfSBmcm9tICcuLi8uLi9tb2RlbHMvcmFuZ2UvZGF0ZS1yYW5nZS1waWNrZXIubW9kZWxzJztcbmltcG9ydCB7IFdsY21EYXRlUmFuZ2VQaWNrZXJCb3R0b21QYW5lbENvbXBvbmVudCB9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvcmFuZ2UvZGF0ZS1yYW5nZS1waWNrZXItYm90dG9tLXBhbmVsL2RhdGUtcmFuZ2UtcGlja2VyLWJvdHRvbS1wYW5lbC5jb21wb25lbnQnO1xuXG5leHBvcnQgY29uc3QgV0xDTV9EQVRFX1JBTkdFX1BJQ0tFUl9DT05GSUc6IEluamVjdGlvblRva2VuPFdsY21EYXRlUmFuZ2VQaWNrZXJDb25maWc+ID0gbmV3IEluamVjdGlvblRva2VuKFxuICAnV0xDTV9EQVRFX1JBTkdFX1BJQ0tFUl9DT05GSUcnLFxuICB7IHByb3ZpZGVkSW46ICdyb290JywgZmFjdG9yeTogKCkgPT4gKHt9KSB9LFxuKTtcblxuZXhwb3J0IGNvbnN0IFdMQ01fREFURV9SQU5HRV9QSUNLRVJfQlA6IEluamVjdGlvblRva2VuPFR5cGU8dW5rbm93bj4+ID0gbmV3IEluamVjdGlvblRva2VuKFxuICAnV0xDTV9EQVRFX1JBTkdFX1BJQ0tFUl9CUCcsXG4gIHsgcHJvdmlkZWRJbjogJ3Jvb3QnLCBmYWN0b3J5OiAoKSA9PiBXbGNtRGF0ZVJhbmdlUGlja2VyQm90dG9tUGFuZWxDb21wb25lbnQgfSxcbik7XG4iXX0=

package/datepicker/esm2022/lib/constants/range/date-range-selection-model.constants.mjs

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { DateAdapter } from '@angular/material/core';
+import { MatRangeDateSelectionModel } from '@angular/material/datepicker';
+export const WLCM_DATE_RANGE_SELECTION_MODEL = new InjectionToken('WLCM_DATE_RANGE_SELECTION_MODEL');
+export const WLCM_DATE_RANGE_SELECTION_MODEL_PROVIDER = {
+    provide: WLCM_DATE_RANGE_SELECTION_MODEL,
+    useFactory: (adapter) => new MatRangeDateSelectionModel(adapter),
+    deps: [DateAdapter],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1yYW5nZS1zZWxlY3Rpb24tbW9kZWwuY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRlcGlja2VyL3NyYy9saWIvY29uc3RhbnRzL3JhbmdlL2RhdGUtcmFuZ2Utc2VsZWN0aW9uLW1vZGVsLmNvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFZLE1BQU0sZUFBZSxDQUFDO0FBQ3pELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUNyRCxPQUFPLEVBQXlCLDBCQUEwQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFFakcsTUFBTSxDQUFDLE1BQU0sK0JBQStCLEdBQWdELElBQUksY0FBYyxDQUM1RyxpQ0FBaUMsQ0FDbEMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLHdDQUF3QyxHQUFhO0lBQ2hFLE9BQU8sRUFBRSwrQkFBK0I7SUFDeEMsVUFBVSxFQUFFLENBQUMsT0FBMEIsRUFBRSxFQUFFLENBQUMsSUFBSSwwQkFBMEIsQ0FBQyxPQUFPLENBQUM7SUFDbkYsSUFBSSxFQUFFLENBQUMsV0FBVyxDQUFDO0NBQ3BCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiwgUHJvdmlkZXIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERhdGVBZGFwdGVyIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvY29yZSc7XG5pbXBvcnQgeyBNYXREYXRlU2VsZWN0aW9uTW9kZWwsIE1hdFJhbmdlRGF0ZVNlbGVjdGlvbk1vZGVsIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGF0ZXBpY2tlcic7XG5cbmV4cG9ydCBjb25zdCBXTENNX0RBVEVfUkFOR0VfU0VMRUNUSU9OX01PREVMOiBJbmplY3Rpb25Ub2tlbjxNYXREYXRlU2VsZWN0aW9uTW9kZWw8RGF0ZT4+ID0gbmV3IEluamVjdGlvblRva2VuKFxuICAnV0xDTV9EQVRFX1JBTkdFX1NFTEVDVElPTl9NT0RFTCdcbik7XG5cbmV4cG9ydCBjb25zdCBXTENNX0RBVEVfUkFOR0VfU0VMRUNUSU9OX01PREVMX1BST1ZJREVSOiBQcm92aWRlciA9IHtcbiAgcHJvdmlkZTogV0xDTV9EQVRFX1JBTkdFX1NFTEVDVElPTl9NT0RFTCxcbiAgdXNlRmFjdG9yeTogKGFkYXB0ZXI6IERhdGVBZGFwdGVyPERhdGU+KSA9PiBuZXcgTWF0UmFuZ2VEYXRlU2VsZWN0aW9uTW9kZWwoYWRhcHRlciksXG4gIGRlcHM6IFtEYXRlQWRhcHRlcl0sXG59O1xuIl19

package/datepicker/esm2022/lib/constants/range/date-range-trigger-selection-model.constants.mjs

@@ -0,0 +1,10 @@
+import { InjectionToken } from '@angular/core';
+import { MatRangeDateSelectionModel } from '@angular/material/datepicker';
+import { DateAdapter } from '@angular/material/core';
+export const WLCM_DATE_RANGE_TRIGGER_SELECTION_MODEL = new InjectionToken('WLCM_DATE_RANGE_SELECTION_MODEL');
+export const WLCM_DATE_RANGE_TRIGGER_SELECTION_MODEL_PROVIDER = {
+    provide: WLCM_DATE_RANGE_TRIGGER_SELECTION_MODEL,
+    useFactory: (adapter) => new MatRangeDateSelectionModel(adapter),
+    deps: [DateAdapter],
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGF0ZS1yYW5nZS10cmlnZ2VyLXNlbGVjdGlvbi1tb2RlbC5jb25zdGFudHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9tb2R1bGVzL2RhdGVwaWNrZXIvc3JjL2xpYi9jb25zdGFudHMvcmFuZ2UvZGF0ZS1yYW5nZS10cmlnZ2VyLXNlbGVjdGlvbi1tb2RlbC5jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBWSxNQUFNLGVBQWUsQ0FBQztBQUN6RCxPQUFPLEVBQXlCLDBCQUEwQixFQUFFLE1BQU0sOEJBQThCLENBQUM7QUFDakcsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBRXJELE1BQU0sQ0FBQyxNQUFNLHVDQUF1QyxHQUFnRCxJQUFJLGNBQWMsQ0FDcEgsaUNBQWlDLENBQ2xDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxnREFBZ0QsR0FBYTtJQUN4RSxPQUFPLEVBQUUsdUNBQXVDO0lBQ2hELFVBQVUsRUFBRSxDQUFDLE9BQTBCLEVBQUUsRUFBRSxDQUFDLElBQUksMEJBQTBCLENBQUMsT0FBTyxDQUFDO0lBQ25GLElBQUksRUFBRSxDQUFDLFdBQVcsQ0FBQztDQUNwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0aW9uVG9rZW4sIFByb3ZpZGVyIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBNYXREYXRlU2VsZWN0aW9uTW9kZWwsIE1hdFJhbmdlRGF0ZVNlbGVjdGlvbk1vZGVsIH0gZnJvbSAnQGFuZ3VsYXIvbWF0ZXJpYWwvZGF0ZXBpY2tlcic7XG5pbXBvcnQgeyBEYXRlQWRhcHRlciB9IGZyb20gJ0Bhbmd1bGFyL21hdGVyaWFsL2NvcmUnO1xuXG5leHBvcnQgY29uc3QgV0xDTV9EQVRFX1JBTkdFX1RSSUdHRVJfU0VMRUNUSU9OX01PREVMOiBJbmplY3Rpb25Ub2tlbjxNYXREYXRlU2VsZWN0aW9uTW9kZWw8RGF0ZT4+ID0gbmV3IEluamVjdGlvblRva2VuKFxuICAnV0xDTV9EQVRFX1JBTkdFX1NFTEVDVElPTl9NT0RFTCdcbik7XG5cbmV4cG9ydCBjb25zdCBXTENNX0RBVEVfUkFOR0VfVFJJR0dFUl9TRUxFQ1RJT05fTU9ERUxfUFJPVklERVI6IFByb3ZpZGVyID0ge1xuICBwcm92aWRlOiBXTENNX0RBVEVfUkFOR0VfVFJJR0dFUl9TRUxFQ1RJT05fTU9ERUwsXG4gIHVzZUZhY3Rvcnk6IChhZGFwdGVyOiBEYXRlQWRhcHRlcjxEYXRlPikgPT4gbmV3IE1hdFJhbmdlRGF0ZVNlbGVjdGlvbk1vZGVsKGFkYXB0ZXIpLFxuICBkZXBzOiBbRGF0ZUFkYXB0ZXJdLFxufTtcbiJdfQ==

package/datepicker/esm2022/lib/datepicker.module.mjs

@@ -0,0 +1,33 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { WlcmDatepickerInputContainerComponent } from './components/single/datepicker-input-container/datepicker-input-container.component';
+import { WlcmDateRangePickerInputComponent } from './components/range/date-range-picker-input/date-range-picker-input.component';
+import { DateRangePickerInputStartDirective } from './directives/ragne/date-range-picker-input-start.directive';
+import { DateRangePickerInputEndDirective } from './directives/ragne/date-range-picker-input-end.directive';
+import { WlcmDatepickerInputDirective } from './directives/single/datepicker-input.directive';
+import { WLCM_DEFAULT_DATEPICKER_PROVIDERS } from './constants/datepicker.constants';
+import * as i0 from "@angular/core";
+const publicComponents = [WlcmDatepickerInputContainerComponent, WlcmDateRangePickerInputComponent];
+const publicDirectives = [
+    WlcmDatepickerInputDirective,
+    DateRangePickerInputStartDirective,
+    DateRangePickerInputEndDirective,
+];
+export class WlcmDatepickerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerModule, imports: [CommonModule, WlcmDatepickerInputContainerComponent, WlcmDateRangePickerInputComponent, WlcmDatepickerInputDirective,
+            DateRangePickerInputStartDirective,
+            DateRangePickerInputEndDirective], exports: [WlcmDatepickerInputContainerComponent, WlcmDateRangePickerInputComponent, WlcmDatepickerInputDirective,
+            DateRangePickerInputStartDirective,
+            DateRangePickerInputEndDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerModule, providers: [...WLCM_DEFAULT_DATEPICKER_PROVIDERS], imports: [CommonModule, publicComponents] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ...publicComponents, ...publicDirectives],
+                    exports: [...publicComponents, ...publicDirectives],
+                    providers: [...WLCM_DEFAULT_DATEPICKER_PROVIDERS],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/datepicker/esm2022/lib/directives/calendar.directive.mjs

@@ -0,0 +1,15 @@
+import { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class WlcmCalendarDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmCalendarDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.6", type: WlcmCalendarDirective, isStandalone: true, selector: "[wlcmCalendar]", host: { classAttribute: "wlcm-calendar" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmCalendarDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[wlcmCalendar]',
+                    host: { class: 'wlcm-calendar' },
+                    standalone: true,
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FsZW5kYXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbW9kdWxlcy9kYXRlcGlja2VyL3NyYy9saWIvZGlyZWN0aXZlcy9jYWxlbmRhci5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFPMUMsTUFBTSxPQUFPLHFCQUFxQjs4R0FBckIscUJBQXFCO2tHQUFyQixxQkFBcUI7OzJGQUFyQixxQkFBcUI7a0JBTGpDLFNBQVM7bUJBQUM7b0JBQ1QsUUFBUSxFQUFFLGdCQUFnQjtvQkFDMUIsSUFBSSxFQUFFLEVBQUUsS0FBSyxFQUFFLGVBQWUsRUFBRTtvQkFDaEMsVUFBVSxFQUFFLElBQUk7aUJBQ2pCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICBzZWxlY3RvcjogJ1t3bGNtQ2FsZW5kYXJdJyxcbiAgaG9zdDogeyBjbGFzczogJ3dsY20tY2FsZW5kYXInIH0sXG4gIHN0YW5kYWxvbmU6IHRydWUsXG59KVxuZXhwb3J0IGNsYXNzIFdsY21DYWxlbmRhckRpcmVjdGl2ZSB7fVxuIl19

package/datepicker/esm2022/lib/directives/datepicker-input.base.mjs

@@ -0,0 +1,103 @@
+import { Directive, ElementRef, HostBinding, HostListener } from '@angular/core';
+import { format, isAfter, isBefore, isValid, parse, startOfDay } from 'date-fns';
+import { WLCM_DATEPICKER_INPUT_CLASS } from '../constants/datepicker.constants';
+import { DateAdapter } from '@angular/material/core';
+import { WlcmDateValidation } from '../models/date-picker.models';
+import { WlcmDatepickerTrigger } from './datepicker-trigger.base';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/core";
+import * as i2 from "./datepicker-trigger.base";
+export class WlcmDatepickerInputBase {
+    handleBlur() {
+        this.updateSelection();
+        this._touched?.();
+    }
+    handleInput() {
+        if (this.isValidFormat(this.currentValue, this.dateFormats.parse.dateInput)) {
+            this.updateSelection();
+        }
+        this._validatorChanged?.();
+    }
+    get datepickerInputClass() {
+        return WLCM_DATEPICKER_INPUT_CLASS;
+    }
+    constructor(element, dateAdapter, dateFormats, trigger) {
+        this.element = element;
+        this.dateAdapter = dateAdapter;
+        this.dateFormats = dateFormats;
+        this.trigger = trigger;
+    }
+    writeValue(value) {
+        this.updateInputValue(value);
+    }
+    registerOnChange(callback) {
+        this._changed = callback;
+    }
+    registerOnTouched(callback) {
+        this._touched = callback;
+    }
+    registerOnValidatorChange(callback) {
+        this._validatorChanged = callback;
+    }
+    validate() {
+        if (!this.currentValue)
+            return null;
+        const isValid = this.isValidFormat(this.currentValue, this.dateFormats.parse.dateInput);
+        if (!isValid) {
+            return {
+                [WlcmDateValidation.Format]: { value: this.currentValue, format: this.dateFormats.parse.dateInput },
+                required: false,
+            };
+        }
+        const date = this.parseCurrentValue();
+        if (this.minDate && isBefore(startOfDay(date), startOfDay(this.minDate))) {
+            return { [WlcmDateValidation.MinDate]: { minDate: this.minDate, currentDate: date } };
+        }
+        if (this.maxDate && isAfter(startOfDay(date), startOfDay(this.maxDate))) {
+            return { [WlcmDateValidation.MaxDate]: { maxDate: this.maxDate, currentDate: date } };
+        }
+        return null;
+    }
+    parseCurrentValue() {
+        const date = this.dateAdapter.parse(this.currentValue, this.dateFormats.parse.dateInput);
+        return this.dateAdapter.getValidDateOrNull(date);
+    }
+    isValidFormat(value, pattern) {
+        const parsedDate = parse(value, pattern, new Date());
+        return isValid(parsedDate) && value === format(parsedDate, pattern);
+    }
+    get minDate() {
+        return this.trigger.minDate?.();
+    }
+    get maxDate() {
+        return this.trigger.maxDate?.();
+    }
+    get inputElement() {
+        return this.element.nativeElement;
+    }
+    get currentValue() {
+        return this.inputElement.value;
+    }
+    updateInputValue(value) {
+        let newValue = '';
+        if (value) {
+            newValue = this.dateAdapter.format(value, this.dateFormats.display.dateInput);
+        }
+        this.inputElement.value = newValue;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerInputBase, deps: "invalid", target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.6", type: WlcmDatepickerInputBase, host: { listeners: { "blur": "handleBlur()", "input": "handleInput()" }, properties: { "class": "this.datepickerInputClass" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerInputBase, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.DateAdapter }, { type: undefined }, { type: i2.WlcmDatepickerTrigger }], propDecorators: { handleBlur: [{
+                type: HostListener,
+                args: ['blur']
+            }], handleInput: [{
+                type: HostListener,
+                args: ['input']
+            }], datepickerInputClass: [{
+                type: HostBinding,
+                args: ['class']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-input.base.js","sourceRoot":"","sources":["../../../../../../modules/datepicker/src/lib/directives/datepicker-input.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { Directive, ElementRef, HostBinding, HostListener } from '@angular/core';\nimport { ControlValueAccessor, ValidationErrors, Validator } from '@angular/forms';\nimport { format, isAfter, isBefore, isValid, parse, startOfDay } from 'date-fns';\nimport { WLCM_DATEPICKER_INPUT_CLASS } from '../constants/datepicker.constants';\nimport { DateAdapter, MatDateFormats } from '@angular/material/core';\nimport { WlcmDateValidation } from '../models/date-picker.models';\nimport { WlcmDatepickerTrigger } from './datepicker-trigger.base';\n\n@Directive()\nexport abstract class WlcmDatepickerInputBase implements ControlValueAccessor, Validator {\n  @HostListener('blur') handleBlur() {\n    this.updateSelection();\n\n    this._touched?.();\n  }\n\n  @HostListener('input') handleInput() {\n    if (this.isValidFormat(this.currentValue, this.dateFormats.parse.dateInput)) {\n      this.updateSelection();\n    }\n\n    this._validatorChanged?.();\n  }\n\n  @HostBinding('class') get datepickerInputClass(): string {\n    return WLCM_DATEPICKER_INPUT_CLASS;\n  }\n\n  protected _changed?: (value: Date | null) => void;\n\n  protected _touched?: () => void;\n\n  protected _validatorChanged?: () => void;\n\n  constructor(\n    protected element: ElementRef,\n    protected dateAdapter: DateAdapter<Date>,\n    protected dateFormats: MatDateFormats,\n    protected trigger: WlcmDatepickerTrigger<unknown>,\n  ) {}\n\n  writeValue(value: Date | null): void {\n    this.updateInputValue(value);\n  }\n\n  registerOnChange(callback: (value: Date | null) => void): void {\n    this._changed = callback;\n  }\n\n  registerOnTouched(callback: () => void): void {\n    this._touched = callback;\n  }\n\n  registerOnValidatorChange(callback: () => void): void {\n    this._validatorChanged = callback;\n  }\n\n  validate(): ValidationErrors | null {\n    if (!this.currentValue) return null;\n\n    const isValid: boolean = this.isValidFormat(this.currentValue, this.dateFormats.parse.dateInput);\n\n    if (!isValid) {\n      return {\n        [WlcmDateValidation.Format]: { value: this.currentValue, format: this.dateFormats.parse.dateInput },\n        required: false,\n      };\n    }\n\n    const date: Date = this.parseCurrentValue()!;\n\n    if (this.minDate && isBefore(startOfDay(date), startOfDay(this.minDate))) {\n      return { [WlcmDateValidation.MinDate]: { minDate: this.minDate, currentDate: date } };\n    }\n\n    if (this.maxDate && isAfter(startOfDay(date), startOfDay(this.maxDate))) {\n      return { [WlcmDateValidation.MaxDate]: { maxDate: this.maxDate, currentDate: date } };\n    }\n\n    return null;\n  }\n\n  parseCurrentValue(): Date | null {\n    const date: Date | null = this.dateAdapter.parse(this.currentValue, this.dateFormats.parse.dateInput);\n\n    return this.dateAdapter.getValidDateOrNull(date);\n  }\n\n  protected isValidFormat(value: string, pattern: string): boolean {\n    const parsedDate = parse(value, pattern, new Date());\n\n    return isValid(parsedDate) && value === format(parsedDate, pattern);\n  }\n\n  protected abstract updateSelection(): void;\n\n  protected get minDate(): Date | undefined {\n    return this.trigger.minDate?.();\n  }\n\n  protected get maxDate(): Date | undefined {\n    return this.trigger.maxDate?.();\n  }\n\n  protected get inputElement(): HTMLInputElement {\n    return this.element.nativeElement;\n  }\n\n  protected get currentValue(): string {\n    return this.inputElement.value;\n  }\n\n  protected updateInputValue(value: Date | null): void {\n    let newValue: string = '';\n\n    if (value) {\n      newValue = this.dateAdapter.format(value, this.dateFormats.display.dateInput);\n    }\n\n    this.inputElement.value = newValue;\n  }\n}\n"]}

package/datepicker/esm2022/lib/directives/datepicker-trigger.base.mjs

@@ -0,0 +1,105 @@
+import { __decorate, __metadata } from "tslib";
+import { OverlayRef, Overlay, OverlayConfig } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { Directive, ViewContainerRef, Injector, input, HostBinding, } from '@angular/core';
+import { WLCM_DATEPICKER_CONFIG } from '../constants/datepicker.constants';
+import { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';
+import { MatDateSelectionModel } from '@angular/material/datepicker';
+import { merge, EMPTY, filter } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+import * as i2 from "@angular/material/datepicker";
+let WlcmDatepickerTrigger = class WlcmDatepickerTrigger {
+    get isOnlySelect() {
+        return this.selectOnly();
+    }
+    constructor(overlay, viewContainerRef, selectionModel) {
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.selectionModel = selectionModel;
+        this.minDate = input(this.defaultDatepickerConfig.minDate?.());
+        this.maxDate = input(this.defaultDatepickerConfig.maxDate?.());
+        this.selectOnly = input(this.defaultDatepickerConfig.selectOnly || false);
+        this.overlayRef = this.overlay.create(this.createOverlayConfig());
+        this.handleBackdropClick();
+    }
+    open() {
+        const injector = Injector.create({
+            providers: [{ provide: OverlayRef, useValue: this.overlayRef }],
+            parent: this.datepickerInjector,
+        });
+        const portal = new ComponentPortal(this.componentType, this.viewContainerRef, injector);
+        this.updatePositionStrategy();
+        this.componentRef = this.overlayRef.attach(portal);
+    }
+    close() {
+        this.overlayRef.detach();
+    }
+    get isOpen() {
+        return this.overlayRef.hasAttached();
+    }
+    get opened() {
+        return merge(this.overlayRef?.attachments() || EMPTY).pipe(filter(() => this.overlayRef.hasAttached()));
+    }
+    get closed() {
+        return (this.overlayRef?.detachments() || EMPTY).pipe(filter(() => !this.overlayRef.hasAttached()));
+    }
+    get datepickerInjector() {
+        const parent = this.viewContainerRef.injector;
+        return Injector.create({
+            parent,
+            providers: [{ provide: WLCM_DATEPICKER_CONFIG, useValue: this.datepickerConfig }],
+        });
+    }
+    get defaultDatepickerConfig() {
+        return this.viewContainerRef.injector.get(WLCM_DATEPICKER_CONFIG, {}, { optional: true });
+    }
+    get datepickerConfig() {
+        const config = { ...this.defaultDatepickerConfig };
+        if (this.minDate())
+            config.minDate = this.minDate;
+        if (this.maxDate())
+            config.maxDate = this.maxDate;
+        config.selectOnly = this.selectOnly();
+        return config;
+    }
+    handleBackdropClick() {
+        this.overlayRef
+            .backdropClick()
+            .pipe(untilDestroyed(this))
+            .subscribe(() => this.close());
+    }
+    updatePositionStrategy() {
+        const strategy = this.overlay.position().flexibleConnectedTo(this.connectedTo);
+        strategy.withPositions([
+            { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top', offsetY: 4 },
+            { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom', offsetY: -4 },
+        ]);
+        strategy.withLockedPosition(false);
+        strategy.withDefaultOffsetY(4);
+        this.overlayRef.updatePositionStrategy(strategy);
+    }
+    createOverlayConfig() {
+        return new OverlayConfig({
+            hasBackdrop: true,
+            scrollStrategy: this.overlay.scrollStrategies.reposition(),
+            backdropClass: 'transparent',
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerTrigger, deps: [{ token: i1.Overlay }, { token: i0.ViewContainerRef }, { token: i2.MatDateSelectionModel }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "18.2.6", type: WlcmDatepickerTrigger, inputs: { minDate: { classPropertyName: "minDate", publicName: "minDate", isSignal: true, isRequired: false, transformFunction: null }, maxDate: { classPropertyName: "maxDate", publicName: "maxDate", isSignal: true, isRequired: false, transformFunction: null }, selectOnly: { classPropertyName: "selectOnly", publicName: "selectOnly", isSignal: true, isRequired: false, transformFunction: null } }, host: { properties: { "class.wlcm-datepicker-select-only-mode": "this.isOnlySelect" } }, ngImport: i0 }); }
+};
+WlcmDatepickerTrigger = __decorate([
+    UntilDestroy(),
+    __metadata("design:paramtypes", [Overlay,
+        ViewContainerRef,
+        MatDateSelectionModel])
+], WlcmDatepickerTrigger);
+export { WlcmDatepickerTrigger };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.6", ngImport: i0, type: WlcmDatepickerTrigger, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.Overlay }, { type: i0.ViewContainerRef }, { type: i2.MatDateSelectionModel }], propDecorators: { isOnlySelect: [{
+                type: HostBinding,
+                args: ['class.wlcm-datepicker-select-only-mode']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datepicker-trigger.base.js","sourceRoot":"","sources":["../../../../../../modules/datepicker/src/lib/directives/datepicker-trigger.base.ts"],"names":[],"mappings":"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","sourcesContent":["import { OverlayRef, Overlay, FlexibleConnectedPositionStrategy, OverlayConfig } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport {\n  Directive,\n  ElementRef,\n  Type,\n  ComponentRef,\n  ViewContainerRef,\n  Injector,\n  InputSignal,\n  input,\n  HostBinding,\n} from '@angular/core';\nimport { WLCM_DATEPICKER_CONFIG } from '../constants/datepicker.constants';\nimport { UntilDestroy, untilDestroyed } from '@ngneat/until-destroy';\nimport { MatDateSelectionModel } from '@angular/material/datepicker';\nimport { WlcmDatepickerConfig } from '../models/date-picker.models';\nimport { Observable, merge, EMPTY, filter } from 'rxjs';\n\n@UntilDestroy()\n@Directive()\nexport abstract class WlcmDatepickerTrigger<T, D = Date> {\n  minDate: InputSignal<Date | undefined> = input(this.defaultDatepickerConfig.minDate?.());\n\n  maxDate: InputSignal<Date | undefined> = input(this.defaultDatepickerConfig.maxDate?.());\n\n  selectOnly: InputSignal<boolean> = input(this.defaultDatepickerConfig.selectOnly || false);\n\n  @HostBinding('class.wlcm-datepicker-select-only-mode') get isOnlySelect(): boolean {\n    return this.selectOnly();\n  }\n\n  protected overlayRef: OverlayRef = this.overlay.create(this.createOverlayConfig());\n\n  protected abstract connectedTo: ElementRef<HTMLElement>;\n\n  protected abstract componentType: Type<T>;\n\n  protected componentRef?: ComponentRef<T>;\n\n  protected constructor(\n    protected overlay: Overlay,\n    protected viewContainerRef: ViewContainerRef,\n    protected selectionModel: MatDateSelectionModel<D>,\n  ) {\n    this.handleBackdropClick();\n  }\n\n  open(): void {\n    const injector: Injector = Injector.create({\n      providers: [{ provide: OverlayRef, useValue: this.overlayRef }],\n      parent: this.datepickerInjector,\n    });\n\n    const portal: ComponentPortal<T> = new ComponentPortal(this.componentType, this.viewContainerRef, injector);\n\n    this.updatePositionStrategy();\n\n    this.componentRef = this.overlayRef.attach(portal);\n  }\n\n  close(): void {\n    this.overlayRef.detach();\n  }\n\n  get isOpen(): boolean {\n    return this.overlayRef.hasAttached();\n  }\n\n  get opened(): Observable<void> {\n    return merge(this.overlayRef?.attachments() || EMPTY).pipe(filter(() => this.overlayRef.hasAttached()));\n  }\n\n  get closed(): Observable<void> {\n    return (this.overlayRef?.detachments() || EMPTY).pipe(filter(() => !this.overlayRef.hasAttached()));\n  }\n\n  get datepickerInjector(): Injector {\n    const parent: Injector = this.viewContainerRef.injector;\n\n    return Injector.create({\n      parent,\n      providers: [{ provide: WLCM_DATEPICKER_CONFIG, useValue: this.datepickerConfig }],\n    });\n  }\n\n  get defaultDatepickerConfig(): WlcmDatepickerConfig {\n    return this.viewContainerRef.injector.get(WLCM_DATEPICKER_CONFIG, {}, { optional: true });\n  }\n\n  get datepickerConfig(): WlcmDatepickerConfig {\n    const config: WlcmDatepickerConfig = { ...this.defaultDatepickerConfig };\n\n    if (this.minDate()) config.minDate = this.minDate;\n\n    if (this.maxDate()) config.maxDate = this.maxDate;\n\n    config.selectOnly = this.selectOnly();\n\n    return config;\n  }\n\n  private handleBackdropClick(): void {\n    this.overlayRef\n      .backdropClick()\n      .pipe(untilDestroyed(this))\n      .subscribe(() => this.close());\n  }\n\n  private updatePositionStrategy(): void {\n    const strategy: FlexibleConnectedPositionStrategy = this.overlay.position().flexibleConnectedTo(this.connectedTo);\n\n    strategy.withPositions([\n      { originX: 'start', originY: 'bottom', overlayX: 'start', overlayY: 'top', offsetY: 4 },\n      { originX: 'start', originY: 'top', overlayX: 'start', overlayY: 'bottom', offsetY: -4 },\n    ]);\n\n    strategy.withLockedPosition(false);\n\n    strategy.withDefaultOffsetY(4);\n\n    this.overlayRef.updatePositionStrategy(strategy);\n  }\n\n  private createOverlayConfig(): OverlayConfig {\n    return new OverlayConfig({\n      hasBackdrop: true,\n      scrollStrategy: this.overlay.scrollStrategies.reposition(),\n      backdropClass: 'transparent',\n    });\n  }\n}\n"]}