@porscheinformatik/clr-addons 15.0.1 → 15.2.1

package/esm2020/daterangepicker/directives/datepicker/datepicker.component.mjs

@@ -0,0 +1,97 @@
+import { Component, ElementRef, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { ClrDateContainer } from '@clr/angular';
+import { DayModel } from '../../models/day.model';
+import { OpenedDatepickersTrackerService } from '../../providers/opened-datepickers-tracker.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../providers/opened-datepickers-tracker.service";
+import * as i2 from "@clr/angular";
+export class ClrDatepickerComponent {
+    constructor(openedDatepickersTrackerService) {
+        this.openedDatepickersTrackerService = openedDatepickersTrackerService;
+        /**
+         * Text label.
+         */
+        this.label = 'Date';
+        /**
+         * Minimum date that can be selected.
+         */
+        this.minDate = undefined;
+        /**
+         * Maximum date that can be selected.
+         */
+        this.maxDate = undefined;
+        /**
+         * Event triggered when value changes.
+         */
+        this.valueChange = new EventEmitter();
+        /** List of subscriptions to later destroy. */
+        this.subscriptions = [];
+    }
+    /**
+     * Get date.
+     * @returns JavaScript Date object.
+     */
+    get date() {
+        return this.value?.toDate();
+    }
+    /**
+     * Set date.
+     */
+    set date(val) {
+        this.value = val == null ? null : new DayModel(val);
+        this.valueChange.emit(this.value);
+    }
+    /**
+     * Minimum date as attribute string.
+     * @returns Minimum date as attribute string.
+     */
+    get minDateAttr() {
+        return this.minDate?.toHTML5SpecDateString();
+    }
+    /**
+     * Maximum date as attribute string.
+     * @returns Maximum date as attribute string.
+     */
+    get maxDateAttr() {
+        return this.maxDate?.toHTML5SpecDateString();
+    }
+    ngAfterViewInit() {
+        // eslint-disable-next-line dot-notation -- Need access to this private property.
+        const toggleService = this.clrDateContainer['toggleService'];
+        this.subscriptions.push(toggleService.openChange.subscribe(openState => {
+            this.openedDatepickersTrackerService.track(openState);
+        }));
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(subscription => subscription.unsubscribe());
+    }
+    /**
+     * Focus input.
+     */
+    focus() {
+        this.inputElm.nativeElement.focus();
+    }
+}
+ClrDatepickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDatepickerComponent, deps: [{ token: i1.OpenedDatepickersTrackerService }], target: i0.ɵɵFactoryTarget.Component });
+ClrDatepickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "15.2.1", type: ClrDatepickerComponent, selector: "clr-datepicker", inputs: { value: "value", label: "label", minDate: "minDate", maxDate: "maxDate" }, outputs: { valueChange: "valueChange" }, viewQueries: [{ propertyName: "inputElm", first: true, predicate: ["inputElm"], descendants: true }, { propertyName: "clrDateContainer", first: true, predicate: ClrDateContainer, descendants: true }], ngImport: i0, template: "<clr-date-container>\n  <label>{{ this.label }}</label>\n  <input #inputElm clrDate [(clrDate)]=\"this.date\" [min]=\"this.minDateAttr\" [max]=\"this.maxDateAttr\" />\n</clr-date-container>\n", dependencies: [{ kind: "directive", type: i2.ClrLabel, selector: "label", inputs: ["for"] }, { kind: "component", type: i2.ClrDateContainer, selector: "clr-date-container", inputs: ["clrPosition"] }, { kind: "directive", type: i2.ClrDateInput, selector: "[clrDate]", inputs: ["placeholder", "clrDate", "min", "max", "disabled"], outputs: ["clrDateChange"] }, { kind: "directive", type: i2.ClrDateInputValidator, selector: "[clrDate]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDatepickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'clr-datepicker', template: "<clr-date-container>\n  <label>{{ this.label }}</label>\n  <input #inputElm clrDate [(clrDate)]=\"this.date\" [min]=\"this.minDateAttr\" [max]=\"this.maxDateAttr\" />\n</clr-date-container>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.OpenedDatepickersTrackerService }]; }, propDecorators: { value: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], inputElm: [{
+                type: ViewChild,
+                args: ['inputElm']
+            }], clrDateContainer: [{
+                type: ViewChild,
+                args: [ClrDateContainer]
+            }], valueChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/daterangepicker/directives/daterangepicker/daterangepicker.directive.mjs

@@ -0,0 +1,256 @@
+import { Directive, ElementRef, EventEmitter, HostBinding, HostListener, Input, Output, Renderer2, Self, } from '@angular/core';
+import { NgControl } from '@angular/forms';
+import { SEPARATOR_TEXT_DEFAULT } from '../../daterange.constants';
+import { DayModel } from '../../models/day.model';
+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 * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "../../providers/daterange-control-state.service";
+import * as i3 from "../../../abstract-form-component/control-id.service";
+import * as i4 from "../../providers/daterange.service";
+import * as i5 from "../../providers/daterange-parsing.service";
+/**
+ * Daterangepicker.
+ */
+export class ClrDaterangepickerDirective {
+    constructor(control, element, renderer, daterangeControlStateService, controlIdService, daterangeService, daterangeParsingService) {
+        this.control = control;
+        this.element = element;
+        this.renderer = renderer;
+        this.daterangeControlStateService = daterangeControlStateService;
+        this.controlIdService = controlIdService;
+        this.daterangeService = daterangeService;
+        this.daterangeParsingService = daterangeParsingService;
+        /**
+         * Locale text between 'from' and 'to' dateranges.
+         */
+        this.separatorText = SEPARATOR_TEXT_DEFAULT;
+        /**
+         * Event that is triggered when value changes.
+         */
+        this.valueChange = new EventEmitter();
+        /** Set the `type` attribute always to "text", to not get the native datepicker. */
+        this.inputType = 'text';
+        this.inputClass = true;
+        /** List of subscriptions to later destroy. */
+        this.subscriptions = [];
+        this.onChanged = (_value) => undefined;
+        this.onTouched = (_value) => undefined;
+        // To get access to the NgControl, we had to remove the `NG_VALUE_ACCESSOR`
+        // provider and set them manually, while still keeping the interfaces.
+        this.control.valueAccessor = this;
+    }
+    /**
+     * Minimum date that can be selected.
+     */
+    set min(value) {
+        this.daterangeService.minDate = !value ? null : new DayModel(value);
+    }
+    /**
+     * Maximum date that can be selected.
+     */
+    set max(value) {
+        this.daterangeService.maxDate = !value ? null : new DayModel(value);
+    }
+    get placeholderText() {
+        return (this.placeholder ??
+            this.daterangeParsingService.localeFormat + this.separatorText + this.daterangeParsingService.localeFormat);
+    }
+    /**
+     * Id-attribute.
+     */
+    get id() {
+        return this.controlIdService.id;
+    }
+    /**
+     * Id-attribute.
+     * @returns Id-attribute.
+     */
+    set id(value) {
+        this.controlIdService.id = value;
+    }
+    /**
+     * Disable control.
+     */
+    set disabled(value) {
+        this.daterangeControlStateService.disabled = value;
+    }
+    /**
+     * Disabled state.
+     * @returns Disabled state.
+     */
+    get disabled() {
+        return this.daterangeControlStateService.disabled;
+    }
+    ngOnInit() {
+        this.listenForDaterangeValueChanges();
+        this.listenForControlStatusChanges();
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(subscription => subscription.unsubscribe());
+    }
+    /**
+     * Listen for daterange value changes.
+     */
+    listenForDaterangeValueChanges() {
+        this.subscriptions.push(this.daterangeService.valueChange.subscribe((_daterange) => {
+            this.triggerChange();
+        }));
+    }
+    /**
+     * Listen for control status changes.
+     */
+    listenForControlStatusChanges() {
+        this.subscriptions.push(this.control.statusChanges.subscribe((_status) => {
+            this.daterangeControlStateService.updateStatus(this.control.control);
+        }));
+    }
+    /**
+     * Listen to manual changes to the input.
+     * @param target - Input element.
+     */
+    onChangeEvent(target) {
+        // Remove 'invalid' error.
+        if (this.control.control.hasError('invalid')) {
+            delete this.control.control.errors.invalid;
+        }
+        // If there is nothing to parse, `ClrDaterangeRequiredValidator` will take care of this.
+        if (!target.value) {
+            this.daterangeService.updateSelectedDaterange(null, true);
+            return;
+        }
+        const daterange = this.daterangeParsingService.parse(target.value, this.separatorText);
+        const invalidDaterange = daterange == null || daterange.from == null || daterange.to == null;
+        // Invalid manual daterange specified.
+        if (invalidDaterange) {
+            this.control.control.setErrors({
+                invalid: target.value,
+            });
+        }
+        // Update selected daterange, but only notify when valid.
+        this.daterangeService.updateSelectedDaterange(daterange, !invalidDaterange);
+    }
+    /**
+     * Listen to focus event.
+     */
+    focusEvent() {
+        this.daterangeControlStateService.focused = true;
+    }
+    /**
+     * Listen to blur event.
+     */
+    blurEvent() {
+        this.daterangeControlStateService.focused = false;
+    }
+    /**
+     * Focus input.
+     */
+    focus() {
+        this.element.nativeElement.focus();
+    }
+    /**
+     * Trigger events to notify form controls, trigger validation and update attributes/properties.
+     */
+    triggerChange() {
+        let daterange = this.daterangeService.selectedDaterange;
+        // When `from` or `to` properties are not set, return null.
+        // This will trigger the `required` validator (if present).
+        if (!this.daterangeService.isValid()) {
+            daterange = null;
+        }
+        // Mark control dirty.
+        this.onTouched(daterange);
+        // Update NgModel.
+        this.onChanged(daterange);
+        // Notify parent.
+        this.valueChange.emit(daterange);
+        // Update attributes/properties.
+        this.updateInput();
+    }
+    /**
+     * Update input with friendly daterange text.
+     */
+    updateInput() {
+        const dateString = this.daterangeParsingService.toLocaleString(this.daterangeService.selectedDaterange, this.separatorText);
+        this.renderer.setProperty(this.element.nativeElement, 'value', dateString);
+    }
+    /**
+     * ControlValueAccessor method. Set value from NgModel.
+     * @param value - Daterange value.
+     */
+    writeValue(value) {
+        this.daterangeService.updateSelectedDaterange(value);
+    }
+    /**
+     * ControlValueAccessor method. Register change event. When value changes.
+     * @param fn - Change event.
+     */
+    registerOnChange(fn) {
+        this.onChanged = fn;
+    }
+    /**
+     * ControlValueAccessor method. Register touch event. When control is dirty.
+     * @param fn - Touch event.
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * ControlValueAccessor method. Set disabled state.
+     * @param disabled - Disabled state.
+     */
+    setDisabledState(disabled) {
+        this.daterangeControlStateService.disabled = disabled;
+    }
+}
+ClrDaterangepickerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.1", 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 });
+ClrDaterangepickerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.1", 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 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.1", ngImport: i0, type: ClrDaterangepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[clrDaterangepicker]',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }] }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.DaterangeControlStateService }, { type: i3.ControlIdService }, { type: i4.DaterangeService }, { type: i5.DaterangeParsingService }]; }, propDecorators: { min: [{
+                type: Input
+            }], max: [{
+                type: Input
+            }], separatorText: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], placeholderText: [{
+                type: HostBinding,
+                args: ['attr.placeholder']
+            }], id: [{
+                type: HostBinding
+            }, {
+                type: Input
+            }], disabled: [{
+                type: HostBinding,
+                args: ['disabled']
+            }, {
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], inputType: [{
+                type: HostBinding,
+                args: ['attr.type']
+            }], inputClass: [{
+                type: HostBinding,
+                args: ['class.clr-input']
+            }], onChangeEvent: [{
+                type: HostListener,
+                args: ['change', ['$event.target']]
+            }], focusEvent: [{
+                type: HostListener,
+                args: ['focus']
+            }], blurEvent: [{
+                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"]}