@impartner/design-components 2.0.1 → 2.1.1

package/esm2022/lib/datetime-picker/components/datetime-picker/datetime-picker.component.mjs

@@ -0,0 +1,370 @@
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, DestroyRef, ElementRef, EventEmitter, Inject, Input, Optional, Output, Self, ViewChild, booleanAttribute, inject } from '@angular/core';
+import { CommonModule, TranslationWidth } from '@angular/common';
+import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
+import { FormBuilder, FormControl, ReactiveFormsModule, Validators } from '@angular/forms';
+import { NgbDateAdapter, NgbDatepicker, NgbDatepickerModule, NgbTimepickerModule } from '@ng-bootstrap/ng-bootstrap';
+import { nanoid } from 'nanoid';
+import { Subject, debounceTime } from 'rxjs';
+import { IMPDC_FORM_ROOT, ImpdcFormFieldControl, ImpdcFormsModule, mixinDisabled, mixinErrorState, mixinTabIndex } from '../../../form-field';
+import { DEFAULT_MAX_DATE, DEFAULT_MIN_DATE, DEFAULT_USE_MERIDIAN_LABEL } from '../../constants';
+import { DatepickerTemplateHostComponent } from '../datepicker-template-host';
+import { DatetimePickerInputFooterComponent } from '../datetime-picker-input-footer';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../form-field";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "@ng-bootstrap/ng-bootstrap";
+import * as i5 from "../../../form-field/component/directives/form-root.directive";
+import * as i6 from "../../../form-field/controls/checkbox/checkbox.component";
+export const DEFAULT_TIME_LAYOUT = {
+    border: false,
+    layout: 'inline'
+};
+const _DatetimePickerComponentBase = mixinTabIndex(mixinDisabled(mixinErrorState(class {
+    constructor(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        this._defaultErrorStateMatcher = _defaultErrorStateMatcher;
+        this._formRoot = _formRoot;
+        this._parentForm = _parentForm;
+        this._parentFormGroup = _parentFormGroup;
+        this.ngControl = ngControl;
+        this.stateChanges = new Subject();
+    }
+})));
+/**
+ * A control for selecting date or datetime via an inline calendar control.
+ *
+ * Implements [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor) to support two-way binding with
+ * Angular forms via usage of the \`[(ngModel)]\`, \`[formControl]\`, and \`[formControlName]\` directives.
+ *
+ * The date and time controls inside this component leverage the value adapter patterns and services of NG-Bootstrap's
+ * [Datepicker](https://ng-bootstrap.github.io/#/components/datepicker/overview#date-model) and
+ * [Timepicker](https://ng-bootstrap.github.io/#/components/timepicker/examples#adapter) components when working with input values.
+ * This means that `date` values will be [NgbDateStruct](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateStruct)
+ * objects and `time` values will be [NgbTimeStruct](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeStruct) objects
+ * by default, and the [NgbDateAdapter](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateAdapter) and
+ * [NgbTimeAdapter](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeAdapter) services will be used to handle them respectively.
+ * If usage of alternative date and time models is desired, consult NG-Bootstrap's documentation for directions.
+ */
+export class DatetimePickerComponent extends _DatetimePickerComponentBase {
+    /**
+     * The earliest allowable date for display or selection.
+     *
+     * @default { year: 1900, month: 1, day: 1 }
+     */
+    get minDate() {
+        return { ...this._minDate };
+    }
+    set minDate(value) {
+        this._minDate = value || DEFAULT_MIN_DATE;
+    }
+    /**
+     * The latest allowable date for display or selection.
+     *
+     * @default { year: 2099, month: 12, day: 31 }
+     */
+    get maxDate() {
+        return { ...this._maxDate };
+    }
+    set maxDate(value) {
+        this._maxDate = value || DEFAULT_MAX_DATE;
+    }
+    /**
+     * Configurable options for setting the layout of the date and time controls within the component.
+     */
+    get timeLayout() {
+        return { ...this._timeLayout };
+    }
+    set timeLayout(value) {
+        this._timeLayout = {
+            ...DEFAULT_TIME_LAYOUT,
+            ...value
+        };
+    }
+    constructor(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl) {
+        super(_defaultErrorStateMatcher, _formRoot, _parentForm, _parentFormGroup, ngControl);
+        this._changeDetector = inject(ChangeDetectorRef);
+        this._destroyRef = inject(DestroyRef);
+        this._hostElement = inject(ElementRef);
+        this._ngbDateAdapter = inject((NgbDateAdapter));
+        this._uid = `impdc-datetime-picker-${nanoid()}`;
+        this.NgTranslationWidth = TranslationWidth;
+        this.formGroup = inject(FormBuilder).group({
+            date: new FormControl(null),
+            time: new FormControl(null),
+            useMeridian: new FormControl(true, { nonNullable: true })
+        });
+        this.cvaOnChange = (_) => { };
+        this.cvaOnTouched = () => { };
+        this._minDate = DEFAULT_MIN_DATE;
+        this._maxDate = DEFAULT_MAX_DATE;
+        this._timeLayout = { ...DEFAULT_TIME_LAYOUT };
+        /**
+         * Label to be displayed with time controls to allow the user to input 24-hour or meridian-based (AM, PM) time.
+         */
+        this.meridianToggleLabel = DEFAULT_USE_MERIDIAN_LABEL;
+        /**
+         * Set whether to display controls for selecting a time value in addition to the date.
+         */
+        this.withTime = false;
+        /**
+         * Events fire when raw value of picker input changes. Mainly exists to handle
+         * two-way binding of `value` input property.
+         * @ignore
+         */
+        this.valueChange = new EventEmitter();
+        /** @ignore */
+        this.blur = new EventEmitter();
+        this._focused = false;
+        this.controlType = 'impdc-datetime-picker';
+        this.supportsAffixes = false;
+        this.markDateDisabledFn = (date, current) => {
+            return (this._dateIsOutsideCurrentMonth(date, current) ||
+                (!!this.markDateDisabled && this.markDateDisabled(date, current)));
+        };
+        if (this.ngControl) {
+            this.ngControl.valueAccessor = this;
+        }
+        this.id = this.id;
+    }
+    /** @ignore */
+    focus() {
+        this.ngbDatepicker.focus();
+    }
+    /* Lifecycle Hooks */
+    /** @ignore */
+    ngDoCheck() {
+        const ngControl = this.ngControl;
+        if (!ngControl) {
+            return;
+        }
+        if (this._previousControl !== ngControl.control) {
+            if (this._previousControl !== undefined &&
+                ngControl.disabled !== null &&
+                ngControl.disabled !== this.disabled) {
+                this.disabled = ngControl?.disabled;
+            }
+            this._previousControl = ngControl.control;
+        }
+        this.updateErrorState();
+    }
+    /** @ignore */
+    ngOnChanges(changes) {
+        // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal
+        // to the parent form field so it can run change detection when disabled state is changed.
+        if (changes['disabled']) {
+            this.stateChanges.next();
+        }
+    }
+    /** @ignore */
+    ngOnDestroy() {
+        this.stateChanges.complete();
+    }
+    /** @ignore */
+    ngOnInit() {
+        this.formGroup.valueChanges
+            .pipe(takeUntilDestroyed(this._destroyRef), debounceTime(100))
+            .subscribe(formValue => {
+            const changeValue = this._getValueFromFormModel(formValue);
+            this.cvaOnChange(changeValue);
+            this.valueChange.emit(changeValue);
+            this.cvaOnTouched();
+        });
+    }
+    /* ControlValueAccessor */
+    /** @ignore */
+    writeValue(obj) {
+        let newValue = {};
+        if (obj && 'date' in obj) {
+            newValue = {
+                ...newValue,
+                date: obj.date
+            };
+        }
+        if (this.withTime && obj && 'time' in obj) {
+            newValue = {
+                ...newValue,
+                time: obj.time
+            };
+        }
+        this.formGroup.patchValue(newValue, { emitEvent: false });
+        if ('date' in newValue) {
+            this.ngbDatepicker.focusDate(this._ngbDateAdapter.fromModel(newValue.date));
+        }
+        this.stateChanges.next();
+    }
+    /** @ignore */
+    registerOnChange(fn) {
+        this.cvaOnChange = fn;
+    }
+    /** @ignore */
+    registerOnTouched(fn) {
+        this.cvaOnTouched = fn;
+    }
+    /** @ignore */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        if (isDisabled) {
+            this.formGroup.disable();
+        }
+        else {
+            this.formGroup.enable();
+        }
+    }
+    /* ImpdcFormFieldControl */
+    get value() {
+        return this._getValueFromFormModel(this.formGroup.value);
+    }
+    set value(value) {
+        this.writeValue(value);
+    }
+    get id() {
+        return this._id;
+    }
+    set id(value) {
+        this._id = value || this._uid;
+        this.stateChanges.next();
+    }
+    /**
+     * Used to set requiredness of control in a template-based manner;
+     * not necessary when using the Angular reactive forms API and `required` validator.
+     *
+     * @default false
+     */
+    get required() {
+        return (this._required ??
+            this.ngControl?.control?.hasValidator(Validators.required) ??
+            false);
+    }
+    set required(value) {
+        this._required = value;
+        this.stateChanges.next();
+    }
+    get focused() {
+        return this._focused;
+    }
+    /* Internals */
+    get useMeridian() {
+        return this.formGroup.getRawValue().useMeridian;
+    }
+    get useMeridianLabelText() {
+        return this.meridianToggleLabel?.trim() || DEFAULT_USE_MERIDIAN_LABEL;
+    }
+    handleFocusOut(evt) {
+        if (!evt.relatedTarget ||
+            !this._hostElement.nativeElement.contains(evt.relatedTarget)) {
+            this._onBlur(evt);
+        }
+    }
+    _getValueFromFormModel(formValue) {
+        if (!formValue.date && !formValue.time) {
+            return null;
+        }
+        let result = {
+            date: formValue.date
+        };
+        if (this.withTime) {
+            result = {
+                ...result,
+                time: formValue.time
+            };
+        }
+        return result;
+    }
+    _dateIsOutsideCurrentMonth(date, current) {
+        return !!current && date.month !== current.month;
+    }
+    _onFocus() {
+        if (!this.disabled) {
+            this._focused = true;
+            this.stateChanges.next();
+        }
+    }
+    _onBlur(focusEvent) {
+        this._focused = false;
+        if (!this.disabled) {
+            this.cvaOnTouched();
+            this.blur.emit(focusEvent);
+            this._changeDetector.markForCheck();
+            this.stateChanges.next();
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: DatetimePickerComponent, deps: [{ token: i1.ErrorStateMatcher }, { token: IMPDC_FORM_ROOT, optional: true }, { token: i2.NgForm, optional: true }, { token: i2.FormGroupDirective, optional: true }, { token: i2.NgControl, optional: true, self: true }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.0.1", type: DatetimePickerComponent, isStandalone: true, selector: "impdc-datetime-picker", inputs: { disabled: "disabled", tabIndex: "tabIndex", markDateDisabled: "markDateDisabled", minDate: "minDate", maxDate: "maxDate", timeLayout: "timeLayout", meridianToggleLabel: "meridianToggleLabel", withTime: "withTime", errorStateMatcher: "errorStateMatcher", value: "value", id: "id", required: ["required", "required", booleanAttribute] }, outputs: { valueChange: "valueChange", blur: "blur" }, host: { listeners: { "focus": "_onFocus(); focus()" }, properties: { "attr.id": "id", "attr.tabindex": "tabIndex", "attr.aria-required": "required.toString()", "attr.aria-disabled": "disabled.toString()", "attr.aria-invalid": "errorState", "class.is-invalid": "errorState", "class.impdc-form-field-control": "true", "class.impdc-datetime-picker--required": "required", "class.impdc-datetime-picker--disabled": "disabled", "class.impdc-datetime-picker--invalid": "errorState", "class.impdc-datetime-picker--empty": "empty" } }, providers: [
+            {
+                provide: ImpdcFormFieldControl,
+                useExisting: DatetimePickerComponent
+            }
+        ], viewQueries: [{ propertyName: "ngbDatepicker", first: true, predicate: NgbDatepicker, descendants: true, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<impdc-datepicker-template-host #templateHost></impdc-datepicker-template-host>\n<div\n  [formGroup]=\"formGroup\"\n  class=\"d-flex\"\n  [ngClass]=\"{\n    'flex-column': withTime && timeLayout.layout === 'stacked'\n  }\"\n  (focusout)=\"handleFocusOut($event)\">\n  <ngb-datepicker\n    class=\"impdc-datetime-picker--datepicker\"\n    formControlName=\"date\"\n    [dayTemplate]=\"templateHost.dayTemplateRef\"\n    [contentTemplate]=\"templateHost.contentTemplateRef\"\n    [showWeekNumbers]=\"false\"\n    outsideDays=\"visible\"\n    [weekdays]=\"NgTranslationWidth.Abbreviated\"\n    [markDisabled]=\"markDateDisabledFn\"\n    [minDate]=\"minDate\"\n    [maxDate]=\"maxDate\" />\n  @if (withTime) {\n  <div\n    class=\"impdc-datetime-picker--timepicker d-flex flex-column gap-4 p-4 w-100\"\n    [ngClass]=\"{\n      'border-0': !timeLayout.border,\n      'border-gray-200': timeLayout.border,\n      'mt-2': timeLayout.layout === 'stacked',\n      'border-top': timeLayout.border && timeLayout.layout === 'stacked',\n      'ms-2': timeLayout.layout === 'inline',\n      'border-start': timeLayout.border && timeLayout.layout === 'inline'\n    }\">\n    <impdc-checkbox\n      [label]=\"useMeridianLabelText\"\n      formControlName=\"useMeridian\"\n      [isSwitch]=\"true\"\n      layout=\"check-end\" />\n    <ngb-timepicker\n      formControlName=\"time\"\n      [meridian]=\"useMeridian\"\n      [seconds]=\"false\"\n      [spinners]=\"false\"\n      size=\"medium\"></ngb-timepicker>\n  </div>\n  }\n</div>\n", styles: [":host{display:block}ngb-datepicker{border:0}ngb-timepicker{font-size:var(--impd-font-size-sm)}::ng-deep .ngb-dp-header{display:none}::ng-deep .ngb-tp-spacer{width:var(--impd-size-4)}.impdc-datetime-picker--datepicker,.impdc-datetime-picker--timepicker{max-width:312px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i2.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i2.FormControlName, selector: "[formControlName]", inputs: ["formControlName", "disabled", "ngModel"], outputs: ["ngModelChange"] }, { kind: "ngmodule", type: NgbDatepickerModule }, { kind: "component", type: i4.NgbDatepicker, selector: "ngb-datepicker", inputs: ["contentTemplate", "dayTemplate", "dayTemplateData", "displayMonths", "firstDayOfWeek", "footerTemplate", "markDisabled", "maxDate", "minDate", "navigation", "outsideDays", "showWeekNumbers", "startDate", "weekdays"], outputs: ["navigate", "dateSelect"], exportAs: ["ngbDatepicker"] }, { kind: "ngmodule", type: NgbTimepickerModule }, { kind: "component", type: i4.NgbTimepicker, selector: "ngb-timepicker", inputs: ["meridian", "spinners", "seconds", "hourStep", "minuteStep", "secondStep", "readonlyInputs", "size"], exportAs: ["ngbTimepicker"] }, { kind: "component", type: DatepickerTemplateHostComponent, selector: "impdc-datepicker-template-host" }, { kind: "ngmodule", type: ImpdcFormsModule }, { kind: "directive", type: i5.RootFormGroupDirective, selector: "[formGroup]" }, { kind: "component", type: i6.CheckboxComponent, selector: "impdc-checkbox", inputs: ["tabIndex", "id", "label", "description", "isSwitch", "switchIcons", "inline", "layout", "checked", "indeterminate", "disabled", "errorStateMatcher", "required"], outputs: ["change", "indeterminateChange"], exportAs: ["impdcCheckControl"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.1", ngImport: i0, type: DatetimePickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'impdc-datetime-picker', standalone: true, imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        NgbDatepickerModule,
+                        NgbTimepickerModule,
+                        DatepickerTemplateHostComponent,
+                        DatetimePickerInputFooterComponent,
+                        ImpdcFormsModule
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, inputs: ['disabled', 'tabIndex'], host: {
+                        '[attr.id]': 'id',
+                        '[attr.tabindex]': 'tabIndex',
+                        '[attr.aria-required]': 'required.toString()',
+                        '[attr.aria-disabled]': 'disabled.toString()',
+                        '[attr.aria-invalid]': 'errorState',
+                        '[class.is-invalid]': 'errorState',
+                        '[class.impdc-form-field-control]': 'true',
+                        '[class.impdc-datetime-picker--required]': 'required',
+                        '[class.impdc-datetime-picker--disabled]': 'disabled',
+                        '[class.impdc-datetime-picker--invalid]': 'errorState',
+                        '[class.impdc-datetime-picker--empty]': 'empty',
+                        '(focus)': '_onFocus(); focus()'
+                    }, providers: [
+                        {
+                            provide: ImpdcFormFieldControl,
+                            useExisting: DatetimePickerComponent
+                        }
+                    ], template: "<impdc-datepicker-template-host #templateHost></impdc-datepicker-template-host>\n<div\n  [formGroup]=\"formGroup\"\n  class=\"d-flex\"\n  [ngClass]=\"{\n    'flex-column': withTime && timeLayout.layout === 'stacked'\n  }\"\n  (focusout)=\"handleFocusOut($event)\">\n  <ngb-datepicker\n    class=\"impdc-datetime-picker--datepicker\"\n    formControlName=\"date\"\n    [dayTemplate]=\"templateHost.dayTemplateRef\"\n    [contentTemplate]=\"templateHost.contentTemplateRef\"\n    [showWeekNumbers]=\"false\"\n    outsideDays=\"visible\"\n    [weekdays]=\"NgTranslationWidth.Abbreviated\"\n    [markDisabled]=\"markDateDisabledFn\"\n    [minDate]=\"minDate\"\n    [maxDate]=\"maxDate\" />\n  @if (withTime) {\n  <div\n    class=\"impdc-datetime-picker--timepicker d-flex flex-column gap-4 p-4 w-100\"\n    [ngClass]=\"{\n      'border-0': !timeLayout.border,\n      'border-gray-200': timeLayout.border,\n      'mt-2': timeLayout.layout === 'stacked',\n      'border-top': timeLayout.border && timeLayout.layout === 'stacked',\n      'ms-2': timeLayout.layout === 'inline',\n      'border-start': timeLayout.border && timeLayout.layout === 'inline'\n    }\">\n    <impdc-checkbox\n      [label]=\"useMeridianLabelText\"\n      formControlName=\"useMeridian\"\n      [isSwitch]=\"true\"\n      layout=\"check-end\" />\n    <ngb-timepicker\n      formControlName=\"time\"\n      [meridian]=\"useMeridian\"\n      [seconds]=\"false\"\n      [spinners]=\"false\"\n      size=\"medium\"></ngb-timepicker>\n  </div>\n  }\n</div>\n", styles: [":host{display:block}ngb-datepicker{border:0}ngb-timepicker{font-size:var(--impd-font-size-sm)}::ng-deep .ngb-dp-header{display:none}::ng-deep .ngb-tp-spacer{width:var(--impd-size-4)}.impdc-datetime-picker--datepicker,.impdc-datetime-picker--timepicker{max-width:312px}\n"] }]
+        }], ctorParameters: () => [{ type: i1.ErrorStateMatcher }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [IMPDC_FORM_ROOT]
+                }] }, { type: i2.NgForm, decorators: [{
+                    type: Optional
+                }] }, { type: i2.FormGroupDirective, decorators: [{
+                    type: Optional
+                }] }, { type: i2.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }], propDecorators: { ngbDatepicker: [{
+                type: ViewChild,
+                args: [NgbDatepicker, { static: true }]
+            }], markDateDisabled: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], timeLayout: [{
+                type: Input
+            }], meridianToggleLabel: [{
+                type: Input
+            }], withTime: [{
+                type: Input
+            }], errorStateMatcher: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], blur: [{
+                type: Output
+            }], value: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], required: [{
+                type: Input,
+                args: [{ transform: booleanAttribute }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datetime-picker.component.js","sourceRoot":"","sources":["../../../../../../../../projects/design-components/src/lib/datetime-picker/components/datetime-picker/datetime-picker.component.ts","../../../../../../../../projects/design-components/src/lib/datetime-picker/components/datetime-picker/datetime-picker.component.html"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,iBAAiB,EACjB,SAAS,EACT,UAAU,EAEV,UAAU,EACV,YAAY,EACZ,MAAM,EACN,KAAK,EAIL,QAAQ,EACR,MAAM,EACN,IAAI,EAEJ,SAAS,EACT,gBAAgB,EAChB,MAAM,EACP,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACjE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAGL,WAAW,EACX,WAAW,EAIX,mBAAmB,EACnB,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,cAAc,EAEd,aAAa,EACb,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,MAAM,CAAC;AAE7C,OAAO,EAIL,eAAe,EACf,qBAAqB,EAErB,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,aAAa,EACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,0BAA0B,EAC3B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,+BAA+B,EAAE,MAAM,6BAA6B,CAAC;AAC9E,OAAO,EAAE,kCAAkC,EAAE,MAAM,iCAAiC,CAAC;;;;;;;;AAOrF,MAAM,CAAC,MAAM,mBAAmB,GAAiB;IAC/C,MAAM,EAAE,KAAK;IACb,MAAM,EAAE,QAAQ;CACR,CAAC;AAEX,MAAM,4BAA4B,GAAG,aAAa,CAChD,aAAa,CACX,eAAe,CACb;IAGE,YACS,yBAA4C,EAC5C,SAAwB,EACxB,WAAmB,EACnB,gBAAoC,EACpC,SAA2B;QAJ3B,8BAAyB,GAAzB,yBAAyB,CAAmB;QAC5C,cAAS,GAAT,SAAS,CAAe;QACxB,gBAAW,GAAX,WAAW,CAAQ;QACnB,qBAAgB,GAAhB,gBAAgB,CAAoB;QACpC,cAAS,GAAT,SAAS,CAAkB;QAPpB,iBAAY,GAAG,IAAI,OAAO,EAAQ,CAAC;IAQhD,CAAC;CACL,CACF,CACF,CACF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AAwCH,MAAM,OAAO,uBACX,SAAQ,4BAA4B;IA2CpC;;;;OAIG;IACH,IACW,OAAO;QAChB,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;IACD,IAAW,OAAO,CAAC,KAA2B;QAC5C,IAAI,CAAC,QAAQ,GAAG,KAAK,IAAI,gBAAgB,CAAC;IAC5C,CAAC;IAGD;;;;OAIG;IACH,IACW,OAAO;QAChB,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC9B,CAAC;IACD,IAAW,OAAO,CAAC,KAA2B;QAC5C,IAAI,CAAC,QAAQ,GAAG,KAAK,IAAI,gBAAgB,CAAC;IAC5C,CAAC;IAGD;;OAEG;IACH,IACW,UAAU;QACnB,OAAO,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IACjC,CAAC;IACD,IAAW,UAAU,CAAC,KAA4B;QAChD,IAAI,CAAC,WAAW,GAAG;YACjB,GAAG,mBAAmB;YACtB,GAAG,KAAK;SACT,CAAC;IACJ,CAAC;IAkCD,YACE,yBAA4C,EACP,SAAwB,EACjD,WAAmB,EACnB,gBAAoC,EAC5B,SAAoB;QAExC,KAAK,CACH,yBAAyB,EACzB,SAAS,EACT,WAAW,EACX,gBAAgB,EAChB,SAAS,CACV,CAAC;QAvHa,oBAAe,GAAG,MAAM,CAAC,iBAAiB,CAAC,CAAC;QAC5C,gBAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QACjC,iBAAY,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;QAClC,oBAAe,GAAG,MAAM,CAAC,CAAA,cAAmB,CAAA,CAAC,CAAC;QAC9C,SAAI,GAAG,yBAAyB,MAAM,EAAE,EAAE,CAAC;QAGzC,uBAAkB,GAAG,gBAAgB,CAAC;QACtC,cAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC;YACvD,IAAI,EAAE,IAAI,WAAW,CAAM,IAAI,CAAC;YAChC,IAAI,EAAE,IAAI,WAAW,CAAM,IAAI,CAAC;YAChC,WAAW,EAAE,IAAI,WAAW,CAAU,IAAI,EAAE,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC;SACnE,CAAC,CAAC;QACO,gBAAW,GAAG,CAAC,CAAM,EAAE,EAAE,GAAE,CAAC,CAAC;QAC7B,iBAAY,GAAG,GAAG,EAAE,GAAE,CAAC,CAAC;QA8B1B,aAAQ,GAAkB,gBAAgB,CAAC;QAc3C,aAAQ,GAAkB,gBAAgB,CAAC;QAe3C,gBAAW,GAAiB,EAAE,GAAG,mBAAmB,EAAE,CAAC;QAE/D;;WAEG;QAEI,wBAAmB,GAAW,0BAA0B,CAAC;QAEhE;;WAEG;QAEI,aAAQ,GAAG,KAAK,CAAC;QAKxB;;;;WAIG;QAEa,gBAAW,GAGf,IAAI,YAAY,EAAyC,CAAC;QAEtE,cAAc;QAGE,SAAI,GAAG,IAAI,YAAY,EAAc,CAAC;QA6K5C,aAAQ,GAAG,KAAK,CAAC;QAEX,gBAAW,GAAW,uBAAuB,CAAC;QAC9C,oBAAe,GAAY,KAAK,CAAC;QAiD9B,uBAAkB,GAAG,CACtC,IAAmB,EACnB,OAAyC,EACzC,EAAE;YACF,OAAO,CACL,IAAI,CAAC,0BAA0B,CAAC,IAAI,EAAE,OAAO,CAAC;gBAC9C,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,IAAI,IAAI,CAAC,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAClE,CAAC;QACJ,CAAC,CAAC;QAxNA,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,IAAI,CAAC,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC;SACrC;QAED,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,EAAE,CAAC;IACpB,CAAC;IAED,cAAc;IACP,KAAK;QACV,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;IAC7B,CAAC;IAED,qBAAqB;IAErB,cAAc;IACP,SAAS;QACd,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC;QAEjC,IAAI,CAAC,SAAS,EAAE;YACd,OAAO;SACR;QAED,IAAI,IAAI,CAAC,gBAAgB,KAAK,SAAS,CAAC,OAAO,EAAE;YAC/C,IACE,IAAI,CAAC,gBAAgB,KAAK,SAAS;gBACnC,SAAS,CAAC,QAAQ,KAAK,IAAI;gBAC3B,SAAS,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,EACpC;gBACA,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,QAAQ,CAAC;aACrC;YAED,IAAI,CAAC,gBAAgB,GAAG,SAAS,CAAC,OAAO,CAAC;SAC3C;QAED,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED,cAAc;IACP,WAAW,CAAC,OAAsB;QACvC,0GAA0G;QAC1G,0FAA0F;QAC1F,IAAI,OAAO,CAAC,UAAU,CAAC,EAAE;YACvB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;IACH,CAAC;IAED,cAAc;IACP,WAAW;QAChB,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,CAAC;IAC/B,CAAC;IAED,cAAc;IACP,QAAQ;QACb,IAAI,CAAC,SAAS,CAAC,YAAY;aACxB,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,YAAY,CAAC,GAAG,CAAC,CAAC;aAC7D,SAAS,CAAC,SAAS,CAAC,EAAE;YACrB,MAAM,WAAW,GAAG,IAAI,CAAC,sBAAsB,CAAC,SAAS,CAAC,CAAC;YAC3D,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;YAC9B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YACnC,IAAI,CAAC,YAAY,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC;IACP,CAAC;IAED,0BAA0B;IAE1B,cAAc;IACP,UAAU,CAAC,GAAyC;QACzD,IAAI,QAAQ,GAAkC,EAAE,CAAC;QACjD,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,EAAE;YACxB,QAAQ,GAAG;gBACT,GAAG,QAAQ;gBACX,IAAI,EAAE,GAAG,CAAC,IAAI;aACf,CAAC;SACH;QAED,IAAI,IAAI,CAAC,QAAQ,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,EAAE;YACzC,QAAQ,GAAG;gBACT,GAAG,QAAQ;gBACX,IAAI,EAAE,GAAG,CAAC,IAAI;aACf,CAAC;SACH;QAED,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;QAC1D,IAAI,MAAM,IAAI,QAAQ,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,SAAS,CAC1B,IAAI,CAAC,eAAe,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAC9C,CAAC;SACH;QAED,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAED,cAAc;IACP,gBAAgB,CAAC,EAAO;QAC7B,IAAI,CAAC,WAAW,GAAG,EAAE,CAAC;IACxB,CAAC;IAED,cAAc;IACP,iBAAiB,CAAC,EAAO;QAC9B,IAAI,CAAC,YAAY,GAAG,EAAE,CAAC;IACzB,CAAC;IAED,cAAc;IACP,gBAAgB,CAAE,UAAmB;QAC1C,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC;QAE3B,IAAI,UAAU,EAAE;YACd,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;SAC1B;aAAM;YACL,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC;SACzB;IACH,CAAC;IAED,2BAA2B;IAE3B,IACW,KAAK;QACd,OAAO,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;IAC3D,CAAC;IACD,IAAW,KAAK,CAAC,KAA4C;QAC3D,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED,IACW,EAAE;QACX,OAAO,IAAI,CAAC,GAAG,CAAC;IAClB,CAAC;IACD,IAAW,EAAE,CAAC,KAAa;QACzB,IAAI,CAAC,GAAG,GAAG,KAAK,IAAI,IAAI,CAAC,IAAI,CAAC;QAC9B,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAGD;;;;;OAKG;IACH,IACW,QAAQ;QACjB,OAAO,CACL,IAAI,CAAC,SAAS;YACd,IAAI,CAAC,SAAS,EAAE,OAAO,EAAE,YAAY,CAAC,UAAU,CAAC,QAAQ,CAAC;YAC1D,KAAK,CACN,CAAC;IACJ,CAAC;IACD,IAAW,QAAQ,CAAC,KAAc;QAChC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC;QACvB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;IAC3B,CAAC;IAGD,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAMD,eAAe;IAEf,IAAc,WAAW;QACvB,OAAO,IAAI,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,WAAW,CAAC;IAClD,CAAC;IAED,IAAc,oBAAoB;QAChC,OAAO,IAAI,CAAC,mBAAmB,EAAE,IAAI,EAAE,IAAI,0BAA0B,CAAC;IACxE,CAAC;IAES,cAAc,CAAC,GAAe;QACtC,IACE,CAAC,GAAG,CAAC,aAAa;YAClB,CAAC,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,CAAC,EAC5D;YACA,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;SACnB;IACH,CAAC;IAEO,sBAAsB,CAC5B,SAA8D;QAE9D,IAAI,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE;YACtC,OAAO,IAAI,CAAC;SACb;QAED,IAAI,MAAM,GAAmC;YAC3C,IAAI,EAAE,SAAS,CAAC,IAAI;SACrB,CAAC;QAEF,IAAI,IAAI,CAAC,QAAQ,EAAE;YACjB,MAAM,GAAG;gBACP,GAAG,MAAM;gBACT,IAAI,EAAE,SAAS,CAAC,IAAI;aACrB,CAAC;SACH;QAED,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,0BAA0B,CAChC,IAAmB,EACnB,OAAyC;QAEzC,OAAO,CAAC,CAAC,OAAO,IAAI,IAAI,CAAC,KAAK,KAAK,OAAO,CAAC,KAAK,CAAC;IACnD,CAAC;IAYS,QAAQ;QAChB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;IACH,CAAC;IAES,OAAO,CAAC,UAAsB;QACtC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC;QAEtB,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;YAClB,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC3B,IAAI,CAAC,eAAe,CAAC,YAAY,EAAE,CAAC;YACpC,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,CAAC;SAC1B;IACH,CAAC;8GA/WU,uBAAuB,mDAwHZ,eAAe;kGAxH1B,uBAAuB,8XAgRd,gBAAgB,slBAvRzB;YACT;gBACE,OAAO,EAAE,qBAAqB;gBAC9B,WAAW,EAAE,uBAAuB;aACrC;SACF,yEA8BU,aAAa,0GC/K1B,m/CA4CA,uUDoEI,YAAY,4HACZ,mBAAmB,mlBACnB,mBAAmB,8YACnB,mBAAmB,sPACnB,+BAA+B,0EAE/B,gBAAgB;;2FA6BP,uBAAuB;kBAvCnC,SAAS;+BACE,uBAAuB,cACrB,IAAI,WACP;wBACP,YAAY;wBACZ,mBAAmB;wBACnB,mBAAmB;wBACnB,mBAAmB;wBACnB,+BAA+B;wBAC/B,kCAAkC;wBAClC,gBAAgB;qBACjB,mBAGgB,uBAAuB,CAAC,MAAM,UAEvC,CAAC,UAAU,EAAE,UAAU,CAAC,QAE1B;wBACJ,WAAW,EAAE,IAAI;wBACjB,iBAAiB,EAAE,UAAU;wBAC7B,sBAAsB,EAAE,qBAAqB;wBAC7C,sBAAsB,EAAE,qBAAqB;wBAC7C,qBAAqB,EAAE,YAAY;wBACnC,oBAAoB,EAAE,YAAY;wBAClC,kCAAkC,EAAE,MAAM;wBAC1C,yCAAyC,EAAE,UAAU;wBACrD,yCAAyC,EAAE,UAAU;wBACrD,wCAAwC,EAAE,YAAY;wBACtD,sCAAsC,EAAE,OAAO;wBAC/C,SAAS,EAAE,qBAAqB;qBACjC,aACU;wBACT;4BACE,OAAO,EAAE,qBAAqB;4BAC9B,WAAW,yBAAyB;yBACrC;qBACF;;0BA0HE,QAAQ;;0BAAI,MAAM;2BAAC,eAAe;;0BAClC,QAAQ;;0BACR,QAAQ;;0BACR,IAAI;;0BAAI,QAAQ;yCA9FT,aAAa;sBADtB,SAAS;uBAAC,aAAa,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;gBAWnC,gBAAgB;sBADtB,KAAK;gBAYK,OAAO;sBADjB,KAAK;gBAeK,OAAO;sBADjB,KAAK;gBAaK,UAAU;sBADpB,KAAK;gBAgBC,mBAAmB;sBADzB,KAAK;gBAOC,QAAQ;sBADd,KAAK;gBAIU,iBAAiB;sBADhC,KAAK;gBASU,WAAW;sBAD1B,MAAM;gBASS,IAAI;sBAFnB,MAAM;gBAuII,KAAK;sBADf,KAAK;gBASK,EAAE;sBADZ,KAAK;gBAiBK,QAAQ;sBADlB,KAAK;uBAAC,EAAE,SAAS,EAAE,gBAAgB,EAAE","sourcesContent":["import {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  DestroyRef,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  Self,\n  SimpleChanges,\n  ViewChild,\n  booleanAttribute,\n  inject\n} from '@angular/core';\nimport { CommonModule, TranslationWidth } from '@angular/common';\nimport { takeUntilDestroyed } from '@angular/core/rxjs-interop';\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  FormBuilder,\n  FormControl,\n  FormGroupDirective,\n  NgControl,\n  NgForm,\n  ReactiveFormsModule,\n  Validators\n} from '@angular/forms';\nimport {\n  NgbDateAdapter,\n  NgbDateStruct,\n  NgbDatepicker,\n  NgbDatepickerModule,\n  NgbTimepickerModule\n} from '@ng-bootstrap/ng-bootstrap';\nimport { nanoid } from 'nanoid';\nimport { Subject, debounceTime } from 'rxjs';\n\nimport {\n  ErrorStateMatcher,\n  ICanUpdateErrorState,\n  IHasErrorState,\n  IMPDC_FORM_ROOT,\n  ImpdcFormFieldControl,\n  ImpdcFormRoot,\n  ImpdcFormsModule,\n  mixinDisabled,\n  mixinErrorState,\n  mixinTabIndex\n} from '../../../form-field';\nimport {\n  DEFAULT_MAX_DATE,\n  DEFAULT_MIN_DATE,\n  DEFAULT_USE_MERIDIAN_LABEL\n} from '../../constants';\nimport { IDatetimePickerValue } from '../../types';\nimport { DatepickerTemplateHostComponent } from '../datepicker-template-host';\nimport { DatetimePickerInputFooterComponent } from '../datetime-picker-input-footer';\n\ninterface ITimeOptions {\n  readonly border: boolean;\n  readonly layout: 'inline' | 'stacked';\n}\n\nexport const DEFAULT_TIME_LAYOUT: ITimeOptions = {\n  border: false,\n  layout: 'inline'\n} as const;\n\nconst _DatetimePickerComponentBase = mixinTabIndex(\n  mixinDisabled(\n    mixinErrorState(\n      class {\n        public readonly stateChanges = new Subject<void>();\n\n        constructor(\n          public _defaultErrorStateMatcher: ErrorStateMatcher,\n          public _formRoot: ImpdcFormRoot,\n          public _parentForm: NgForm,\n          public _parentFormGroup: FormGroupDirective,\n          public ngControl: NgControl | null\n        ) {}\n      }\n    )\n  )\n);\n\n/**\n * A control for selecting date or datetime via an inline calendar control.\n *\n * Implements [ControlValueAccessor](https://angular.io/api/forms/ControlValueAccessor) to support two-way binding with\n * Angular forms via usage of the \\`[(ngModel)]\\`, \\`[formControl]\\`, and \\`[formControlName]\\` directives.\n *\n * The date and time controls inside this component leverage the value adapter patterns and services of NG-Bootstrap's\n * [Datepicker](https://ng-bootstrap.github.io/#/components/datepicker/overview#date-model) and\n * [Timepicker](https://ng-bootstrap.github.io/#/components/timepicker/examples#adapter) components when working with input values.\n * This means that `date` values will be [NgbDateStruct](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateStruct)\n * objects and `time` values will be [NgbTimeStruct](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeStruct) objects\n * by default, and the [NgbDateAdapter](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDateAdapter) and\n * [NgbTimeAdapter](https://ng-bootstrap.github.io/#/components/timepicker/api#NgbTimeAdapter) services will be used to handle them respectively.\n * If usage of alternative date and time models is desired, consult NG-Bootstrap's documentation for directions.\n */\n@Component({\n  selector: 'impdc-datetime-picker',\n  standalone: true,\n  imports: [\n    CommonModule,\n    ReactiveFormsModule,\n    NgbDatepickerModule,\n    NgbTimepickerModule,\n    DatepickerTemplateHostComponent,\n    DatetimePickerInputFooterComponent,\n    ImpdcFormsModule\n  ],\n  templateUrl: './datetime-picker.component.html',\n  styleUrls: ['./datetime-picker.component.scss'],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  // eslint-disable-next-line @angular-eslint/no-inputs-metadata-property\n  inputs: ['disabled', 'tabIndex'],\n  // eslint-disable-next-line @angular-eslint/no-host-metadata-property\n  host: {\n    '[attr.id]': 'id',\n    '[attr.tabindex]': 'tabIndex',\n    '[attr.aria-required]': 'required.toString()',\n    '[attr.aria-disabled]': 'disabled.toString()',\n    '[attr.aria-invalid]': 'errorState',\n    '[class.is-invalid]': 'errorState',\n    '[class.impdc-form-field-control]': 'true',\n    '[class.impdc-datetime-picker--required]': 'required',\n    '[class.impdc-datetime-picker--disabled]': 'disabled',\n    '[class.impdc-datetime-picker--invalid]': 'errorState',\n    '[class.impdc-datetime-picker--empty]': 'empty',\n    '(focus)': '_onFocus(); focus()'\n  },\n  providers: [\n    {\n      provide: ImpdcFormFieldControl,\n      useExisting: DatetimePickerComponent\n    }\n  ]\n})\nexport class DatetimePickerComponent\n  extends _DatetimePickerComponentBase\n  implements\n    ControlValueAccessor,\n    DoCheck,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    ImpdcFormFieldControl<IDatetimePickerValue<any, any> | null>,\n    ICanUpdateErrorState,\n    IHasErrorState\n{\n  private readonly _changeDetector = inject(ChangeDetectorRef);\n  private readonly _destroyRef = inject(DestroyRef);\n  private readonly _hostElement = inject(ElementRef);\n  private readonly _ngbDateAdapter = inject(NgbDateAdapter<any>);\n  private readonly _uid = `impdc-datetime-picker-${nanoid()}`;\n  private _previousControl?: AbstractControl | null;\n\n  protected readonly NgTranslationWidth = TranslationWidth;\n  protected readonly formGroup = inject(FormBuilder).group({\n    date: new FormControl<any>(null),\n    time: new FormControl<any>(null),\n    useMeridian: new FormControl<boolean>(true, { nonNullable: true })\n  });\n  protected cvaOnChange = (_: any) => {};\n  protected cvaOnTouched = () => {};\n\n  @ViewChild(NgbDatepicker, { static: true })\n  protected ngbDatepicker!: NgbDatepicker;\n\n  /**\n   * A callback function that can be evaluated to decide if a given date is disabled\n   * in the calendar view.\n   *\n   * @param date An [`NgbDate`](https://ng-bootstrap.github.io/#/components/datepicker/api#NgbDate) value describing the singular date being evaluated.\n   * @param current The month and year selected for the current calendar view.\n   */\n  @Input()\n  public markDateDisabled?: (\n    date: NgbDateStruct,\n    current?: { month: number; year: number }\n  ) => boolean;\n\n  /**\n   * The earliest allowable date for display or selection.\n   *\n   * @default { year: 1900, month: 1, day: 1 }\n   */\n  @Input()\n  public get minDate(): NgbDateStruct {\n    return { ...this._minDate };\n  }\n  public set minDate(value: NgbDateStruct | null) {\n    this._minDate = value || DEFAULT_MIN_DATE;\n  }\n  private _minDate: NgbDateStruct = DEFAULT_MIN_DATE;\n\n  /**\n   * The latest allowable date for display or selection.\n   *\n   * @default { year: 2099, month: 12, day: 31 }\n   */\n  @Input()\n  public get maxDate(): NgbDateStruct {\n    return { ...this._maxDate };\n  }\n  public set maxDate(value: NgbDateStruct | null) {\n    this._maxDate = value || DEFAULT_MAX_DATE;\n  }\n  private _maxDate: NgbDateStruct = DEFAULT_MAX_DATE;\n\n  /**\n   * Configurable options for setting the layout of the date and time controls within the component.\n   */\n  @Input()\n  public get timeLayout(): ITimeOptions {\n    return { ...this._timeLayout };\n  }\n  public set timeLayout(value: Partial<ITimeOptions>) {\n    this._timeLayout = {\n      ...DEFAULT_TIME_LAYOUT,\n      ...value\n    };\n  }\n  private _timeLayout: ITimeOptions = { ...DEFAULT_TIME_LAYOUT };\n\n  /**\n   * Label to be displayed with time controls to allow the user to input 24-hour or meridian-based (AM, PM) time.\n   */\n  @Input()\n  public meridianToggleLabel: string = DEFAULT_USE_MERIDIAN_LABEL;\n\n  /**\n   * Set whether to display controls for selecting a time value in addition to the date.\n   */\n  @Input()\n  public withTime = false;\n\n  @Input()\n  public override errorStateMatcher!: ErrorStateMatcher;\n\n  /**\n   * Events fire when raw value of picker input changes. Mainly exists to handle\n   * two-way binding of `value` input property.\n   * @ignore\n   */\n  @Output()\n  public readonly valueChange: EventEmitter<IDatetimePickerValue<\n    any,\n    any\n  > | null> = new EventEmitter<IDatetimePickerValue<any, any> | null>();\n\n  /** @ignore */\n  @Output()\n  // eslint-disable-next-line @angular-eslint/no-output-native\n  public readonly blur = new EventEmitter<FocusEvent>();\n\n  constructor(\n    _defaultErrorStateMatcher: ErrorStateMatcher,\n    @Optional() @Inject(IMPDC_FORM_ROOT) _formRoot: ImpdcFormRoot,\n    @Optional() _parentForm: NgForm,\n    @Optional() _parentFormGroup: FormGroupDirective,\n    @Self() @Optional() ngControl: NgControl\n  ) {\n    super(\n      _defaultErrorStateMatcher,\n      _formRoot,\n      _parentForm,\n      _parentFormGroup,\n      ngControl\n    );\n\n    if (this.ngControl) {\n      this.ngControl.valueAccessor = this;\n    }\n\n    this.id = this.id;\n  }\n\n  /** @ignore */\n  public focus(): void {\n    this.ngbDatepicker.focus();\n  }\n\n  /* Lifecycle Hooks */\n\n  /** @ignore */\n  public ngDoCheck(): void {\n    const ngControl = this.ngControl;\n\n    if (!ngControl) {\n      return;\n    }\n\n    if (this._previousControl !== ngControl.control) {\n      if (\n        this._previousControl !== undefined &&\n        ngControl.disabled !== null &&\n        ngControl.disabled !== this.disabled\n      ) {\n        this.disabled = ngControl?.disabled;\n      }\n\n      this._previousControl = ngControl.control;\n    }\n\n    this.updateErrorState();\n  }\n\n  /** @ignore */\n  public ngOnChanges(changes: SimpleChanges): void {\n    // Managing disabled state is handled via the `mixinDisabled` mixin/generator, but we still need to signal\n    // to the parent form field so it can run change detection when disabled state is changed.\n    if (changes['disabled']) {\n      this.stateChanges.next();\n    }\n  }\n\n  /** @ignore */\n  public ngOnDestroy(): void {\n    this.stateChanges.complete();\n  }\n\n  /** @ignore */\n  public ngOnInit(): void {\n    this.formGroup.valueChanges\n      .pipe(takeUntilDestroyed(this._destroyRef), debounceTime(100))\n      .subscribe(formValue => {\n        const changeValue = this._getValueFromFormModel(formValue);\n        this.cvaOnChange(changeValue);\n        this.valueChange.emit(changeValue);\n        this.cvaOnTouched();\n      });\n  }\n\n  /* ControlValueAccessor */\n\n  /** @ignore */\n  public writeValue(obj: IDatetimePickerValue<any, any> | any): void {\n    let newValue: Partial<IDatetimePickerValue> = {};\n    if (obj && 'date' in obj) {\n      newValue = {\n        ...newValue,\n        date: obj.date\n      };\n    }\n\n    if (this.withTime && obj && 'time' in obj) {\n      newValue = {\n        ...newValue,\n        time: obj.time\n      };\n    }\n\n    this.formGroup.patchValue(newValue, { emitEvent: false });\n    if ('date' in newValue) {\n      this.ngbDatepicker.focusDate(\n        this._ngbDateAdapter.fromModel(newValue.date)\n      );\n    }\n\n    this.stateChanges.next();\n  }\n\n  /** @ignore */\n  public registerOnChange(fn: any): void {\n    this.cvaOnChange = fn;\n  }\n\n  /** @ignore */\n  public registerOnTouched(fn: any): void {\n    this.cvaOnTouched = fn;\n  }\n\n  /** @ignore */\n  public setDisabledState?(isDisabled: boolean): void {\n    this.disabled = isDisabled;\n\n    if (isDisabled) {\n      this.formGroup.disable();\n    } else {\n      this.formGroup.enable();\n    }\n  }\n\n  /* ImpdcFormFieldControl */\n\n  @Input()\n  public get value(): IDatetimePickerValue<any, any> | null {\n    return this._getValueFromFormModel(this.formGroup.value);\n  }\n  public set value(value: IDatetimePickerValue<any, any> | null) {\n    this.writeValue(value);\n  }\n\n  @Input()\n  public get id(): string {\n    return this._id;\n  }\n  public set id(value: string) {\n    this._id = value || this._uid;\n    this.stateChanges.next();\n  }\n  protected _id!: string;\n\n  /**\n   * Used to set requiredness of control in a template-based manner;\n   * not necessary when using the Angular reactive forms API and `required` validator.\n   *\n   * @default false\n   */\n  @Input({ transform: booleanAttribute })\n  public get required(): boolean {\n    return (\n      this._required ??\n      this.ngControl?.control?.hasValidator(Validators.required) ??\n      false\n    );\n  }\n  public set required(value: boolean) {\n    this._required = value;\n    this.stateChanges.next();\n  }\n  private _required: boolean | undefined;\n\n  public get focused(): boolean {\n    return this._focused;\n  }\n  protected _focused = false;\n\n  public readonly controlType: string = 'impdc-datetime-picker';\n  public readonly supportsAffixes: boolean = false;\n\n  /* Internals */\n\n  protected get useMeridian(): boolean {\n    return this.formGroup.getRawValue().useMeridian;\n  }\n\n  protected get useMeridianLabelText(): string {\n    return this.meridianToggleLabel?.trim() || DEFAULT_USE_MERIDIAN_LABEL;\n  }\n\n  protected handleFocusOut(evt: FocusEvent): void {\n    if (\n      !evt.relatedTarget ||\n      !this._hostElement.nativeElement.contains(evt.relatedTarget)\n    ) {\n      this._onBlur(evt);\n    }\n  }\n\n  private _getValueFromFormModel(\n    formValue: Partial<{ date: any; time: any; useMeridian: any }>\n  ): IDatetimePickerValue<any, any> | null {\n    if (!formValue.date && !formValue.time) {\n      return null;\n    }\n\n    let result: IDatetimePickerValue<any, any> = {\n      date: formValue.date\n    };\n\n    if (this.withTime) {\n      result = {\n        ...result,\n        time: formValue.time\n      };\n    }\n\n    return result;\n  }\n\n  private _dateIsOutsideCurrentMonth(\n    date: NgbDateStruct,\n    current?: { month: number; year: number }\n  ): boolean {\n    return !!current && date.month !== current.month;\n  }\n\n  protected readonly markDateDisabledFn = (\n    date: NgbDateStruct,\n    current?: { month: number; year: number }\n  ) => {\n    return (\n      this._dateIsOutsideCurrentMonth(date, current) ||\n      (!!this.markDateDisabled && this.markDateDisabled(date, current))\n    );\n  };\n\n  protected _onFocus(): void {\n    if (!this.disabled) {\n      this._focused = true;\n      this.stateChanges.next();\n    }\n  }\n\n  protected _onBlur(focusEvent: FocusEvent): void {\n    this._focused = false;\n\n    if (!this.disabled) {\n      this.cvaOnTouched();\n      this.blur.emit(focusEvent);\n      this._changeDetector.markForCheck();\n      this.stateChanges.next();\n    }\n  }\n}\n","<impdc-datepicker-template-host #templateHost></impdc-datepicker-template-host>\n<div\n  [formGroup]=\"formGroup\"\n  class=\"d-flex\"\n  [ngClass]=\"{\n    'flex-column': withTime && timeLayout.layout === 'stacked'\n  }\"\n  (focusout)=\"handleFocusOut($event)\">\n  <ngb-datepicker\n    class=\"impdc-datetime-picker--datepicker\"\n    formControlName=\"date\"\n    [dayTemplate]=\"templateHost.dayTemplateRef\"\n    [contentTemplate]=\"templateHost.contentTemplateRef\"\n    [showWeekNumbers]=\"false\"\n    outsideDays=\"visible\"\n    [weekdays]=\"NgTranslationWidth.Abbreviated\"\n    [markDisabled]=\"markDateDisabledFn\"\n    [minDate]=\"minDate\"\n    [maxDate]=\"maxDate\" />\n  @if (withTime) {\n  <div\n    class=\"impdc-datetime-picker--timepicker d-flex flex-column gap-4 p-4 w-100\"\n    [ngClass]=\"{\n      'border-0': !timeLayout.border,\n      'border-gray-200': timeLayout.border,\n      'mt-2': timeLayout.layout === 'stacked',\n      'border-top': timeLayout.border && timeLayout.layout === 'stacked',\n      'ms-2': timeLayout.layout === 'inline',\n      'border-start': timeLayout.border && timeLayout.layout === 'inline'\n    }\">\n    <impdc-checkbox\n      [label]=\"useMeridianLabelText\"\n      formControlName=\"useMeridian\"\n      [isSwitch]=\"true\"\n      layout=\"check-end\" />\n    <ngb-timepicker\n      formControlName=\"time\"\n      [meridian]=\"useMeridian\"\n      [seconds]=\"false\"\n      [spinners]=\"false\"\n      size=\"medium\"></ngb-timepicker>\n  </div>\n  }\n</div>\n"]}

package/esm2022/lib/datetime-picker/components/datetime-picker/index.mjs

@@ -0,0 +1,2 @@
+export * from './datetime-picker.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9kZXNpZ24tY29tcG9uZW50cy9zcmMvbGliL2RhdGV0aW1lLXBpY2tlci9jb21wb25lbnRzL2RhdGV0aW1lLXBpY2tlci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9kYXRldGltZS1waWNrZXIuY29tcG9uZW50JztcbiJdfQ==