@clr/angular 12.0.8 → 13.0.0-next.0

package/esm2020/forms/datepicker/date-container.mjs

@@ -0,0 +1,249 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Component, Optional, ViewChild, Input } from '@angular/core';
+import { ClrPopoverToggleService } from '../../utils/popover/providers/popover-toggle.service';
+import { ControlClassService } from '../common/providers/control-class.service';
+import { ControlIdService } from '../common/providers/control-id.service';
+import { FocusService } from '../common/providers/focus.service';
+import { NgControlService } from '../common/providers/ng-control.service';
+import { DateFormControlService } from './providers/date-form-control.service';
+import { DateIOService } from './providers/date-io.service';
+import { DateNavigationService } from './providers/date-navigation.service';
+import { DatepickerEnabledService } from './providers/datepicker-enabled.service';
+import { LocaleHelperService } from './providers/locale-helper.service';
+import { ClrPopoverPositions } from '../../utils/popover/enums/positions.enum';
+import { ClrPopoverEventsService } from '../../utils/popover/providers/popover-events.service';
+import { ClrPopoverPositionService } from '../../utils/popover/providers/popover-position.service';
+import { ViewManagerService } from './providers/view-manager.service';
+import { IfControlStateService } from '../common/if-control-state/if-control-state.service';
+import { ClrAbstractContainer } from '../common/abstract-container';
+import * as i0 from "@angular/core";
+import * as i1 from "../../utils/popover/providers/popover-toggle.service";
+import * as i2 from "./providers/date-navigation.service";
+import * as i3 from "./providers/datepicker-enabled.service";
+import * as i4 from "./providers/date-form-control.service";
+import * as i5 from "../../utils/i18n/common-strings.service";
+import * as i6 from "../common/providers/focus.service";
+import * as i7 from "./providers/view-manager.service";
+import * as i8 from "../common/providers/control-class.service";
+import * as i9 from "../common/providers/layout.service";
+import * as i10 from "../common/providers/ng-control.service";
+import * as i11 from "../common/if-control-state/if-control-state.service";
+import * as i12 from "./datepicker-view-manager";
+import * as i13 from "@angular/common";
+import * as i14 from "../common/label";
+import * as i15 from "../../utils/popover/popover-anchor";
+import * as i16 from "../../utils/popover/popover-open-close-button";
+import * as i17 from "../../icon/icon";
+import * as i18 from "../../utils/popover/popover-content";
+import * as i19 from "../../utils/focus-trap/focus-trap.directive";
+export class ClrDateContainer extends ClrAbstractContainer {
+    constructor(toggleService, dateNavigationService, datepickerEnabledService, dateFormControlService, commonStrings, focusService, viewManagerService, controlClassService, layoutService, ngControlService, ifControlStateService) {
+        super(ifControlStateService, layoutService, controlClassService, ngControlService);
+        this.toggleService = toggleService;
+        this.dateNavigationService = dateNavigationService;
+        this.datepickerEnabledService = datepickerEnabledService;
+        this.dateFormControlService = dateFormControlService;
+        this.commonStrings = commonStrings;
+        this.focusService = focusService;
+        this.viewManagerService = viewManagerService;
+        this.controlClassService = controlClassService;
+        this.layoutService = layoutService;
+        this.ngControlService = ngControlService;
+        this.ifControlStateService = ifControlStateService;
+        this.focus = false;
+        this.subscriptions.push(this.focusService.focusChange.subscribe(state => {
+            this.focus = state;
+        }));
+        this.subscriptions.push(this.toggleService.openChange.subscribe(() => {
+            this.dateFormControlService.markAsTouched();
+        }));
+    }
+    set clrPosition(position) {
+        if (position && ClrPopoverPositions[position]) {
+            this.viewManagerService.position = ClrPopoverPositions[position];
+        }
+    }
+    get popoverPosition() {
+        return this.viewManagerService.position;
+    }
+    get open() {
+        return this.toggleService.open;
+    }
+    set actionButton(button) {
+        this.toggleButton = button;
+    }
+    ngAfterViewInit() {
+        this.subscriptions.push(this.toggleService.openChange.subscribe(open => {
+            if (open) {
+                this.initializeCalendar();
+            }
+            else {
+                this.toggleButton.nativeElement.focus();
+            }
+        }));
+    }
+    /**
+     * Returns if the Datepicker is enabled or not. If disabled, hides the datepicker trigger.
+     */
+    get isEnabled() {
+        return this.datepickerEnabledService.isEnabled;
+    }
+    /**
+     * Return if Datepicker is diabled or not as Form Control
+     */
+    get isInputDateDisabled() {
+        /* clrForm wrapper or without clrForm */
+        return ((this.control && this.control.disabled) || (this.dateFormControlService && this.dateFormControlService.disabled));
+    }
+    /**
+     * Processes the user input and Initializes the Calendar everytime the datepicker popover is open.
+     */
+    initializeCalendar() {
+        this.dateNavigationService.initializeCalendar();
+    }
+}
+ClrDateContainer.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDateContainer, deps: [{ token: i1.ClrPopoverToggleService }, { token: i2.DateNavigationService }, { token: i3.DatepickerEnabledService }, { token: i4.DateFormControlService }, { token: i5.ClrCommonStringsService }, { token: i6.FocusService }, { token: i7.ViewManagerService }, { token: i8.ControlClassService }, { token: i9.LayoutService, optional: true }, { token: i10.NgControlService }, { token: i11.IfControlStateService }], target: i0.ɵɵFactoryTarget.Component });
+ClrDateContainer.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrDateContainer, selector: "clr-date-container", inputs: { clrPosition: "clrPosition" }, host: { properties: { "class.clr-date-container": "true", "class.clr-form-control-disabled": "isInputDateDisabled", "class.clr-form-control": "true", "class.clr-row": "addGrid()" } }, providers: [
+        ControlIdService,
+        ClrPopoverToggleService,
+        ClrPopoverEventsService,
+        ClrPopoverPositionService,
+        LocaleHelperService,
+        ControlClassService,
+        FocusService,
+        NgControlService,
+        DateIOService,
+        DateNavigationService,
+        DatepickerEnabledService,
+        DateFormControlService,
+        ViewManagerService,
+        IfControlStateService,
+    ], viewQueries: [{ propertyName: "actionButton", first: true, predicate: ["actionButton"], descendants: true }], usesInheritance: true, ngImport: i0, template: `
+    <ng-content select="label"></ng-content>
+    <label *ngIf="!label && addGrid()"></label>
+    <div class="clr-control-container" [ngClass]="controlClass()">
+      <div class="clr-input-wrapper" clrPopoverAnchor>
+        <div class="clr-input-group" [class.clr-focus]="focus">
+          <ng-content select="[clrDate]"></ng-content>
+          <button
+            #actionButton
+            type="button"
+            clrPopoverOpenCloseButton
+            class="clr-input-group-icon-action"
+            [attr.title]="commonStrings.keys.datepickerToggle"
+            [attr.aria-label]="commonStrings.keys.datepickerToggle"
+            [disabled]="isInputDateDisabled"
+            *ngIf="isEnabled"
+          >
+            <cds-icon status="info" shape="calendar"></cds-icon>
+          </button>
+          <clr-datepicker-view-manager
+            *clrPopoverContent="open; at: popoverPosition; outsideClickToClose: true; scrollToClose: true"
+            clrFocusTrap
+          ></clr-datepicker-view-manager>
+        </div>
+        <cds-icon
+          *ngIf="showInvalid"
+          class="clr-validate-icon"
+          status="danger"
+          shape="exclamation-circle"
+          aria-hidden="true"
+        ></cds-icon>
+        <cds-icon
+          *ngIf="showValid"
+          class="clr-validate-icon"
+          shape="check-circle"
+          status="success"
+          aria-hidden="true"
+        ></cds-icon>
+      </div>
+      <ng-content select="clr-control-helper" *ngIf="showHelper"></ng-content>
+      <ng-content select="clr-control-error" *ngIf="showInvalid"></ng-content>
+      <ng-content select="clr-control-success" *ngIf="showValid"></ng-content>
+    </div>
+  `, isInline: true, components: [{ type: i12.ClrDatepickerViewManager, selector: "clr-datepicker-view-manager" }], directives: [{ type: i13.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i14.ClrLabel, selector: "label", inputs: ["for"] }, { type: i13.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i15.ClrPopoverAnchor, selector: "[clrPopoverAnchor]" }, { type: i16.ClrPopoverOpenCloseButton, selector: "[clrPopoverOpenCloseButton]", outputs: ["clrPopoverOpenCloseChange"] }, { type: i17.CdsIconCustomTag, selector: "cds-icon" }, { type: i18.ClrPopoverContent, selector: "[clrPopoverContent]", inputs: ["clrPopoverContent", "clrPopoverContentAt", "clrPopoverContentOutsideClickToClose", "clrPopoverContentScrollToClose"] }, { type: i19.FocusTrapDirective, selector: "[clrFocusTrap]", inputs: ["clrFocusTrap"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDateContainer, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'clr-date-container',
+                    template: `
+    <ng-content select="label"></ng-content>
+    <label *ngIf="!label && addGrid()"></label>
+    <div class="clr-control-container" [ngClass]="controlClass()">
+      <div class="clr-input-wrapper" clrPopoverAnchor>
+        <div class="clr-input-group" [class.clr-focus]="focus">
+          <ng-content select="[clrDate]"></ng-content>
+          <button
+            #actionButton
+            type="button"
+            clrPopoverOpenCloseButton
+            class="clr-input-group-icon-action"
+            [attr.title]="commonStrings.keys.datepickerToggle"
+            [attr.aria-label]="commonStrings.keys.datepickerToggle"
+            [disabled]="isInputDateDisabled"
+            *ngIf="isEnabled"
+          >
+            <cds-icon status="info" shape="calendar"></cds-icon>
+          </button>
+          <clr-datepicker-view-manager
+            *clrPopoverContent="open; at: popoverPosition; outsideClickToClose: true; scrollToClose: true"
+            clrFocusTrap
+          ></clr-datepicker-view-manager>
+        </div>
+        <cds-icon
+          *ngIf="showInvalid"
+          class="clr-validate-icon"
+          status="danger"
+          shape="exclamation-circle"
+          aria-hidden="true"
+        ></cds-icon>
+        <cds-icon
+          *ngIf="showValid"
+          class="clr-validate-icon"
+          shape="check-circle"
+          status="success"
+          aria-hidden="true"
+        ></cds-icon>
+      </div>
+      <ng-content select="clr-control-helper" *ngIf="showHelper"></ng-content>
+      <ng-content select="clr-control-error" *ngIf="showInvalid"></ng-content>
+      <ng-content select="clr-control-success" *ngIf="showValid"></ng-content>
+    </div>
+  `,
+                    providers: [
+                        ControlIdService,
+                        ClrPopoverToggleService,
+                        ClrPopoverEventsService,
+                        ClrPopoverPositionService,
+                        LocaleHelperService,
+                        ControlClassService,
+                        FocusService,
+                        NgControlService,
+                        DateIOService,
+                        DateNavigationService,
+                        DatepickerEnabledService,
+                        DateFormControlService,
+                        ViewManagerService,
+                        IfControlStateService,
+                    ],
+                    host: {
+                        '[class.clr-date-container]': 'true',
+                        '[class.clr-form-control-disabled]': 'isInputDateDisabled',
+                        '[class.clr-form-control]': 'true',
+                        '[class.clr-row]': 'addGrid()',
+                    },
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ClrPopoverToggleService }, { type: i2.DateNavigationService }, { type: i3.DatepickerEnabledService }, { type: i4.DateFormControlService }, { type: i5.ClrCommonStringsService }, { type: i6.FocusService }, { type: i7.ViewManagerService }, { type: i8.ControlClassService }, { type: i9.LayoutService, decorators: [{
+                    type: Optional
+                }] }, { type: i10.NgControlService }, { type: i11.IfControlStateService }]; }, propDecorators: { clrPosition: [{
+                type: Input,
+                args: ['clrPosition']
+            }], actionButton: [{
+                type: ViewChild,
+                args: ['actionButton']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-container.js","sourceRoot":"","sources":["../../../../../projects/angular/src/forms/datepicker/date-container.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\nimport { Component, Optional, ViewChild, ElementRef, Input, AfterViewInit } from '@angular/core';\n\nimport { ClrPopoverToggleService } from '../../utils/popover/providers/popover-toggle.service';\nimport { ControlClassService } from '../common/providers/control-class.service';\nimport { ControlIdService } from '../common/providers/control-id.service';\nimport { FocusService } from '../common/providers/focus.service';\nimport { LayoutService } from '../common/providers/layout.service';\nimport { NgControlService } from '../common/providers/ng-control.service';\n\nimport { DateFormControlService } from './providers/date-form-control.service';\nimport { DateIOService } from './providers/date-io.service';\nimport { DateNavigationService } from './providers/date-navigation.service';\nimport { DatepickerEnabledService } from './providers/datepicker-enabled.service';\nimport { LocaleHelperService } from './providers/locale-helper.service';\nimport { ClrCommonStringsService } from '../../utils/i18n/common-strings.service';\nimport { ClrPopoverPositions } from '../../utils/popover/enums/positions.enum';\nimport { ClrPopoverPosition } from '../../utils/popover/interfaces/popover-position.interface';\nimport { ClrPopoverEventsService } from '../../utils/popover/providers/popover-events.service';\nimport { ClrPopoverPositionService } from '../../utils/popover/providers/popover-position.service';\nimport { ViewManagerService } from './providers/view-manager.service';\nimport { IfControlStateService } from '../common/if-control-state/if-control-state.service';\nimport { ClrAbstractContainer } from '../common/abstract-container';\n\n@Component({\n  selector: 'clr-date-container',\n  template: `\n    <ng-content select=\"label\"></ng-content>\n    <label *ngIf=\"!label && addGrid()\"></label>\n    <div class=\"clr-control-container\" [ngClass]=\"controlClass()\">\n      <div class=\"clr-input-wrapper\" clrPopoverAnchor>\n        <div class=\"clr-input-group\" [class.clr-focus]=\"focus\">\n          <ng-content select=\"[clrDate]\"></ng-content>\n          <button\n            #actionButton\n            type=\"button\"\n            clrPopoverOpenCloseButton\n            class=\"clr-input-group-icon-action\"\n            [attr.title]=\"commonStrings.keys.datepickerToggle\"\n            [attr.aria-label]=\"commonStrings.keys.datepickerToggle\"\n            [disabled]=\"isInputDateDisabled\"\n            *ngIf=\"isEnabled\"\n          >\n            <cds-icon status=\"info\" shape=\"calendar\"></cds-icon>\n          </button>\n          <clr-datepicker-view-manager\n            *clrPopoverContent=\"open; at: popoverPosition; outsideClickToClose: true; scrollToClose: true\"\n            clrFocusTrap\n          ></clr-datepicker-view-manager>\n        </div>\n        <cds-icon\n          *ngIf=\"showInvalid\"\n          class=\"clr-validate-icon\"\n          status=\"danger\"\n          shape=\"exclamation-circle\"\n          aria-hidden=\"true\"\n        ></cds-icon>\n        <cds-icon\n          *ngIf=\"showValid\"\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=\"showHelper\"></ng-content>\n      <ng-content select=\"clr-control-error\" *ngIf=\"showInvalid\"></ng-content>\n      <ng-content select=\"clr-control-success\" *ngIf=\"showValid\"></ng-content>\n    </div>\n  `,\n  providers: [\n    ControlIdService,\n    ClrPopoverToggleService,\n    ClrPopoverEventsService,\n    ClrPopoverPositionService,\n    LocaleHelperService,\n    ControlClassService,\n    FocusService,\n    NgControlService,\n    DateIOService,\n    DateNavigationService,\n    DatepickerEnabledService,\n    DateFormControlService,\n    ViewManagerService,\n    IfControlStateService,\n  ],\n  host: {\n    '[class.clr-date-container]': 'true',\n    '[class.clr-form-control-disabled]': 'isInputDateDisabled',\n    '[class.clr-form-control]': 'true',\n    '[class.clr-row]': 'addGrid()',\n  },\n})\nexport class ClrDateContainer extends ClrAbstractContainer implements AfterViewInit {\n  focus = false;\n\n  @Input('clrPosition')\n  set clrPosition(position: string) {\n    if (position && (ClrPopoverPositions as Record<string, any>)[position]) {\n      this.viewManagerService.position = (ClrPopoverPositions as Record<string, any>)[position];\n    }\n  }\n  get popoverPosition(): ClrPopoverPosition {\n    return this.viewManagerService.position;\n  }\n\n  public get open() {\n    return this.toggleService.open;\n  }\n\n  private toggleButton: ElementRef;\n  @ViewChild('actionButton')\n  set actionButton(button: ElementRef) {\n    this.toggleButton = button;\n  }\n\n  constructor(\n    private toggleService: ClrPopoverToggleService,\n    private dateNavigationService: DateNavigationService,\n    private datepickerEnabledService: DatepickerEnabledService,\n    private dateFormControlService: DateFormControlService,\n    public commonStrings: ClrCommonStringsService,\n    private focusService: FocusService,\n    private viewManagerService: ViewManagerService,\n    protected controlClassService: ControlClassService,\n    @Optional() protected layoutService: LayoutService,\n    protected ngControlService: NgControlService,\n    protected ifControlStateService: IfControlStateService\n  ) {\n    super(ifControlStateService, layoutService, controlClassService, ngControlService);\n\n    this.subscriptions.push(\n      this.focusService.focusChange.subscribe(state => {\n        this.focus = state;\n      })\n    );\n\n    this.subscriptions.push(\n      this.toggleService.openChange.subscribe(() => {\n        this.dateFormControlService.markAsTouched();\n      })\n    );\n  }\n\n  ngAfterViewInit(): void {\n    this.subscriptions.push(\n      this.toggleService.openChange.subscribe(open => {\n        if (open) {\n          this.initializeCalendar();\n        } else {\n          this.toggleButton.nativeElement.focus();\n        }\n      })\n    );\n  }\n\n  /**\n   * Returns if the Datepicker is enabled or not. If disabled, hides the datepicker trigger.\n   */\n  get isEnabled(): boolean {\n    return this.datepickerEnabledService.isEnabled;\n  }\n\n  /**\n   * Return if Datepicker is diabled or not as Form Control\n   */\n  get isInputDateDisabled(): boolean {\n    /* clrForm wrapper or without clrForm */\n    return (\n      (this.control && this.control.disabled) || (this.dateFormControlService && this.dateFormControlService.disabled)\n    );\n  }\n\n  /**\n   * Processes the user input and Initializes the Calendar everytime the datepicker popover is open.\n   */\n  private initializeCalendar(): void {\n    this.dateNavigationService.initializeCalendar();\n  }\n}\n"]}

package/esm2020/forms/datepicker/date-input.mjs

@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { isPlatformBrowser } from '@angular/common';
+import { Directive, EventEmitter, HostBinding, HostListener, Inject, Input, Optional, Output, PLATFORM_ID, Self, } from '@angular/core';
+import { filter, switchMap } from 'rxjs/operators';
+import { of } from 'rxjs';
+import { WrappedFormControl } from '../common/wrapped-control';
+import { ClrDateContainer } from './date-container';
+import { DayModel } from './model/day.model';
+import { DateFormControlService } from './providers/date-form-control.service';
+import { DateIOService } from './providers/date-io.service';
+import { DateNavigationService } from './providers/date-navigation.service';
+import { DatepickerEnabledService } from './providers/datepicker-enabled.service';
+import { DatepickerFocusService } from './providers/datepicker-focus.service';
+import { datesAreEqual } from './utils/date-utils';
+import { isBooleanAttributeSet } from '../../utils/component/is-boolean-attribute-set';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "./date-container";
+import * as i3 from "./providers/date-io.service";
+import * as i4 from "./providers/date-navigation.service";
+import * as i5 from "./providers/datepicker-enabled.service";
+import * as i6 from "./providers/date-form-control.service";
+import * as i7 from "../common/providers/focus.service";
+import * as i8 from "./providers/datepicker-focus.service";
+// There are four ways the datepicker value is set
+// 1. Value set by user typing into text input as a string ex: '01/28/2015'
+// 2. Value set explicitly by Angular Forms APIs as a string ex: '01/28/2015'
+// 3. Value set by user via datepicker UI as a Date Object
+// 4. Value set via `clrDate` input as a Date Object
+export class ClrDateInput extends WrappedFormControl {
+    constructor(viewContainerRef, injector, el, renderer, control, container, dateIOService, dateNavigationService, datepickerEnabledService, dateFormControlService, platformId, focusService, datepickerFocusService) {
+        super(viewContainerRef, ClrDateContainer, injector, control, renderer, el);
+        this.el = el;
+        this.renderer = renderer;
+        this.control = control;
+        this.container = container;
+        this.dateIOService = dateIOService;
+        this.dateNavigationService = dateNavigationService;
+        this.datepickerEnabledService = datepickerEnabledService;
+        this.dateFormControlService = dateFormControlService;
+        this.platformId = platformId;
+        this.focusService = focusService;
+        this.datepickerFocusService = datepickerFocusService;
+        this.dateChange = new EventEmitter(false);
+        this.index = 1;
+    }
+    set date(date) {
+        if (this.previousDateChange !== date) {
+            this.updateDate(this.getValidDateValueFromDate(date));
+        }
+        if (!this.initialClrDateInputValue) {
+            this.initialClrDateInputValue = date;
+        }
+    }
+    set min(dateString) {
+        this.dateIOService.setMinDate(dateString);
+    }
+    set max(dateString) {
+        this.dateIOService.setMaxDate(dateString);
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.populateServicesFromContainerComponent();
+        this.subscriptions.push(this.listenForUserSelectedDayChanges(), this.listenForControlValueChanges(), this.listenForTouchChanges(), this.listenForDirtyChanges(), this.listenForInputRefocus());
+    }
+    ngAfterViewInit() {
+        // I don't know why I have to do this but after using the new HostWrapping Module I have to delay the processing
+        // of the initial Input set by the user to here. If I do not 2 issues occur:
+        // 1. The Input setter is called before ngOnInit. ngOnInit initializes the services without which the setter fails.
+        // 2. The Renderer doesn't work before ngAfterViewInit (It used to before the new HostWrapping Module for some reason).
+        // I need the renderer to set the value property on the input to make sure that if the user has supplied a Date
+        // input object, we reflect it with the right date on the input field using the IO service. I am not sure if
+        // these are major issues or not but just noting them down here.
+        this.processInitialInputs();
+    }
+    setFocusStates() {
+        this.setFocus(true);
+    }
+    triggerValidation() {
+        super.triggerValidation();
+        this.setFocus(false);
+    }
+    get placeholderText() {
+        return this.placeholder ? this.placeholder : this.dateIOService.placeholderText;
+    }
+    get inputType() {
+        return isPlatformBrowser(this.platformId) && this.usingNativeDatepicker() ? 'date' : 'text';
+    }
+    onValueChange(target) {
+        const validDateValue = this.dateIOService.getDateValueFromDateString(target.value);
+        if (this.usingClarityDatepicker() && validDateValue) {
+            this.updateDate(validDateValue, true);
+        }
+        else if (this.usingNativeDatepicker()) {
+            const [year, month, day] = target.value.split('-');
+            this.updateDate(new Date(+year, +month - 1, +day), true);
+        }
+        else {
+            this.emitDateOutput(null);
+        }
+    }
+    set disabled(value) {
+        if (this.dateFormControlService) {
+            this.dateFormControlService.setDisabled(isBooleanAttributeSet(value));
+        }
+    }
+    get disabled() {
+        if (this.dateFormControlService) {
+            return this.dateFormControlService.disabled;
+        }
+        return null;
+    }
+    usingClarityDatepicker() {
+        return this.datepickerEnabledService.isEnabled;
+    }
+    usingNativeDatepicker() {
+        return !this.datepickerEnabledService.isEnabled;
+    }
+    setFocus(focus) {
+        if (this.focusService) {
+            this.focusService.focused = focus;
+        }
+    }
+    populateServicesFromContainerComponent() {
+        if (!this.container) {
+            this.dateIOService = this.getProviderFromContainer(DateIOService);
+            this.dateNavigationService = this.getProviderFromContainer(DateNavigationService);
+            this.datepickerEnabledService = this.getProviderFromContainer(DatepickerEnabledService);
+            this.dateFormControlService = this.getProviderFromContainer(DateFormControlService);
+        }
+    }
+    processInitialInputs() {
+        if (this.datepickerHasFormControl()) {
+            this.updateDate(this.dateIOService.getDateValueFromDateString(this.control.value));
+        }
+        else {
+            this.updateDate(this.initialClrDateInputValue);
+        }
+    }
+    updateDate(value, setByUserInteraction = false) {
+        const date = this.getValidDateValueFromDate(value);
+        if (setByUserInteraction) {
+            this.emitDateOutput(date);
+        }
+        else {
+            this.previousDateChange = date;
+        }
+        if (this.dateNavigationService) {
+            this.dateNavigationService.selectedDay = date
+                ? new DayModel(date.getFullYear(), date.getMonth(), date.getDate())
+                : null;
+        }
+        this.updateInput(date);
+    }
+    updateInput(date) {
+        if (date) {
+            const dateString = this.dateIOService.toLocaleDisplayFormatString(date);
+            if (this.usingNativeDatepicker()) {
+                // valueAsDate expects UTC, date from input is time-zoned
+                date.setMinutes(date.getMinutes() - date.getTimezoneOffset());
+                this.renderer.setProperty(this.el.nativeElement, 'valueAsDate', date);
+            }
+            else if (this.datepickerHasFormControl() && dateString !== this.control.value) {
+                this.control.control.setValue(dateString);
+            }
+            else {
+                this.renderer.setProperty(this.el.nativeElement, 'value', dateString);
+            }
+        }
+        else {
+            this.renderer.setProperty(this.el.nativeElement, 'value', '');
+        }
+    }
+    getValidDateValueFromDate(date) {
+        if (this.dateIOService) {
+            const dateString = this.dateIOService.toLocaleDisplayFormatString(date);
+            return this.dateIOService.getDateValueFromDateString(dateString);
+        }
+        else {
+            return null;
+        }
+    }
+    emitDateOutput(date) {
+        if (!datesAreEqual(date, this.previousDateChange)) {
+            this.dateChange.emit(date);
+            this.previousDateChange = date;
+        }
+        else if (!date && this.previousDateChange) {
+            this.dateChange.emit(null);
+            this.previousDateChange = null;
+        }
+    }
+    datepickerHasFormControl() {
+        return !!this.control;
+    }
+    listenForControlValueChanges() {
+        return of(this.datepickerHasFormControl())
+            .pipe(filter(hasControl => hasControl), switchMap(() => this.control.valueChanges), 
+        // only update date value if not being set by user
+        filter(() => !this.datepickerFocusService.elementIsFocused(this.el.nativeElement)))
+            .subscribe((value) => this.updateDate(this.dateIOService.getDateValueFromDateString(value)));
+    }
+    listenForUserSelectedDayChanges() {
+        return this.dateNavigationService.selectedDayChange.subscribe(dayModel => this.updateDate(dayModel.toDate(), true));
+    }
+    listenForTouchChanges() {
+        return this.dateFormControlService.touchedChange
+            .pipe(filter(() => this.datepickerHasFormControl()))
+            .subscribe(() => this.control.control.markAsTouched());
+    }
+    listenForDirtyChanges() {
+        return this.dateFormControlService.dirtyChange
+            .pipe(filter(() => this.datepickerHasFormControl()))
+            .subscribe(() => this.control.control.markAsDirty());
+    }
+    listenForInputRefocus() {
+        return this.dateNavigationService.selectedDayChange
+            .pipe(filter(date => !!date))
+            .subscribe(() => this.datepickerFocusService.focusInput(this.el.nativeElement));
+    }
+}
+ClrDateInput.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDateInput, deps: [{ token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.NgControl, optional: true, self: true }, { token: i2.ClrDateContainer, optional: true }, { token: i3.DateIOService, optional: true }, { token: i4.DateNavigationService, optional: true }, { token: i5.DatepickerEnabledService, optional: true }, { token: i6.DateFormControlService, optional: true }, { token: PLATFORM_ID }, { token: i7.FocusService, optional: true }, { token: i8.DatepickerFocusService }], target: i0.ɵɵFactoryTarget.Directive });
+ClrDateInput.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.0", type: ClrDateInput, selector: "[clrDate]", inputs: { placeholder: "placeholder", date: ["clrDate", "date"], min: "min", max: "max", disabled: "disabled" }, outputs: { dateChange: "clrDateChange" }, host: { listeners: { "focus": "setFocusStates()", "blur": "triggerValidation()", "change": "onValueChange($event.target)" }, properties: { "class.clr-input": "true", "attr.placeholder": "this.placeholderText", "attr.type": "this.inputType", "disabled": "this.disabled" } }, providers: [DatepickerFocusService], usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrDateInput, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDate]',
+                    host: {
+                        '[class.clr-input]': 'true',
+                    },
+                    providers: [DatepickerFocusService],
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }, { type: i0.Injector }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: i2.ClrDateContainer, decorators: [{
+                    type: Optional
+                }] }, { type: i3.DateIOService, decorators: [{
+                    type: Optional
+                }] }, { type: i4.DateNavigationService, decorators: [{
+                    type: Optional
+                }] }, { type: i5.DatepickerEnabledService, decorators: [{
+                    type: Optional
+                }] }, { type: i6.DateFormControlService, decorators: [{
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i7.FocusService, decorators: [{
+                    type: Optional
+                }] }, { type: i8.DatepickerFocusService }]; }, propDecorators: { placeholder: [{
+                type: Input
+            }], dateChange: [{
+                type: Output,
+                args: ['clrDateChange']
+            }], date: [{
+                type: Input,
+                args: ['clrDate']
+            }], min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], setFocusStates: [{
+                type: HostListener,
+                args: ['focus']
+            }], triggerValidation: [{
+                type: HostListener,
+                args: ['blur']
+            }], placeholderText: [{
+                type: HostBinding,
+                args: ['attr.placeholder']
+            }], inputType: [{
+                type: HostBinding,
+                args: ['attr.type']
+            }], onValueChange: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }], disabled: [{
+                type: HostBinding,
+                args: ['disabled']
+            }, {
+                type: Input,
+                args: ['disabled']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-input.js","sourceRoot":"","sources":["../../../../../projects/angular/src/forms/datepicker/date-input.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { isPlatformBrowser } from '@angular/common';\nimport {\n  AfterViewInit,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  HostListener,\n  Inject,\n  Injector,\n  Input,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  PLATFORM_ID,\n  Renderer2,\n  Self,\n  ViewContainerRef,\n} from '@angular/core';\nimport { NgControl } from '@angular/forms';\nimport { filter, switchMap } from 'rxjs/operators';\nimport { of } from 'rxjs';\n\nimport { FocusService } from '../common/providers/focus.service';\nimport { WrappedFormControl } from '../common/wrapped-control';\nimport { ClrDateContainer } from './date-container';\nimport { DayModel } from './model/day.model';\nimport { DateFormControlService } from './providers/date-form-control.service';\nimport { DateIOService } from './providers/date-io.service';\nimport { DateNavigationService } from './providers/date-navigation.service';\nimport { DatepickerEnabledService } from './providers/datepicker-enabled.service';\nimport { DatepickerFocusService } from './providers/datepicker-focus.service';\nimport { datesAreEqual } from './utils/date-utils';\nimport { isBooleanAttributeSet } from '../../utils/component/is-boolean-attribute-set';\n\n// There are four ways the datepicker value is set\n// 1. Value set by user typing into text input as a string ex: '01/28/2015'\n// 2. Value set explicitly by Angular Forms APIs as a string ex: '01/28/2015'\n// 3. Value set by user via datepicker UI as a Date Object\n// 4. Value set via `clrDate` input as a Date Object\n\n@Directive({\n  selector: '[clrDate]',\n  host: {\n    '[class.clr-input]': 'true',\n  },\n  providers: [DatepickerFocusService],\n})\nexport class ClrDateInput extends WrappedFormControl<ClrDateContainer> implements OnInit, AfterViewInit, OnDestroy {\n  public static ngAcceptInputType_date: Date | null | string;\n\n  @Input() placeholder: string;\n  @Output('clrDateChange') dateChange: EventEmitter<Date> = new EventEmitter<Date>(false);\n  @Input('clrDate')\n  set date(date: Date | string) {\n    if (this.previousDateChange !== date) {\n      this.updateDate(this.getValidDateValueFromDate(date as Date));\n    }\n\n    if (!this.initialClrDateInputValue) {\n      this.initialClrDateInputValue = date as Date;\n    }\n  }\n\n  @Input()\n  set min(dateString: string) {\n    this.dateIOService.setMinDate(dateString);\n  }\n\n  @Input()\n  set max(dateString: string) {\n    this.dateIOService.setMaxDate(dateString);\n  }\n\n  protected index = 1;\n  private initialClrDateInputValue: Date;\n  private previousDateChange: Date;\n\n  constructor(\n    viewContainerRef: ViewContainerRef,\n    injector: Injector,\n    protected el: ElementRef,\n    protected renderer: Renderer2,\n    @Self()\n    @Optional()\n    protected control: NgControl,\n    @Optional() private container: ClrDateContainer,\n    @Optional() private dateIOService: DateIOService,\n    @Optional() private dateNavigationService: DateNavigationService,\n    @Optional() private datepickerEnabledService: DatepickerEnabledService,\n    @Optional() private dateFormControlService: DateFormControlService,\n    @Inject(PLATFORM_ID) private platformId: any,\n    @Optional() private focusService: FocusService,\n    private datepickerFocusService: DatepickerFocusService\n  ) {\n    super(viewContainerRef, ClrDateContainer, injector, control, renderer, el);\n  }\n\n  ngOnInit() {\n    super.ngOnInit();\n    this.populateServicesFromContainerComponent();\n\n    this.subscriptions.push(\n      this.listenForUserSelectedDayChanges(),\n      this.listenForControlValueChanges(),\n      this.listenForTouchChanges(),\n      this.listenForDirtyChanges(),\n      this.listenForInputRefocus()\n    );\n  }\n\n  ngAfterViewInit() {\n    // I don't know why I have to do this but after using the new HostWrapping Module I have to delay the processing\n    // of the initial Input set by the user to here. If I do not 2 issues occur:\n    // 1. The Input setter is called before ngOnInit. ngOnInit initializes the services without which the setter fails.\n    // 2. The Renderer doesn't work before ngAfterViewInit (It used to before the new HostWrapping Module for some reason).\n    // I need the renderer to set the value property on the input to make sure that if the user has supplied a Date\n    // input object, we reflect it with the right date on the input field using the IO service. I am not sure if\n    // these are major issues or not but just noting them down here.\n    this.processInitialInputs();\n  }\n\n  @HostListener('focus')\n  setFocusStates() {\n    this.setFocus(true);\n  }\n\n  @HostListener('blur')\n  triggerValidation() {\n    super.triggerValidation();\n    this.setFocus(false);\n  }\n\n  @HostBinding('attr.placeholder')\n  get placeholderText(): string {\n    return this.placeholder ? this.placeholder : this.dateIOService.placeholderText;\n  }\n\n  @HostBinding('attr.type')\n  get inputType(): string {\n    return isPlatformBrowser(this.platformId) && this.usingNativeDatepicker() ? 'date' : 'text';\n  }\n\n  @HostListener('change', ['$event.target'])\n  onValueChange(target: HTMLInputElement) {\n    const validDateValue = this.dateIOService.getDateValueFromDateString(target.value);\n    if (this.usingClarityDatepicker() && validDateValue) {\n      this.updateDate(validDateValue, true);\n    } else if (this.usingNativeDatepicker()) {\n      const [year, month, day] = target.value.split('-');\n      this.updateDate(new Date(+year, +month - 1, +day), true);\n    } else {\n      this.emitDateOutput(null);\n    }\n  }\n\n  @HostBinding('disabled')\n  @Input('disabled')\n  set disabled(value: boolean | string) {\n    if (this.dateFormControlService) {\n      this.dateFormControlService.setDisabled(isBooleanAttributeSet(value));\n    }\n  }\n  get disabled() {\n    if (this.dateFormControlService) {\n      return this.dateFormControlService.disabled;\n    }\n    return null;\n  }\n\n  private usingClarityDatepicker() {\n    return this.datepickerEnabledService.isEnabled;\n  }\n\n  private usingNativeDatepicker() {\n    return !this.datepickerEnabledService.isEnabled;\n  }\n\n  private setFocus(focus: boolean) {\n    if (this.focusService) {\n      this.focusService.focused = focus;\n    }\n  }\n\n  private populateServicesFromContainerComponent() {\n    if (!this.container) {\n      this.dateIOService = this.getProviderFromContainer(DateIOService);\n      this.dateNavigationService = this.getProviderFromContainer(DateNavigationService);\n      this.datepickerEnabledService = this.getProviderFromContainer(DatepickerEnabledService);\n      this.dateFormControlService = this.getProviderFromContainer(DateFormControlService);\n    }\n  }\n\n  private processInitialInputs() {\n    if (this.datepickerHasFormControl()) {\n      this.updateDate(this.dateIOService.getDateValueFromDateString(this.control.value));\n    } else {\n      this.updateDate(this.initialClrDateInputValue);\n    }\n  }\n\n  private updateDate(value: Date, setByUserInteraction = false) {\n    const date = this.getValidDateValueFromDate(value);\n\n    if (setByUserInteraction) {\n      this.emitDateOutput(date);\n    } else {\n      this.previousDateChange = date;\n    }\n\n    if (this.dateNavigationService) {\n      this.dateNavigationService.selectedDay = date\n        ? new DayModel(date.getFullYear(), date.getMonth(), date.getDate())\n        : null;\n    }\n\n    this.updateInput(date);\n  }\n\n  private updateInput(date: Date) {\n    if (date) {\n      const dateString = this.dateIOService.toLocaleDisplayFormatString(date);\n      if (this.usingNativeDatepicker()) {\n        // valueAsDate expects UTC, date from input is time-zoned\n        date.setMinutes(date.getMinutes() - date.getTimezoneOffset());\n        this.renderer.setProperty(this.el.nativeElement, 'valueAsDate', date);\n      } else if (this.datepickerHasFormControl() && dateString !== this.control.value) {\n        this.control.control.setValue(dateString);\n      } else {\n        this.renderer.setProperty(this.el.nativeElement, 'value', dateString);\n      }\n    } else {\n      this.renderer.setProperty(this.el.nativeElement, 'value', '');\n    }\n  }\n\n  private getValidDateValueFromDate(date: Date) {\n    if (this.dateIOService) {\n      const dateString = this.dateIOService.toLocaleDisplayFormatString(date);\n      return this.dateIOService.getDateValueFromDateString(dateString);\n    } else {\n      return null;\n    }\n  }\n\n  private emitDateOutput(date: Date) {\n    if (!datesAreEqual(date, this.previousDateChange)) {\n      this.dateChange.emit(date);\n      this.previousDateChange = date;\n    } else if (!date && this.previousDateChange) {\n      this.dateChange.emit(null);\n      this.previousDateChange = null;\n    }\n  }\n\n  private datepickerHasFormControl() {\n    return !!this.control;\n  }\n\n  private listenForControlValueChanges() {\n    return of(this.datepickerHasFormControl())\n      .pipe(\n        filter(hasControl => hasControl),\n        switchMap(() => this.control.valueChanges),\n        // only update date value if not being set by user\n        filter(() => !this.datepickerFocusService.elementIsFocused(this.el.nativeElement))\n      )\n      .subscribe((value: string) => this.updateDate(this.dateIOService.getDateValueFromDateString(value)));\n  }\n\n  private listenForUserSelectedDayChanges() {\n    return this.dateNavigationService.selectedDayChange.subscribe(dayModel => this.updateDate(dayModel.toDate(), true));\n  }\n\n  private listenForTouchChanges() {\n    return this.dateFormControlService.touchedChange\n      .pipe(filter(() => this.datepickerHasFormControl()))\n      .subscribe(() => this.control.control.markAsTouched());\n  }\n\n  private listenForDirtyChanges() {\n    return this.dateFormControlService.dirtyChange\n      .pipe(filter(() => this.datepickerHasFormControl()))\n      .subscribe(() => this.control.control.markAsDirty());\n  }\n\n  private listenForInputRefocus() {\n    return this.dateNavigationService.selectedDayChange\n      .pipe(filter(date => !!date))\n      .subscribe(() => this.datepickerFocusService.focusInput(this.el.nativeElement));\n  }\n}\n"]}