@porscheinformatik/clr-addons 18.0.4 → 18.1.1

package/esm2022/daterangepicker/directives/daterangepicker/daterangepicker.directive.mjs

@@ -6,6 +6,7 @@ import { DaterangeService } from '../../providers/daterange.service';
 import { DaterangeParsingService } from '../../providers/daterange-parsing.service';
 import { DaterangeControlStateService } from '../../providers/daterange-control-state.service';
 import { ControlIdService } from '../../../abstract-form-component/control-id.service';
+import { TimeModel } from '../../models/time.model';
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/forms";
 import * as i2 from "../../providers/daterange-control-state.service";
@@ -29,6 +30,16 @@ export class ClrDaterangepickerDirective {
         this.daterangeService.maxDate = !value ? null : new DayModel(value);
     }
     get placeholderText() {
+        if (this.daterangeService.timeActive) {
+            return (this.placeholder ??
+                this.daterangeParsingService.localeFormat +
+                    ' hh:mm' +
+                    (this.daterangeService.timeSecondsActive ? ':ss' : '') +
+                    this.separatorText +
+                    this.daterangeParsingService.localeFormat +
+                    ' hh:mm' +
+                    (this.daterangeService.timeSecondsActive ? ':ss' : ''));
+        }
         return (this.placeholder ??
             this.daterangeParsingService.localeFormat + this.separatorText + this.daterangeParsingService.localeFormat);
     }
@@ -70,6 +81,11 @@ export class ClrDaterangepickerDirective {
          * Locale text between 'from' and 'to' dateranges.
          */
         this.separatorText = SEPARATOR_TEXT_DEFAULT;
+        this.regex = /^[0-9]+[mhdw]$/;
+        this.regexW = /^[0-9]+w$/;
+        this.regexH = /^[0-9]+h$/;
+        this.regexD = /^[0-9]+d$/;
+        this.regexM = /^[0-9]+m$/;
         /**
          * Event that is triggered when value changes.
          */
@@ -117,6 +133,15 @@ export class ClrDaterangepickerDirective {
         if (this.control.control.hasError('invalid')) {
             delete this.control.control.errors.invalid;
         }
+        if (!target) {
+            return;
+        }
+        console.log('aaaaa', target, this.regex.test(target.value));
+        if (target.value && this.regex.test(target.value)) {
+            // handle easy access
+            this.handleEasyAccess(target.value);
+            return;
+        }
         // If there is nothing to parse, `ClrDaterangeRequiredValidator` will take care of this.
         if (!target.value) {
             this.daterangeService.updateSelectedDaterange(null, true);
@@ -174,7 +199,19 @@ export class ClrDaterangepickerDirective {
      * Update input with friendly daterange text.
      */
     updateInput() {
-        const dateString = this.daterangeParsingService.toLocaleString(this.daterangeService.selectedDaterange, this.separatorText);
+        let dateString;
+        if (this.daterangeService.timeActive) {
+            if (this.daterangeService.selectedDaterange &&
+                Object.prototype.hasOwnProperty.call(this.daterangeService.selectedDaterange, 'fromTime')) {
+                this.daterangeService.updateSelectedDaterange(this.daterangeService.selectedDaterange
+                    ? this.daterangeService.selectedDaterange
+                    : null, false);
+            }
+            dateString = this.daterangeParsingService.toLocaleStringWithTime(this.daterangeService.selectedDaterange, this.separatorText);
+        }
+        else {
+            dateString = this.daterangeParsingService.toLocaleString(this.daterangeService.selectedDaterange, this.separatorText);
+        }
         this.renderer.setProperty(this.element.nativeElement, 'value', dateString);
     }
     /**
@@ -205,6 +242,43 @@ export class ClrDaterangepickerDirective {
     setDisabledState(disabled) {
         this.daterangeControlStateService.disabled = disabled;
     }
+    handleEasyAccess(value) {
+        const now = new Date();
+        if (this.regexW.test(value)) {
+            value = value.replace('w', '');
+            now.setDate(now.getDate() - Number(value) * 7);
+            this.daterangeService.updateSelectedDaterange({
+                from: new DayModel(now),
+                to: new DayModel(new Date()),
+            }, true);
+        }
+        else if (this.regexD.test(value)) {
+            value = value.replace('d', '');
+            now.setDate(now.getDate() - Number(value));
+            this.daterangeService.updateSelectedDaterange({
+                from: new DayModel(now),
+                to: new DayModel(new Date()),
+            }, true);
+        }
+        else if (this.regexH.test(value)) {
+            value = value.replace('h', '');
+            this.daterangeService.updateSelectedDaterange({
+                from: new DayModel(new Date()),
+                to: new DayModel(new Date()),
+                fromTime: new TimeModel(new Date(new Date().getTime() - Number(value) * 3600000)),
+                toTime: new TimeModel(new Date()),
+            }, true);
+        }
+        else if (this.regexM.test(value)) {
+            value = value.replace('m', '');
+            this.daterangeService.updateSelectedDaterange({
+                from: new DayModel(new Date()),
+                to: new DayModel(new Date()),
+                fromTime: new TimeModel(new Date(new Date().getTime() - Number(value) * 60000)),
+                toTime: new TimeModel(new Date()),
+            }, true);
+        }
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ClrDaterangepickerDirective, deps: [{ token: i1.NgControl, self: true }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.DaterangeControlStateService }, { token: i3.ControlIdService }, { token: i4.DaterangeService }, { token: i5.DaterangeParsingService }], target: i0.ɵɵFactoryTarget.Directive }); }
     static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.5", type: ClrDaterangepickerDirective, selector: "[clrDaterangepicker]", inputs: { min: "min", max: "max", separatorText: "separatorText", placeholder: "placeholder", id: "id", disabled: "disabled" }, outputs: { valueChange: "valueChange" }, host: { listeners: { "change": "onChangeEvent($event.target)", "focus": "focusEvent()", "blur": "blurEvent()" }, properties: { "attr.placeholder": "this.placeholderText", "id": "this.id", "disabled": "this.disabled", "attr.type": "this.inputType", "class.clr-input": "this.inputClass" } }, ngImport: i0 }); }
 }
@@ -253,4 +327,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImpor
                 type: HostListener,
                 args: ['blur']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker.directive.js","sourceRoot":"","sources":["../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker/daterangepicker.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  Self,\n} from '@angular/core';\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\nimport { Subscription } from 'rxjs';\n\nimport { SEPARATOR_TEXT_DEFAULT } from '../../daterange.constants';\nimport { NullableDaterange } from '../../interfaces/daterange.interface';\nimport { DayModel } from '../../models/day.model';\nimport { DaterangeService } from '../../providers/daterange.service';\nimport { DaterangeParsingService } from '../../providers/daterange-parsing.service';\nimport { DaterangeControlStateService } from '../../providers/daterange-control-state.service';\nimport { ControlIdService } from '../../../abstract-form-component/control-id.service';\n\n/**\n * Daterangepicker.\n */\n@Directive({\n  selector: '[clrDaterangepicker]',\n})\nexport class ClrDaterangepickerDirective implements OnInit, OnDestroy, ControlValueAccessor {\n  /**\n   * Minimum date that can be selected.\n   */\n  @Input()\n  public set min(value: string | undefined | null) {\n    this.daterangeService.minDate = !value ? null : new DayModel(value);\n  }\n\n  /**\n   * Maximum date that can be selected.\n   */\n  @Input()\n  public set max(value: string | undefined | null) {\n    this.daterangeService.maxDate = !value ? null : new DayModel(value);\n  }\n\n  /**\n   * Locale text between 'from' and 'to' dateranges.\n   */\n  @Input()\n  public separatorText: string = SEPARATOR_TEXT_DEFAULT;\n\n  /**\n   * Placeholder text.\n   *\n   * It is recommend against overriding the automatically generated placeholder.\n   * Adding an incorrect placeholder will create confusion while entering the daterange in the input.\n   */\n  @Input() public placeholder: string;\n  @HostBinding('attr.placeholder')\n  public get placeholderText(): string {\n    return (\n      this.placeholder ??\n      this.daterangeParsingService.localeFormat + this.separatorText + this.daterangeParsingService.localeFormat\n    );\n  }\n\n  /**\n   * Id-attribute.\n   */\n  @HostBinding()\n  @Input()\n  public get id() {\n    return this.controlIdService.id;\n  }\n  /**\n   * Id-attribute.\n   * @returns Id-attribute.\n   */\n  public set id(value: string) {\n    this.controlIdService.id = value;\n  }\n\n  /**\n   * Disable control.\n   */\n  @HostBinding('disabled')\n  @Input()\n  public set disabled(value: boolean) {\n    this.daterangeControlStateService.disabled = value;\n  }\n  /**\n   * Disabled state.\n   * @returns Disabled state.\n   */\n  public get disabled() {\n    return this.daterangeControlStateService.disabled;\n  }\n\n  /**\n   * Event that is triggered when value changes.\n   */\n  @Output()\n  public valueChange = new EventEmitter<NullableDaterange>();\n\n  /** Set the `type` attribute always to \"text\", to not get the native datepicker. */\n  @HostBinding('attr.type')\n  public inputType = 'text';\n\n  @HostBinding('class.clr-input')\n  public inputClass = true;\n\n  /** List of subscriptions to later destroy. */\n  private subscriptions: Array<Subscription> = [];\n\n  public constructor(\n    @Self()\n    private readonly control: NgControl,\n    private readonly element: ElementRef,\n    private readonly renderer: Renderer2,\n    private readonly daterangeControlStateService: DaterangeControlStateService,\n    private readonly controlIdService: ControlIdService,\n    private readonly daterangeService: DaterangeService,\n    private readonly daterangeParsingService: DaterangeParsingService\n  ) {\n    // To get access to the NgControl, we had to remove the `NG_VALUE_ACCESSOR`\n    // provider and set them manually, while still keeping the interfaces.\n    this.control.valueAccessor = this;\n  }\n\n  public ngOnInit(): void {\n    this.listenForDaterangeValueChanges();\n    this.listenForControlStatusChanges();\n  }\n\n  public ngOnDestroy(): void {\n    this.subscriptions.forEach(subscription => subscription.unsubscribe());\n  }\n\n  /**\n   * Listen for daterange value changes.\n   */\n  private listenForDaterangeValueChanges(): void {\n    this.subscriptions.push(\n      this.daterangeService.valueChange.subscribe((_daterange: NullableDaterange) => {\n        this.triggerChange();\n      })\n    );\n  }\n\n  /**\n   * Listen for control status changes.\n   */\n  private listenForControlStatusChanges(): void {\n    this.subscriptions.push(\n      this.control.statusChanges.subscribe((_status: unknown) => {\n        this.daterangeControlStateService.updateStatus(this.control.control);\n      })\n    );\n  }\n\n  /**\n   * Listen to manual changes to the input.\n   * @param target - Input element.\n   */\n  @HostListener('change', ['$event.target'])\n  public onChangeEvent(target: HTMLInputElement): void {\n    // Remove 'invalid' error.\n    if (this.control.control.hasError('invalid')) {\n      delete this.control.control.errors.invalid;\n    }\n\n    // If there is nothing to parse, `ClrDaterangeRequiredValidator` will take care of this.\n    if (!target.value) {\n      this.daterangeService.updateSelectedDaterange(null, true);\n      return;\n    }\n\n    const daterange = this.daterangeParsingService.parse(target.value, this.separatorText);\n    const invalidDaterange: boolean = daterange == null || daterange.from == null || daterange.to == null;\n\n    // Invalid manual daterange specified.\n    if (invalidDaterange) {\n      this.control.control.setErrors({\n        invalid: target.value,\n      });\n    }\n\n    // Update selected daterange, but only notify when valid.\n    this.daterangeService.updateSelectedDaterange(daterange, !invalidDaterange);\n  }\n\n  /**\n   * Listen to focus event.\n   */\n  @HostListener('focus')\n  public focusEvent(): void {\n    this.daterangeControlStateService.focused = true;\n  }\n\n  /**\n   * Listen to blur event.\n   */\n  @HostListener('blur')\n  public blurEvent(): void {\n    this.daterangeControlStateService.focused = false;\n  }\n\n  /**\n   * Focus input.\n   */\n  public focus(): void {\n    this.element.nativeElement.focus();\n  }\n\n  /**\n   * Trigger events to notify form controls, trigger validation and update attributes/properties.\n   */\n  private triggerChange(): void {\n    let daterange = this.daterangeService.selectedDaterange;\n\n    // When `from` or `to` properties are not set, return null.\n    // This will trigger the `required` validator (if present).\n    if (!this.daterangeService.isValid()) {\n      daterange = null;\n    }\n\n    // Mark control dirty.\n    this.onTouched(daterange);\n    // Update NgModel.\n    this.onChanged(daterange);\n    // Notify parent.\n    this.valueChange.emit(daterange);\n    // Update attributes/properties.\n    this.updateInput();\n  }\n\n  /**\n   * Update input with friendly daterange text.\n   */\n  private updateInput(): void {\n    const dateString = this.daterangeParsingService.toLocaleString(\n      this.daterangeService.selectedDaterange,\n      this.separatorText\n    );\n    this.renderer.setProperty(this.element.nativeElement, 'value', dateString);\n  }\n\n  /**\n   * ControlValueAccessor method. Set value from NgModel.\n   * @param value - Daterange value.\n   */\n  public writeValue(value: NullableDaterange) {\n    this.daterangeService.updateSelectedDaterange(value);\n  }\n\n  /**\n   * ControlValueAccessor method. Register change event. When value changes.\n   * @param fn - Change event.\n   */\n  public registerOnChange(fn: (value: NullableDaterange) => void): void {\n    this.onChanged = fn;\n  }\n  private onChanged = (_value: NullableDaterange): void => undefined;\n\n  /**\n   * ControlValueAccessor method. Register touch event. When control is dirty.\n   * @param fn - Touch event.\n   */\n  public registerOnTouched(fn: (value: NullableDaterange) => void): void {\n    this.onTouched = fn;\n  }\n  private onTouched = (_value: NullableDaterange): void => undefined;\n\n  /**\n   * ControlValueAccessor method. Set disabled state.\n   * @param disabled - Disabled state.\n   */\n  public setDisabledState(disabled: boolean): void {\n    this.daterangeControlStateService.disabled = disabled;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker.directive.js","sourceRoot":"","sources":["../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker/daterangepicker.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n  Renderer2,\n  Self,\n} from '@angular/core';\nimport { ControlValueAccessor, NgControl } from '@angular/forms';\nimport { Subscription } from 'rxjs';\n\nimport { SEPARATOR_TEXT_DEFAULT } from '../../daterange.constants';\nimport { NullableDaterange } from '../../interfaces/daterange.interface';\nimport { DayModel } from '../../models/day.model';\nimport { DaterangeService } from '../../providers/daterange.service';\nimport { DaterangeParsingService } from '../../providers/daterange-parsing.service';\nimport { DaterangeControlStateService } from '../../providers/daterange-control-state.service';\nimport { ControlIdService } from '../../../abstract-form-component/control-id.service';\nimport { NullableTimerange } from '../../interfaces/timerange.interface';\nimport { TimeModel } from '../../models/time.model';\n\n/**\n * Daterangepicker.\n */\n@Directive({\n  selector: '[clrDaterangepicker]',\n})\nexport class ClrDaterangepickerDirective implements OnInit, OnDestroy, ControlValueAccessor {\n  /**\n   * Minimum date that can be selected.\n   */\n  @Input()\n  public set min(value: string | undefined | null) {\n    this.daterangeService.minDate = !value ? null : new DayModel(value);\n  }\n\n  /**\n   * Maximum date that can be selected.\n   */\n  @Input()\n  public set max(value: string | undefined | null) {\n    this.daterangeService.maxDate = !value ? null : new DayModel(value);\n  }\n\n  /**\n   * Locale text between 'from' and 'to' dateranges.\n   */\n  @Input()\n  public separatorText: string = SEPARATOR_TEXT_DEFAULT;\n\n  regex = /^[0-9]+[mhdw]$/;\n  regexW = /^[0-9]+w$/;\n  regexH = /^[0-9]+h$/;\n  regexD = /^[0-9]+d$/;\n  regexM = /^[0-9]+m$/;\n\n  /**\n   * Placeholder text.\n   *\n   * It is recommend against overriding the automatically generated placeholder.\n   * Adding an incorrect placeholder will create confusion while entering the daterange in the input.\n   */\n  @Input() public placeholder: string;\n\n  @HostBinding('attr.placeholder')\n  public get placeholderText(): string {\n    if (this.daterangeService.timeActive) {\n      return (\n        this.placeholder ??\n        this.daterangeParsingService.localeFormat +\n          ' hh:mm' +\n          (this.daterangeService.timeSecondsActive ? ':ss' : '') +\n          this.separatorText +\n          this.daterangeParsingService.localeFormat +\n          ' hh:mm' +\n          (this.daterangeService.timeSecondsActive ? ':ss' : '')\n      );\n    }\n    return (\n      this.placeholder ??\n      this.daterangeParsingService.localeFormat + this.separatorText + this.daterangeParsingService.localeFormat\n    );\n  }\n\n  /**\n   * Id-attribute.\n   */\n  @HostBinding()\n  @Input()\n  public get id() {\n    return this.controlIdService.id;\n  }\n\n  /**\n   * Id-attribute.\n   * @returns Id-attribute.\n   */\n  public set id(value: string) {\n    this.controlIdService.id = value;\n  }\n\n  /**\n   * Disable control.\n   */\n  @HostBinding('disabled')\n  @Input()\n  public set disabled(value: boolean) {\n    this.daterangeControlStateService.disabled = value;\n  }\n\n  /**\n   * Disabled state.\n   * @returns Disabled state.\n   */\n  public get disabled() {\n    return this.daterangeControlStateService.disabled;\n  }\n\n  /**\n   * Event that is triggered when value changes.\n   */\n  @Output()\n  public valueChange = new EventEmitter<NullableDaterange>();\n\n  /** Set the `type` attribute always to \"text\", to not get the native datepicker. */\n  @HostBinding('attr.type')\n  public inputType = 'text';\n\n  @HostBinding('class.clr-input')\n  public inputClass = true;\n\n  /** List of subscriptions to later destroy. */\n  private subscriptions: Array<Subscription> = [];\n\n  public constructor(\n    @Self()\n    private readonly control: NgControl,\n    private readonly element: ElementRef,\n    private readonly renderer: Renderer2,\n    private readonly daterangeControlStateService: DaterangeControlStateService,\n    private readonly controlIdService: ControlIdService,\n    private readonly daterangeService: DaterangeService,\n    private readonly daterangeParsingService: DaterangeParsingService\n  ) {\n    // To get access to the NgControl, we had to remove the `NG_VALUE_ACCESSOR`\n    // provider and set them manually, while still keeping the interfaces.\n    this.control.valueAccessor = this;\n  }\n\n  public ngOnInit(): void {\n    this.listenForDaterangeValueChanges();\n    this.listenForControlStatusChanges();\n  }\n\n  public ngOnDestroy(): void {\n    this.subscriptions.forEach(subscription => subscription.unsubscribe());\n  }\n\n  /**\n   * Listen for daterange value changes.\n   */\n  private listenForDaterangeValueChanges(): void {\n    this.subscriptions.push(\n      this.daterangeService.valueChange.subscribe((_daterange: NullableDaterange) => {\n        this.triggerChange();\n      })\n    );\n  }\n\n  /**\n   * Listen for control status changes.\n   */\n  private listenForControlStatusChanges(): void {\n    this.subscriptions.push(\n      this.control.statusChanges.subscribe((_status: unknown) => {\n        this.daterangeControlStateService.updateStatus(this.control.control);\n      })\n    );\n  }\n\n  /**\n   * Listen to manual changes to the input.\n   * @param target - Input element.\n   */\n  @HostListener('change', ['$event.target'])\n  public onChangeEvent(target: HTMLInputElement): void {\n    // Remove 'invalid' error.\n    if (this.control.control.hasError('invalid')) {\n      delete this.control.control.errors.invalid;\n    }\n    if (!target) {\n      return;\n    }\n\n    console.log('aaaaa', target, this.regex.test(target.value));\n    if (target.value && this.regex.test(target.value)) {\n      // handle easy access\n      this.handleEasyAccess(target.value);\n      return;\n    }\n\n    // If there is nothing to parse, `ClrDaterangeRequiredValidator` will take care of this.\n    if (!target.value) {\n      this.daterangeService.updateSelectedDaterange(null, true);\n      return;\n    }\n\n    const daterange = this.daterangeParsingService.parse(target.value, this.separatorText);\n    const invalidDaterange: boolean = daterange == null || daterange.from == null || daterange.to == null;\n\n    // Invalid manual daterange specified.\n    if (invalidDaterange) {\n      this.control.control.setErrors({\n        invalid: target.value,\n      });\n    }\n\n    // Update selected daterange, but only notify when valid.\n    this.daterangeService.updateSelectedDaterange(daterange, !invalidDaterange);\n  }\n\n  /**\n   * Listen to focus event.\n   */\n  @HostListener('focus')\n  public focusEvent(): void {\n    this.daterangeControlStateService.focused = true;\n  }\n\n  /**\n   * Listen to blur event.\n   */\n  @HostListener('blur')\n  public blurEvent(): void {\n    this.daterangeControlStateService.focused = false;\n  }\n\n  /**\n   * Focus input.\n   */\n  public focus(): void {\n    this.element.nativeElement.focus();\n  }\n\n  /**\n   * Trigger events to notify form controls, trigger validation and update attributes/properties.\n   */\n  private triggerChange(): void {\n    let daterange = this.daterangeService.selectedDaterange;\n\n    // When `from` or `to` properties are not set, return null.\n    // This will trigger the `required` validator (if present).\n    if (!this.daterangeService.isValid()) {\n      daterange = null;\n    }\n\n    // Mark control dirty.\n    this.onTouched(daterange);\n    // Update NgModel.\n    this.onChanged(daterange);\n    // Notify parent.\n    this.valueChange.emit(daterange);\n    // Update attributes/properties.\n    this.updateInput();\n  }\n\n  /**\n   * Update input with friendly daterange text.\n   */\n  private updateInput(): void {\n    let dateString;\n    if (this.daterangeService.timeActive) {\n      if (\n        this.daterangeService.selectedDaterange &&\n        Object.prototype.hasOwnProperty.call(this.daterangeService.selectedDaterange, 'fromTime')\n      ) {\n        this.daterangeService.updateSelectedDaterange(\n          this.daterangeService.selectedDaterange\n            ? (this.daterangeService.selectedDaterange as NullableTimerange)\n            : null,\n          false\n        );\n      }\n      dateString = this.daterangeParsingService.toLocaleStringWithTime(\n        this.daterangeService.selectedDaterange,\n        this.separatorText\n      );\n    } else {\n      dateString = this.daterangeParsingService.toLocaleString(\n        this.daterangeService.selectedDaterange,\n        this.separatorText\n      );\n    }\n    this.renderer.setProperty(this.element.nativeElement, 'value', dateString);\n  }\n\n  /**\n   * ControlValueAccessor method. Set value from NgModel.\n   * @param value - Daterange value.\n   */\n  public writeValue(value: NullableDaterange) {\n    this.daterangeService.updateSelectedDaterange(value);\n  }\n\n  /**\n   * ControlValueAccessor method. Register change event. When value changes.\n   * @param fn - Change event.\n   */\n  public registerOnChange(fn: (value: NullableDaterange) => void): void {\n    this.onChanged = fn;\n  }\n\n  private onChanged = (_value: NullableDaterange): void => undefined;\n\n  /**\n   * ControlValueAccessor method. Register touch event. When control is dirty.\n   * @param fn - Touch event.\n   */\n  public registerOnTouched(fn: (value: NullableDaterange) => void): void {\n    this.onTouched = fn;\n  }\n\n  private onTouched = (_value: NullableDaterange): void => undefined;\n\n  /**\n   * ControlValueAccessor method. Set disabled state.\n   * @param disabled - Disabled state.\n   */\n  public setDisabledState(disabled: boolean): void {\n    this.daterangeControlStateService.disabled = disabled;\n  }\n\n  private handleEasyAccess(value: string) {\n    const now = new Date();\n    if (this.regexW.test(value)) {\n      value = value.replace('w', '');\n      now.setDate(now.getDate() - Number(value) * 7);\n      this.daterangeService.updateSelectedDaterange(\n        {\n          from: new DayModel(now),\n          to: new DayModel(new Date()),\n        },\n        true\n      );\n    } else if (this.regexD.test(value)) {\n      value = value.replace('d', '');\n      now.setDate(now.getDate() - Number(value));\n      this.daterangeService.updateSelectedDaterange(\n        {\n          from: new DayModel(now),\n          to: new DayModel(new Date()),\n        },\n        true\n      );\n    } else if (this.regexH.test(value)) {\n      value = value.replace('h', '');\n      this.daterangeService.updateSelectedDaterange(\n        {\n          from: new DayModel(new Date()),\n          to: new DayModel(new Date()),\n          fromTime: new TimeModel(new Date(new Date().getTime() - Number(value) * 3600000)),\n          toTime: new TimeModel(new Date()),\n        },\n        true\n      );\n    } else if (this.regexM.test(value)) {\n      value = value.replace('m', '');\n      this.daterangeService.updateSelectedDaterange(\n        {\n          from: new DayModel(new Date()),\n          to: new DayModel(new Date()),\n          fromTime: new TimeModel(new Date(new Date().getTime() - Number(value) * 60000)),\n          toTime: new TimeModel(new Date()),\n        },\n        true\n      );\n    }\n  }\n}\n"]}

package/esm2022/daterangepicker/directives/daterangepicker-container/daterangepicker-container.component.mjs

@@ -1,5 +1,5 @@
 import { Component, ContentChild, HostBinding, Input, Optional, QueryList, ViewChildren, } from '@angular/core';
-import { ClarityIcons, calendarIcon, checkCircleIcon, exclamationCircleIcon, windowCloseIcon } from '@cds/core/icon';
+import { calendarIcon, checkCircleIcon, ClarityIcons, exclamationCircleIcon, trashIcon, windowCloseIcon, } from '@cds/core/icon';
 import '@cds/core/icon/register.js';
 import { ClrCommonStringsService, ClrLayout, ClrPopoverEventsService, ClrPopoverPositionService, ClrPopoverToggleService, } from '@clr/angular';
 import { ControlIdService } from '../../../abstract-form-component/control-id.service';
@@ -21,7 +21,8 @@ import * as i5 from "../../providers/daterange-parsing.service";
 import * as i6 from "@angular/common";
 import * as i7 from "@angular/forms";
 import * as i8 from "../datepicker/datepicker.component";
-ClarityIcons.addIcons(calendarIcon, exclamationCircleIcon, checkCircleIcon, windowCloseIcon);
+import * as i9 from "../timepicker/timepicker.component";
+ClarityIcons.addIcons(calendarIcon, exclamationCircleIcon, checkCircleIcon, windowCloseIcon, trashIcon);
 /**
  * Daterangepicker container.
  */
@@ -41,6 +42,11 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
     get dateFrom() {
         return this.daterangeService.selectedDaterange?.from;
     }
+    get timeFrom() {
+        return this.daterangeService.selectedDaterange
+            ? this.daterangeService.selectedDaterange.fromTime
+            : null;
+    }
     /**
      * Date to.
      * @returns Date to.
@@ -48,6 +54,11 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
     get dateTo() {
         return this.daterangeService.selectedDaterange?.to;
     }
+    get timeTo() {
+        return this.daterangeService.selectedDaterange
+            ? this.daterangeService.selectedDaterange.toTime
+            : null;
+    }
     /**
      * Minimum date that can be selected.
      * @returns Minimum date that can be selected.
@@ -89,6 +100,12 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
          * List of presets.
          */
         this.presets = [];
+        /**
+         * List of time presets.
+         */
+        this.presetsDateTime = [];
+        this.timeSelection = false;
+        this.activateSeconds = false;
         /**
          * Text for the 'from' label.
          */
@@ -114,6 +131,8 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
         if (this.daterangepickerDirective == null) {
             throw new Error('`ClrDaterangepickerContainerComponent` requires an child `ClrDaterangepickerDirective`');
         }
+        this.daterangeService.timeActive = this.timeSelection;
+        this.daterangeService.timeSecondsActive = this.activateSeconds;
         this.listenForDaterangeValueChanges();
         this.listenForOpenedDatepickersTrackerChanges();
         this.listenForPopoverToggleChanges();
@@ -178,20 +197,40 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
      * @param value - Date from.
      */
     onDateFromChange(value) {
-        this.daterangeService.updateSelectedDaterange({
-            from: value,
-            to: this.dateTo,
-        });
+        if (this.daterangeService.timeActive) {
+            this.daterangeService.updateSelectedDaterange({
+                from: value,
+                to: this.dateTo,
+                fromTime: this.timeFrom,
+                toTime: this.timeTo,
+            });
+        }
+        else {
+            this.daterangeService.updateSelectedDaterange({
+                from: value,
+                to: this.dateTo,
+            });
+        }
     }
     /**
      * Event triggered when date to changed.
      * @param value - Date to.
      */
     onDateToChange(value) {
-        this.daterangeService.updateSelectedDaterange({
-            from: this.dateFrom,
-            to: value,
-        });
+        if (this.daterangeService.timeActive) {
+            this.daterangeService.updateSelectedDaterange({
+                from: this.dateFrom,
+                to: value,
+                fromTime: this.timeFrom,
+                toTime: this.timeTo,
+            });
+        }
+        else {
+            this.daterangeService.updateSelectedDaterange({
+                from: this.dateFrom,
+                to: value,
+            });
+        }
     }
     /**
      * Apply selected preset.
@@ -206,8 +245,33 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
             this.clrPopoverToggleService.open = false;
         }
     }
+    applyPresetTime(preset) {
+        const range = preset.range();
+        this.daterangeService.updateSelectedDaterange(range);
+        // Close popover here, because it's not possible to conditionally
+        // apply `clrPopoverCloseButton` directive on preset button.
+        if (this.daterangeService.isValid()) {
+            this.clrPopoverToggleService.open = false;
+        }
+    }
+    onTimeFromChange(value) {
+        this.daterangeService.updateSelectedDaterange({
+            from: this.dateFrom,
+            to: this.dateTo,
+            fromTime: value,
+            toTime: this.timeTo,
+        });
+    }
+    onTimeToChange(value) {
+        this.daterangeService.updateSelectedDaterange({
+            from: this.dateFrom,
+            to: this.dateTo,
+            fromTime: this.timeFrom,
+            toTime: value,
+        });
+    }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ClrDaterangepickerContainerComponent, deps: [{ token: i1.ClrPopoverEventsService }, { token: i1.ClrPopoverToggleService }, { token: i1.ClrCommonStringsService }, { token: i1.ClrLayout, optional: true }, { token: i2.DaterangeControlStateService }, { token: i3.OpenedDatepickersTrackerService }, { token: i4.DaterangeService }, { token: i5.DaterangeParsingService }], target: i0.ɵɵFactoryTarget.Component }); }
-    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.5", type: ClrDaterangepickerContainerComponent, selector: "clr-daterangepicker-container", inputs: { presets: "presets", clrPosition: "clrPosition", labelFrom: "labelFrom", labelTo: "labelTo" }, host: { properties: { "class": "this.classes" } }, providers: [
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.5", type: ClrDaterangepickerContainerComponent, selector: "clr-daterangepicker-container", inputs: { presets: "presets", presetsDateTime: "presetsDateTime", timeSelection: "timeSelection", activateSeconds: "activateSeconds", clrPosition: "clrPosition", labelFrom: "labelFrom", labelTo: "labelTo" }, host: { properties: { "class": "this.classes" } }, providers: [
             ClrPopoverToggleService,
             ClrPopoverEventsService,
             ClrPopoverPositionService,
@@ -215,7 +279,7 @@ export class ClrDaterangepickerContainerComponent extends ClrAbstractContainer {
             DaterangeService,
             OpenedDatepickersTrackerService,
             ControlIdService,
-        ], queries: [{ propertyName: "daterangepickerDirective", first: true, predicate: ClrDaterangepickerDirective, descendants: true }], viewQueries: [{ propertyName: "datepickerComponents", predicate: ClrDatepickerComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  class=\"clr-control-container\"\n  [class.clr-error]=\"this.isInvalid\"\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div class=\"clr-input-group\" [class.clr-focus]=\"this.focus\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        type=\"button\"\n        class=\"clr-input-group-icon-action\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        clrPopoverOpenCloseButton\n      >\n        <cds-icon status=\"info\" shape=\"calendar\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n  </div>\n  <ng-content select=\"clr-control-helper\" *ngIf=\"this.showHelper\"></ng-content>\n  <ng-content select=\"clr-control-error\" *ngIf=\"this.showInvalid\"></ng-content>\n  <ng-content select=\"clr-control-success\" *ngIf=\"this.showValid\"></ng-content>\n\n  <div\n    class=\"clr-daterangepicker-container-popup datepicker\"\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n      [attr.aria-label]=\"this.commonStrings.close\"\n    >\n      <cds-icon shape=\"window-close\" aria-hidden=\"true\" [attr.title]=\"this.commonStrings.close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form clrForm [clrLayout]=\"'vertical'\">\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelFrom\"\n          [value]=\"this.dateFrom\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateFromChange($event)\"\n        >\n        </clr-datepicker>\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelTo\"\n          [value]=\"this.dateTo\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateToChange($event)\"\n        >\n        </clr-datepicker>\n      </form>\n      <div class=\"clr-daterangepicker-container-popup-content-presets\" *ngIf=\"this.presets?.length > 0\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button class=\"btn btn-outline btn-sm btn-block\" type=\"button\" (click)=\"this.applyPreset(preset)\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".clr-input-wrapper>.clr-input-group{max-width:fit-content;padding-right:1.5rem}.clr-input-wrapper>.clr-input-group ::ng-deep>.clr-input{width:100%;padding:0 .3rem}.clr-daterangepicker-container-popup.datepicker{padding:0;width:auto;height:auto;display:block}.clr-daterangepicker-container-popup.datepicker .clr-smart-close-button{min-width:1.2rem;margin:0;padding:0;position:absolute;right:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content{padding:.6rem;display:flex;flex-direction:row}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-form ::ng-deep clr-datepicker:first-of-type ::ng-deep clr-date-container{margin-top:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets{margin-left:.6rem;padding:.3rem}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets .btn{margin-right:0}\n"], dependencies: [{ kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i7.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i7.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i7.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.CdsIconCustomTag, selector: "cds-icon" }, { kind: "directive", type: i1.ClrLabel, selector: "label", inputs: ["for"] }, { kind: "directive", type: i1.ClrForm, selector: "[clrForm]", inputs: ["clrLabelSize"] }, { kind: "directive", type: i1.ClrLayout, selector: "[clrForm][clrLayout]", inputs: ["clrLayout"] }, { kind: "directive", type: i1.ClrPopoverAnchor, selector: "[clrPopoverAnchor]" }, { kind: "directive", type: i1.ÇlrClrPopoverCloseButton, selector: "[clrPopoverCloseButton]", outputs: ["clrPopoverOnCloseChange"] }, { kind: "directive", type: i1.ÇlrClrPopoverOpenCloseButton, selector: "[clrPopoverOpenCloseButton]", outputs: ["clrPopoverOpenCloseChange"] }, { kind: "directive", type: i1.ClrPopoverContent, selector: "[clrPopoverContent]", inputs: ["clrPopoverContent", "clrPopoverContentAt", "clrPopoverContentOutsideClickToClose", "clrPopoverContentScrollToClose"] }, { kind: "component", type: i8.ClrDatepickerComponent, selector: "clr-datepicker", inputs: ["value", "label", "minDate", "maxDate"], outputs: ["valueChange"] }] }); }
+        ], queries: [{ propertyName: "daterangepickerDirective", first: true, predicate: ClrDaterangepickerDirective, descendants: true }], viewQueries: [{ propertyName: "datepickerComponents", predicate: ClrDatepickerComponent, descendants: true }], usesInheritance: true, ngImport: i0, template: "<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n  [class.clr-error]=\"this.isInvalid\"\n  class=\"clr-control-container\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div [class.clr-focus]=\"this.focus\" class=\"clr-input-group\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        class=\"clr-input-group-icon-action\"\n        clrPopoverOpenCloseButton\n        type=\"button\"\n      >\n        <cds-icon shape=\"calendar\" status=\"info\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n    ></cds-icon>\n  </div>\n  <ng-content *ngIf=\"this.showHelper\" select=\"clr-control-helper\"></ng-content>\n  <ng-content *ngIf=\"this.showInvalid\" select=\"clr-control-error\"></ng-content>\n  <ng-content *ngIf=\"this.showValid\" select=\"clr-control-success\"></ng-content>\n\n  <div\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n    class=\"clr-daterangepicker-container-popup datepicker\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close clr-smart-close-button btn-trash\"\n      type=\"button\"\n      (click)=\"daterangeService.updateSelectedDaterange(null)\"\n    >\n      <cds-icon shape=\"trash\"></cds-icon>\n    </button>\n    <button\n      [attr.aria-label]=\"this.commonStrings.close\"\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n    >\n      <cds-icon [attr.title]=\"this.commonStrings.close\" aria-hidden=\"true\" shape=\"window-close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form [clrLayout]=\"'vertical'\" clrForm>\n        <div class=\"datetime-container\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateFromChange($event)\"\n            [label]=\"this.labelFrom\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateFrom\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeFromChange($event)\"\n            [value]=\"this.timeFrom\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n        <div class=\"datetime-container datetime-container-to\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateToChange($event)\"\n            [label]=\"this.labelTo\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateTo\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeToChange($event)\"\n            [value]=\"this.timeTo\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n      </form>\n      <div *ngIf=\"this.presets?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button (click)=\"this.applyPreset(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n      <div *ngIf=\"this.presetsDateTime?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presetsDateTime\">\n          <button (click)=\"this.applyPresetTime(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".clr-input-wrapper>.clr-input-group{max-width:fit-content;padding-right:1.5rem}.clr-input-wrapper>.clr-input-group ::ng-deep>.clr-input{width:100%;padding:0 .3rem}.clr-daterangepicker-container-popup.datepicker{padding:0;width:auto;height:auto;display:block}.clr-daterangepicker-container-popup.datepicker .clr-smart-close-button{min-width:1.2rem;padding:0;position:absolute;right:0;margin:5px}.clr-daterangepicker-container-popup.datepicker .btn-trash{padding-right:25px;margin:5px}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content{padding:.6rem;display:flex;flex-direction:row}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-form ::ng-deep clr-datepicker:first-of-type ::ng-deep clr-date-container{margin-top:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets{margin-left:.6rem;padding:.3rem}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets .btn{margin-right:0}.datetime-container{display:flex;flex-direction:row;align-items:flex-start}.datetime-container-to{padding-top:1rem}.timepicker{padding-left:1rem}.timepicker clr-input-container{margin-top:.8rem}\n"], dependencies: [{ kind: "directive", type: i6.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i6.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i7.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i7.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i7.NgForm, selector: "form:not([ngNoForm]):not([formGroup]),ng-form,[ngForm]", inputs: ["ngFormOptions"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "directive", type: i1.CdsIconCustomTag, selector: "cds-icon" }, { kind: "directive", type: i1.ClrLabel, selector: "label", inputs: ["for"] }, { kind: "directive", type: i1.ClrForm, selector: "[clrForm]", inputs: ["clrLabelSize"] }, { kind: "directive", type: i1.ClrLayout, selector: "[clrForm][clrLayout]", inputs: ["clrLayout"] }, { kind: "directive", type: i1.ClrPopoverAnchor, selector: "[clrPopoverAnchor]" }, { kind: "directive", type: i1.ÇlrClrPopoverCloseButton, selector: "[clrPopoverCloseButton]", outputs: ["clrPopoverOnCloseChange"] }, { kind: "directive", type: i1.ÇlrClrPopoverOpenCloseButton, selector: "[clrPopoverOpenCloseButton]", outputs: ["clrPopoverOpenCloseChange"] }, { kind: "directive", type: i1.ClrPopoverContent, selector: "[clrPopoverContent]", inputs: ["clrPopoverContent", "clrPopoverContentAt", "clrPopoverContentOutsideClickToClose", "clrPopoverContentScrollToClose"] }, { kind: "component", type: i8.ClrDatepickerComponent, selector: "clr-datepicker", inputs: ["value", "label", "minDate", "maxDate", "timeSelection"], outputs: ["valueChange"] }, { kind: "component", type: i9.ClrTimepickerComponent, selector: "clr-timepicker", inputs: ["value", "activateSeconds"], outputs: ["valueChange"] }] }); }
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImport: i0, type: ClrDaterangepickerContainerComponent, decorators: [{
             type: Component,
@@ -227,11 +291,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImpor
                         DaterangeService,
                         OpenedDatepickersTrackerService,
                         ControlIdService,
-                    ], template: "<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  class=\"clr-control-container\"\n  [class.clr-error]=\"this.isInvalid\"\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div class=\"clr-input-group\" [class.clr-focus]=\"this.focus\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        type=\"button\"\n        class=\"clr-input-group-icon-action\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        clrPopoverOpenCloseButton\n      >\n        <cds-icon status=\"info\" shape=\"calendar\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n  </div>\n  <ng-content select=\"clr-control-helper\" *ngIf=\"this.showHelper\"></ng-content>\n  <ng-content select=\"clr-control-error\" *ngIf=\"this.showInvalid\"></ng-content>\n  <ng-content select=\"clr-control-success\" *ngIf=\"this.showValid\"></ng-content>\n\n  <div\n    class=\"clr-daterangepicker-container-popup datepicker\"\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n      [attr.aria-label]=\"this.commonStrings.close\"\n    >\n      <cds-icon shape=\"window-close\" aria-hidden=\"true\" [attr.title]=\"this.commonStrings.close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form clrForm [clrLayout]=\"'vertical'\">\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelFrom\"\n          [value]=\"this.dateFrom\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateFromChange($event)\"\n        >\n        </clr-datepicker>\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelTo\"\n          [value]=\"this.dateTo\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateToChange($event)\"\n        >\n        </clr-datepicker>\n      </form>\n      <div class=\"clr-daterangepicker-container-popup-content-presets\" *ngIf=\"this.presets?.length > 0\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button class=\"btn btn-outline btn-sm btn-block\" type=\"button\" (click)=\"this.applyPreset(preset)\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".clr-input-wrapper>.clr-input-group{max-width:fit-content;padding-right:1.5rem}.clr-input-wrapper>.clr-input-group ::ng-deep>.clr-input{width:100%;padding:0 .3rem}.clr-daterangepicker-container-popup.datepicker{padding:0;width:auto;height:auto;display:block}.clr-daterangepicker-container-popup.datepicker .clr-smart-close-button{min-width:1.2rem;margin:0;padding:0;position:absolute;right:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content{padding:.6rem;display:flex;flex-direction:row}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-form ::ng-deep clr-datepicker:first-of-type ::ng-deep clr-date-container{margin-top:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets{margin-left:.6rem;padding:.3rem}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets .btn{margin-right:0}\n"] }]
+                    ], template: "<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n  [class.clr-error]=\"this.isInvalid\"\n  class=\"clr-control-container\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div [class.clr-focus]=\"this.focus\" class=\"clr-input-group\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        class=\"clr-input-group-icon-action\"\n        clrPopoverOpenCloseButton\n        type=\"button\"\n      >\n        <cds-icon shape=\"calendar\" status=\"info\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n    ></cds-icon>\n  </div>\n  <ng-content *ngIf=\"this.showHelper\" select=\"clr-control-helper\"></ng-content>\n  <ng-content *ngIf=\"this.showInvalid\" select=\"clr-control-error\"></ng-content>\n  <ng-content *ngIf=\"this.showValid\" select=\"clr-control-success\"></ng-content>\n\n  <div\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n    class=\"clr-daterangepicker-container-popup datepicker\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close clr-smart-close-button btn-trash\"\n      type=\"button\"\n      (click)=\"daterangeService.updateSelectedDaterange(null)\"\n    >\n      <cds-icon shape=\"trash\"></cds-icon>\n    </button>\n    <button\n      [attr.aria-label]=\"this.commonStrings.close\"\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n    >\n      <cds-icon [attr.title]=\"this.commonStrings.close\" aria-hidden=\"true\" shape=\"window-close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form [clrLayout]=\"'vertical'\" clrForm>\n        <div class=\"datetime-container\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateFromChange($event)\"\n            [label]=\"this.labelFrom\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateFrom\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeFromChange($event)\"\n            [value]=\"this.timeFrom\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n        <div class=\"datetime-container datetime-container-to\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateToChange($event)\"\n            [label]=\"this.labelTo\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateTo\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeToChange($event)\"\n            [value]=\"this.timeTo\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n      </form>\n      <div *ngIf=\"this.presets?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button (click)=\"this.applyPreset(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n      <div *ngIf=\"this.presetsDateTime?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presetsDateTime\">\n          <button (click)=\"this.applyPresetTime(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n", styles: [".clr-input-wrapper>.clr-input-group{max-width:fit-content;padding-right:1.5rem}.clr-input-wrapper>.clr-input-group ::ng-deep>.clr-input{width:100%;padding:0 .3rem}.clr-daterangepicker-container-popup.datepicker{padding:0;width:auto;height:auto;display:block}.clr-daterangepicker-container-popup.datepicker .clr-smart-close-button{min-width:1.2rem;padding:0;position:absolute;right:0;margin:5px}.clr-daterangepicker-container-popup.datepicker .btn-trash{padding-right:25px;margin:5px}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content{padding:.6rem;display:flex;flex-direction:row}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-form ::ng-deep clr-datepicker:first-of-type ::ng-deep clr-date-container{margin-top:0}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets{margin-left:.6rem;padding:.3rem}.clr-daterangepicker-container-popup.datepicker .clr-daterangepicker-container-popup-content .clr-daterangepicker-container-popup-content-presets .btn{margin-right:0}.datetime-container{display:flex;flex-direction:row;align-items:flex-start}.datetime-container-to{padding-top:1rem}.timepicker{padding-left:1rem}.timepicker clr-input-container{margin-top:.8rem}\n"] }]
         }], ctorParameters: () => [{ type: i1.ClrPopoverEventsService }, { type: i1.ClrPopoverToggleService }, { type: i1.ClrCommonStringsService }, { type: i1.ClrLayout, decorators: [{
                     type: Optional
                 }] }, { type: i2.DaterangeControlStateService }, { type: i3.OpenedDatepickersTrackerService }, { type: i4.DaterangeService }, { type: i5.DaterangeParsingService }], propDecorators: { presets: [{
                 type: Input
+            }], presetsDateTime: [{
+                type: Input
+            }], timeSelection: [{
+                type: Input
+            }], activateSeconds: [{
+                type: Input
             }], clrPosition: [{
                 type: Input
             }], labelFrom: [{
@@ -248,4 +318,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.5", ngImpor
                 type: HostBinding,
                 args: ['class']
             }] } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker-container.component.js","sourceRoot":"","sources":["../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker-container/daterangepicker-container.component.ts","../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker-container/daterangepicker-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ContentChild,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Optional,\n  QueryList,\n  ViewChildren,\n} from '@angular/core';\nimport { ClarityIcons, calendarIcon, checkCircleIcon, exclamationCircleIcon, windowCloseIcon } from '@cds/core/icon';\nimport '@cds/core/icon/register.js';\nimport {\n  ClrCommonStrings,\n  ClrCommonStringsService,\n  ClrLayout,\n  ClrPopoverEventsService,\n  ClrPopoverPosition,\n  ClrPopoverPositionService,\n  ClrPopoverToggleService,\n} from '@clr/angular';\nimport { Subscription } from 'rxjs';\n\nimport { ControlIdService } from '../../../abstract-form-component/control-id.service';\nimport { TRANSLATIONS } from '../../daterange.constants';\nimport { DaterangePreset } from '../../interfaces/daterange-preset.interface';\nimport { NullableDaterange } from '../../interfaces/daterange.interface';\nimport { NullableDayModel } from '../../models/day.model';\nimport { PopoverPositions } from '../../models/popover-positions.model';\nimport { DaterangeControlStateService } from '../../providers/daterange-control-state.service';\nimport { DaterangeParsingService } from '../../providers/daterange-parsing.service';\nimport { DaterangeService } from '../../providers/daterange.service';\nimport { OpenedDatepickersTrackerService } from '../../providers/opened-datepickers-tracker.service';\nimport { ClrAbstractContainer } from '../abstract-container.component';\nimport { ClrDatepickerComponent } from '../datepicker/datepicker.component';\nimport { ClrDaterangepickerDirective } from '../daterangepicker/daterangepicker.directive';\n\nClarityIcons.addIcons(calendarIcon, exclamationCircleIcon, checkCircleIcon, windowCloseIcon);\n\n/**\n * Daterangepicker container.\n */\n@Component({\n  selector: 'clr-daterangepicker-container',\n  templateUrl: './daterangepicker-container.component.html',\n  styleUrls: ['./daterangepicker-container.component.scss'],\n  providers: [\n    ClrPopoverToggleService,\n    ClrPopoverEventsService,\n    ClrPopoverPositionService,\n    DaterangeControlStateService,\n    DaterangeService,\n    OpenedDatepickersTrackerService,\n    ControlIdService,\n  ],\n})\nexport class ClrDaterangepickerContainerComponent extends ClrAbstractContainer implements AfterViewInit, OnDestroy {\n  /**\n   * List of presets.\n   */\n  @Input()\n  public presets: Array<DaterangePreset> = [];\n\n  /**\n   * Set popover position.\n   */\n  @Input()\n  public set clrPosition(position: string) {\n    if (position && (PopoverPositions as Record<string, any>)[position]) {\n      this.popoverPosition = (PopoverPositions as Record<string, any>)[position];\n    }\n  }\n\n  /**\n   * Text for the 'from' label.\n   */\n  @Input()\n  public labelFrom = TRANSLATIONS.from;\n\n  /**\n   * Text for the 'to' label.\n   */\n  @Input()\n  public labelTo = TRANSLATIONS.to;\n\n  /** List of datepicker components children. */\n  @ViewChildren(ClrDatepickerComponent)\n  private datepickerComponents!: QueryList<ClrDatepickerComponent>;\n\n  /** Daterangepicker directive. */\n  @ContentChild(ClrDaterangepickerDirective)\n  private daterangepickerDirective!: ClrDaterangepickerDirective;\n\n  /** CSS classes. */\n  @HostBinding('class')\n  public classes = 'clr-date-container';\n\n  /**\n   * Popover open state.\n   */\n  protected open = false;\n\n  /**\n   * Popover position config.\n   */\n  protected popoverPosition: ClrPopoverPosition = PopoverPositions['bottom-left'];\n\n  /**\n   * Date from.\n   * @returns Date from.\n   */\n  protected get dateFrom() {\n    return this.daterangeService.selectedDaterange?.from;\n  }\n\n  /**\n   * Date to.\n   * @returns Date to.\n   */\n  protected get dateTo() {\n    return this.daterangeService.selectedDaterange?.to;\n  }\n\n  /**\n   * Minimum date that can be selected.\n   * @returns Minimum date that can be selected.\n   */\n  protected get minDate(): NullableDayModel {\n    return this.daterangeService.minDate;\n  }\n\n  /**\n   * Maximum date that can be selected.\n   * @returns Maximum date that can be selected.\n   */\n  protected get maxDate(): NullableDayModel {\n    return this.daterangeService.maxDate;\n  }\n\n  private _friendlyDaterange?: string;\n  /**\n   * Get friendly daterange text.\n   * @returns Friendly daterange text.\n   */\n  protected get friendlyDaterange(): string {\n    return this._friendlyDaterange || this.commonStrings.datepickerToggleChooseDateLabel;\n  }\n\n  /**\n   * List of common translation keys.\n   */\n  protected get commonStrings(): Readonly<ClrCommonStrings> {\n    return this.clrCommonStringsService.keys;\n  }\n\n  /** List of subscriptions to later destroy. */\n  private subscriptions: Array<Subscription> = [];\n\n  public constructor(\n    private readonly clrPopoverEventsService: ClrPopoverEventsService,\n    private readonly clrPopoverToggleService: ClrPopoverToggleService,\n    private readonly clrCommonStringsService: ClrCommonStringsService,\n    @Optional() protected readonly clrLayout: ClrLayout,\n    protected readonly daterangeControlStateService: DaterangeControlStateService,\n    private readonly openedDatepickersTrackerService: OpenedDatepickersTrackerService,\n    private readonly daterangeService: DaterangeService,\n    private readonly daterangeParsingService: DaterangeParsingService\n  ) {\n    super(clrLayout, daterangeControlStateService);\n  }\n\n  public ngAfterViewInit(): void {\n    if (this.daterangepickerDirective == null) {\n      throw new Error('`ClrDaterangepickerContainerComponent` requires an child `ClrDaterangepickerDirective`');\n    }\n\n    this.listenForDaterangeValueChanges();\n    this.listenForOpenedDatepickersTrackerChanges();\n    this.listenForPopoverToggleChanges();\n  }\n\n  public ngOnDestroy(): void {\n    this.subscriptions.forEach(subscription => subscription.unsubscribe());\n  }\n\n  /**\n   * Listen for daterange value changes.\n   */\n  private listenForDaterangeValueChanges(): void {\n    this.subscriptions.push(\n      this.daterangeService.valueChange.subscribe((daterange: NullableDaterange) => {\n        this._friendlyDaterange = this.daterangeParsingService.toLocaleString(\n          daterange,\n          this.daterangepickerDirective.separatorText\n        );\n      })\n    );\n  }\n\n  /**\n   * Listen for any opened datepickers tracker state changes.\n   */\n  private listenForOpenedDatepickersTrackerChanges(): void {\n    this.subscriptions.push(\n      this.openedDatepickersTrackerService.valueChange.subscribe(hasOpenDatePickers => {\n        // When choosing an date in the DatePicker calender, all popovers are closed. Even our own popover.\n        // Therefor we have to remove the ability to close our own popover.\n        // Simply changing the `outsideClickClose` property after initialization does nothing.\n        // We need to manually remove the listener, change the `outsideClickClose` property and re-attach the click listener.\n        // Steps to reproduce with 2 daterangepickers:\n        // 1. Click on second daterangepicker action icon to open the popover.\n        // 2. Click on one of the datepickers to open calender.\n        // 3. Close datepicker.\n        // 4. Click on first daterangepicker action icon. Error.\n        this.clrPopoverEventsService.removeClickListener();\n        this.clrPopoverEventsService.outsideClickClose = !hasOpenDatePickers;\n        // We need to wait before we attach the click listener.\n        requestAnimationFrame(() => {\n          this.clrPopoverEventsService.addClickListener();\n        });\n      })\n    );\n  }\n\n  /**\n   * Listen for popover toggle changes.\n   */\n  private listenForPopoverToggleChanges(): void {\n    this.subscriptions.push(\n      this.clrPopoverToggleService.openChange.subscribe(opened => {\n        // Focus first datepicker when popover opens.\n        // Focus back to input when popover is closed.\n        if (opened) {\n          // Wait for the datepicker components to be rendered.\n          requestAnimationFrame(() => {\n            this.datepickerComponents.first.focus();\n          });\n        } else {\n          this.daterangepickerDirective.focus();\n\n          // When closing popover modal and daterange is not valid, reset model.\n          if (!this.daterangeService.isValid()) {\n            this.daterangeService.updateSelectedDaterange(null);\n          }\n        }\n      })\n    );\n  }\n\n  /**\n   * Event triggered when date from changed.\n   * @param value - Date from.\n   */\n  protected onDateFromChange(value: NullableDayModel): void {\n    this.daterangeService.updateSelectedDaterange({\n      from: value,\n      to: this.dateTo,\n    });\n  }\n\n  /**\n   * Event triggered when date to changed.\n   * @param value - Date to.\n   */\n  protected onDateToChange(value: NullableDayModel): void {\n    this.daterangeService.updateSelectedDaterange({\n      from: this.dateFrom,\n      to: value,\n    });\n  }\n\n  /**\n   * Apply selected preset.\n   * @param preset - Selected preset.\n   */\n  protected applyPreset(preset: DaterangePreset): void {\n    const range = preset.range();\n    this.daterangeService.updateSelectedDaterange(range);\n\n    // Close popover here, because it's not possible to conditionally\n    // apply `clrPopoverCloseButton` directive on preset button.\n    if (this.daterangeService.isValid()) {\n      this.clrPopoverToggleService.open = false;\n    }\n  }\n}\n","<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  class=\"clr-control-container\"\n  [class.clr-error]=\"this.isInvalid\"\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div class=\"clr-input-group\" [class.clr-focus]=\"this.focus\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        type=\"button\"\n        class=\"clr-input-group-icon-action\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        clrPopoverOpenCloseButton\n      >\n        <cds-icon status=\"info\" shape=\"calendar\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n      aria-hidden=\"true\"\n    ></cds-icon>\n  </div>\n  <ng-content select=\"clr-control-helper\" *ngIf=\"this.showHelper\"></ng-content>\n  <ng-content select=\"clr-control-error\" *ngIf=\"this.showInvalid\"></ng-content>\n  <ng-content select=\"clr-control-success\" *ngIf=\"this.showValid\"></ng-content>\n\n  <div\n    class=\"clr-daterangepicker-container-popup datepicker\"\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n      [attr.aria-label]=\"this.commonStrings.close\"\n    >\n      <cds-icon shape=\"window-close\" aria-hidden=\"true\" [attr.title]=\"this.commonStrings.close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form clrForm [clrLayout]=\"'vertical'\">\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelFrom\"\n          [value]=\"this.dateFrom\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateFromChange($event)\"\n        >\n        </clr-datepicker>\n        <clr-datepicker\n          class=\"clr-datepicker\"\n          [label]=\"this.labelTo\"\n          [value]=\"this.dateTo\"\n          [minDate]=\"this.minDate\"\n          [maxDate]=\"this.maxDate\"\n          (valueChange)=\"this.onDateToChange($event)\"\n        >\n        </clr-datepicker>\n      </form>\n      <div class=\"clr-daterangepicker-container-popup-content-presets\" *ngIf=\"this.presets?.length > 0\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button class=\"btn btn-outline btn-sm btn-block\" type=\"button\" (click)=\"this.applyPreset(preset)\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"daterangepicker-container.component.js","sourceRoot":"","sources":["../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker-container/daterangepicker-container.component.ts","../../../../../../src/clr-addons/daterangepicker/directives/daterangepicker-container/daterangepicker-container.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  Component,\n  ContentChild,\n  HostBinding,\n  Input,\n  OnDestroy,\n  Optional,\n  QueryList,\n  ViewChildren,\n} from '@angular/core';\nimport {\n  calendarIcon,\n  checkCircleIcon,\n  ClarityIcons,\n  exclamationCircleIcon,\n  trashIcon,\n  windowCloseIcon,\n} from '@cds/core/icon';\nimport '@cds/core/icon/register.js';\nimport {\n  ClrCommonStrings,\n  ClrCommonStringsService,\n  ClrLayout,\n  ClrPopoverEventsService,\n  ClrPopoverPosition,\n  ClrPopoverPositionService,\n  ClrPopoverToggleService,\n} from '@clr/angular';\nimport { Subscription } from 'rxjs';\n\nimport { ControlIdService } from '../../../abstract-form-component/control-id.service';\nimport { TRANSLATIONS } from '../../daterange.constants';\nimport { DaterangePreset } from '../../interfaces/daterange-preset.interface';\nimport { NullableDaterange } from '../../interfaces/daterange.interface';\nimport { NullableDayModel } from '../../models/day.model';\nimport { PopoverPositions } from '../../models/popover-positions.model';\nimport { DaterangeControlStateService } from '../../providers/daterange-control-state.service';\nimport { DaterangeParsingService } from '../../providers/daterange-parsing.service';\nimport { DaterangeService } from '../../providers/daterange.service';\nimport { OpenedDatepickersTrackerService } from '../../providers/opened-datepickers-tracker.service';\nimport { ClrAbstractContainer } from '../abstract-container.component';\nimport { ClrDatepickerComponent } from '../datepicker/datepicker.component';\nimport { ClrDaterangepickerDirective } from '../daterangepicker/daterangepicker.directive';\nimport { DateTimerangePreset } from '../../interfaces/timerange-preset.interface';\nimport { NullableTimeModel } from '../../models/time.model';\nimport { NullableTimerange } from '../../interfaces/timerange.interface';\n\nClarityIcons.addIcons(calendarIcon, exclamationCircleIcon, checkCircleIcon, windowCloseIcon, trashIcon);\n\n/**\n * Daterangepicker container.\n */\n@Component({\n  selector: 'clr-daterangepicker-container',\n  templateUrl: './daterangepicker-container.component.html',\n  styleUrls: ['./daterangepicker-container.component.scss'],\n  providers: [\n    ClrPopoverToggleService,\n    ClrPopoverEventsService,\n    ClrPopoverPositionService,\n    DaterangeControlStateService,\n    DaterangeService,\n    OpenedDatepickersTrackerService,\n    ControlIdService,\n  ],\n})\nexport class ClrDaterangepickerContainerComponent extends ClrAbstractContainer implements AfterViewInit, OnDestroy {\n  /**\n   * List of presets.\n   */\n  @Input()\n  public presets: Array<DaterangePreset> = [];\n\n  /**\n   * List of time presets.\n   */\n  @Input()\n  public presetsDateTime: Array<DateTimerangePreset> = [];\n\n  @Input()\n  public timeSelection = false;\n\n  @Input()\n  public activateSeconds = false;\n\n  /**\n   * Set popover position.\n   */\n  @Input()\n  public set clrPosition(position: string) {\n    if (position && (PopoverPositions as Record<string, any>)[position]) {\n      this.popoverPosition = (PopoverPositions as Record<string, any>)[position];\n    }\n  }\n\n  /**\n   * Text for the 'from' label.\n   */\n  @Input()\n  public labelFrom = TRANSLATIONS.from;\n\n  /**\n   * Text for the 'to' label.\n   */\n  @Input()\n  public labelTo = TRANSLATIONS.to;\n\n  /** List of datepicker components children. */\n  @ViewChildren(ClrDatepickerComponent)\n  private datepickerComponents!: QueryList<ClrDatepickerComponent>;\n\n  /** Daterangepicker directive. */\n  @ContentChild(ClrDaterangepickerDirective)\n  private daterangepickerDirective!: ClrDaterangepickerDirective;\n\n  /** CSS classes. */\n  @HostBinding('class')\n  public classes = 'clr-date-container';\n\n  /**\n   * Popover open state.\n   */\n  protected open = false;\n\n  /**\n   * Popover position config.\n   */\n  protected popoverPosition: ClrPopoverPosition = PopoverPositions['bottom-left'];\n\n  /**\n   * Date from.\n   * @returns Date from.\n   */\n  protected get dateFrom() {\n    return this.daterangeService.selectedDaterange?.from;\n  }\n\n  protected get timeFrom() {\n    return this.daterangeService.selectedDaterange\n      ? (this.daterangeService.selectedDaterange as NullableTimerange).fromTime\n      : null;\n  }\n\n  /**\n   * Date to.\n   * @returns Date to.\n   */\n  protected get dateTo() {\n    return this.daterangeService.selectedDaterange?.to;\n  }\n\n  protected get timeTo() {\n    return this.daterangeService.selectedDaterange\n      ? (this.daterangeService.selectedDaterange as NullableTimerange).toTime\n      : null;\n  }\n\n  /**\n   * Minimum date that can be selected.\n   * @returns Minimum date that can be selected.\n   */\n  protected get minDate(): NullableDayModel {\n    return this.daterangeService.minDate;\n  }\n\n  /**\n   * Maximum date that can be selected.\n   * @returns Maximum date that can be selected.\n   */\n  protected get maxDate(): NullableDayModel {\n    return this.daterangeService.maxDate;\n  }\n\n  private _friendlyDaterange?: string;\n  /**\n   * Get friendly daterange text.\n   * @returns Friendly daterange text.\n   */\n  protected get friendlyDaterange(): string {\n    return this._friendlyDaterange || this.commonStrings.datepickerToggleChooseDateLabel;\n  }\n\n  /**\n   * List of common translation keys.\n   */\n  protected get commonStrings(): Readonly<ClrCommonStrings> {\n    return this.clrCommonStringsService.keys;\n  }\n\n  /** List of subscriptions to later destroy. */\n  private subscriptions: Array<Subscription> = [];\n\n  public constructor(\n    private readonly clrPopoverEventsService: ClrPopoverEventsService,\n    private readonly clrPopoverToggleService: ClrPopoverToggleService,\n    private readonly clrCommonStringsService: ClrCommonStringsService,\n    @Optional() protected readonly clrLayout: ClrLayout,\n    protected readonly daterangeControlStateService: DaterangeControlStateService,\n    private readonly openedDatepickersTrackerService: OpenedDatepickersTrackerService,\n    protected readonly daterangeService: DaterangeService,\n    private readonly daterangeParsingService: DaterangeParsingService\n  ) {\n    super(clrLayout, daterangeControlStateService);\n  }\n\n  public ngAfterViewInit(): void {\n    if (this.daterangepickerDirective == null) {\n      throw new Error('`ClrDaterangepickerContainerComponent` requires an child `ClrDaterangepickerDirective`');\n    }\n\n    this.daterangeService.timeActive = this.timeSelection;\n    this.daterangeService.timeSecondsActive = this.activateSeconds;\n    this.listenForDaterangeValueChanges();\n    this.listenForOpenedDatepickersTrackerChanges();\n    this.listenForPopoverToggleChanges();\n  }\n\n  public ngOnDestroy(): void {\n    this.subscriptions.forEach(subscription => subscription.unsubscribe());\n  }\n\n  /**\n   * Listen for daterange value changes.\n   */\n  private listenForDaterangeValueChanges(): void {\n    this.subscriptions.push(\n      this.daterangeService.valueChange.subscribe((daterange: NullableDaterange) => {\n        this._friendlyDaterange = this.daterangeParsingService.toLocaleString(\n          daterange,\n          this.daterangepickerDirective.separatorText\n        );\n      })\n    );\n  }\n\n  /**\n   * Listen for any opened datepickers tracker state changes.\n   */\n  private listenForOpenedDatepickersTrackerChanges(): void {\n    this.subscriptions.push(\n      this.openedDatepickersTrackerService.valueChange.subscribe(hasOpenDatePickers => {\n        // When choosing an date in the DatePicker calender, all popovers are closed. Even our own popover.\n        // Therefor we have to remove the ability to close our own popover.\n        // Simply changing the `outsideClickClose` property after initialization does nothing.\n        // We need to manually remove the listener, change the `outsideClickClose` property and re-attach the click listener.\n        // Steps to reproduce with 2 daterangepickers:\n        // 1. Click on second daterangepicker action icon to open the popover.\n        // 2. Click on one of the datepickers to open calender.\n        // 3. Close datepicker.\n        // 4. Click on first daterangepicker action icon. Error.\n        this.clrPopoverEventsService.removeClickListener();\n        this.clrPopoverEventsService.outsideClickClose = !hasOpenDatePickers;\n        // We need to wait before we attach the click listener.\n        requestAnimationFrame(() => {\n          this.clrPopoverEventsService.addClickListener();\n        });\n      })\n    );\n  }\n\n  /**\n   * Listen for popover toggle changes.\n   */\n  private listenForPopoverToggleChanges(): void {\n    this.subscriptions.push(\n      this.clrPopoverToggleService.openChange.subscribe(opened => {\n        // Focus first datepicker when popover opens.\n        // Focus back to input when popover is closed.\n        if (opened) {\n          // Wait for the datepicker components to be rendered.\n          requestAnimationFrame(() => {\n            this.datepickerComponents.first.focus();\n          });\n        } else {\n          this.daterangepickerDirective.focus();\n\n          // When closing popover modal and daterange is not valid, reset model.\n          if (!this.daterangeService.isValid()) {\n            this.daterangeService.updateSelectedDaterange(null);\n          }\n        }\n      })\n    );\n  }\n\n  /**\n   * Event triggered when date from changed.\n   * @param value - Date from.\n   */\n  protected onDateFromChange(value: NullableDayModel): void {\n    if (this.daterangeService.timeActive) {\n      this.daterangeService.updateSelectedDaterange({\n        from: value,\n        to: this.dateTo,\n        fromTime: this.timeFrom,\n        toTime: this.timeTo,\n      });\n    } else {\n      this.daterangeService.updateSelectedDaterange({\n        from: value,\n        to: this.dateTo,\n      });\n    }\n  }\n\n  /**\n   * Event triggered when date to changed.\n   * @param value - Date to.\n   */\n  protected onDateToChange(value: NullableDayModel): void {\n    if (this.daterangeService.timeActive) {\n      this.daterangeService.updateSelectedDaterange({\n        from: this.dateFrom,\n        to: value,\n        fromTime: this.timeFrom,\n        toTime: this.timeTo,\n      });\n    } else {\n      this.daterangeService.updateSelectedDaterange({\n        from: this.dateFrom,\n        to: value,\n      });\n    }\n  }\n\n  /**\n   * Apply selected preset.\n   * @param preset - Selected preset.\n   */\n  protected applyPreset(preset: DaterangePreset): void {\n    const range = preset.range();\n    this.daterangeService.updateSelectedDaterange(range);\n\n    // Close popover here, because it's not possible to conditionally\n    // apply `clrPopoverCloseButton` directive on preset button.\n    if (this.daterangeService.isValid()) {\n      this.clrPopoverToggleService.open = false;\n    }\n  }\n\n  applyPresetTime(preset: DateTimerangePreset) {\n    const range = preset.range();\n    this.daterangeService.updateSelectedDaterange(range);\n\n    // Close popover here, because it's not possible to conditionally\n    // apply `clrPopoverCloseButton` directive on preset button.\n    if (this.daterangeService.isValid()) {\n      this.clrPopoverToggleService.open = false;\n    }\n  }\n\n  protected onTimeFromChange(value: NullableTimeModel) {\n    this.daterangeService.updateSelectedDaterange({\n      from: this.dateFrom,\n      to: this.dateTo,\n      fromTime: value,\n      toTime: this.timeTo,\n    });\n  }\n\n  protected onTimeToChange(value: NullableTimeModel) {\n    this.daterangeService.updateSelectedDaterange({\n      from: this.dateFrom,\n      to: this.dateTo,\n      fromTime: this.timeFrom,\n      toTime: value,\n    });\n  }\n}\n","<ng-content select=\"label\"></ng-content>\n<label *ngIf=\"!this.labelComponent && this.addLayoutGrid\"></label>\n<div\n  [class.clr-col-12]=\"this.addLayoutGrid\"\n  [class.clr-col-md-10]=\"this.addLayoutGrid\"\n  [class.clr-error]=\"this.isInvalid\"\n  class=\"clr-control-container\"\n>\n  <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n    <div [class.clr-focus]=\"this.focus\" class=\"clr-input-group\">\n      <ng-content select=\"[clrDaterangepicker]\"></ng-content>\n      <button\n        [attr.aria-label]=\"this.friendlyDaterange\"\n        [disabled]=\"this.disabled\"\n        [title]=\"this.friendlyDaterange\"\n        class=\"clr-input-group-icon-action\"\n        clrPopoverOpenCloseButton\n        type=\"button\"\n      >\n        <cds-icon shape=\"calendar\" status=\"info\"></cds-icon>\n      </button>\n    </div>\n    <cds-icon\n      *ngIf=\"this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"exclamation-circle\"\n      status=\"danger\"\n    ></cds-icon>\n    <cds-icon\n      *ngIf=\"!this.isInvalid\"\n      aria-hidden=\"true\"\n      class=\"clr-validate-icon\"\n      shape=\"check-circle\"\n      status=\"success\"\n    ></cds-icon>\n  </div>\n  <ng-content *ngIf=\"this.showHelper\" select=\"clr-control-helper\"></ng-content>\n  <ng-content *ngIf=\"this.showInvalid\" select=\"clr-control-error\"></ng-content>\n  <ng-content *ngIf=\"this.showValid\" select=\"clr-control-success\"></ng-content>\n\n  <div\n    *clrPopoverContent=\"this.open; at: this.popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n    class=\"clr-daterangepicker-container-popup datepicker\"\n  >\n    <button\n      class=\"btn btn-sm btn-link close clr-smart-close-button btn-trash\"\n      type=\"button\"\n      (click)=\"daterangeService.updateSelectedDaterange(null)\"\n    >\n      <cds-icon shape=\"trash\"></cds-icon>\n    </button>\n    <button\n      [attr.aria-label]=\"this.commonStrings.close\"\n      class=\"btn btn-sm btn-link close\"\n      clrPopoverCloseButton\n      type=\"button\"\n    >\n      <cds-icon [attr.title]=\"this.commonStrings.close\" aria-hidden=\"true\" shape=\"window-close\"></cds-icon>\n      <span class=\"clr-sr-only\">{{ this.commonStrings.close }}</span>\n    </button>\n    <div class=\"clr-daterangepicker-container-popup-content\">\n      <form [clrLayout]=\"'vertical'\" clrForm>\n        <div class=\"datetime-container\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateFromChange($event)\"\n            [label]=\"this.labelFrom\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateFrom\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeFromChange($event)\"\n            [value]=\"this.timeFrom\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n        <div class=\"datetime-container datetime-container-to\">\n          <clr-datepicker\n            (valueChange)=\"this.onDateToChange($event)\"\n            [label]=\"this.labelTo\"\n            [maxDate]=\"this.maxDate\"\n            [minDate]=\"this.minDate\"\n            [value]=\"this.dateTo\"\n            class=\"clr-datepicker\"\n          >\n          </clr-datepicker>\n          <clr-timepicker\n            *ngIf=\"timeSelection\"\n            class=\"timepicker\"\n            (valueChange)=\"this.onTimeToChange($event)\"\n            [value]=\"this.timeTo\"\n            [activateSeconds]=\"activateSeconds\"\n          >\n          </clr-timepicker>\n        </div>\n      </form>\n      <div *ngIf=\"this.presets?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presets\">\n          <button (click)=\"this.applyPreset(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n      <div *ngIf=\"this.presetsDateTime?.length > 0\" class=\"clr-daterangepicker-container-popup-content-presets\">\n        <ng-container *ngFor=\"let preset of this.presetsDateTime\">\n          <button (click)=\"this.applyPresetTime(preset)\" class=\"btn btn-outline btn-sm btn-block\" type=\"button\">\n            {{ preset.text }}\n          </button>\n        </ng-container>\n      </div>\n    </div>\n  </div>\n</div>\n"]}