ontimize-web-ngx 15.3.5 → 15.4.1

package/esm2020/lib/components/input/date-range-legacy/o-daterange-input.directive.mjs

@@ -0,0 +1,381 @@
+import { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';
+import { Overlay, OverlayConfig, ScrollStrategyOptions } from '@angular/cdk/overlay';
+import { ComponentPortal } from '@angular/cdk/portal';
+import { ChangeDetectorRef, Directive, ElementRef, EventEmitter, forwardRef, Input, KeyValueDiffers, NgZone, Output, ViewContainerRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { MatDialog } from '@angular/material/dialog';
+import moment from 'moment';
+import { merge } from 'rxjs';
+import { filter, take } from 'rxjs/operators';
+import { DaterangepickerComponent } from './o-daterange-picker.component';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/material/dialog";
+import * as i2 from "@angular/cdk/overlay";
+export class ODaterangepickerDirective {
+    set separator(value) {
+        if (value !== null) {
+            this._separator = value;
+            if (this._locale) {
+                this._locale.separator = value;
+            }
+        }
+    }
+    set locale(value) {
+        if (value !== null) {
+            this._locale = value;
+            if (this._separator) {
+                this._locale.separator = this._separator;
+            }
+        }
+    }
+    get locale() {
+        return this._locale;
+    }
+    set startKey(value) {
+        if (value && value !== null) {
+            this._startKey = value;
+        }
+        else {
+            this._startKey = 'startDate';
+        }
+    }
+    get startKey() {
+        return this._startKey;
+    }
+    set endKey(value) {
+        if (value && value !== null) {
+            this._endKey = value;
+        }
+        else {
+            this._endKey = 'endDate';
+        }
+    }
+    get endKey() {
+        return this._endKey;
+    }
+    get value() {
+        return this._value || null;
+    }
+    set value(val) {
+        this._value = val;
+        this._onChange(val);
+        this._changeDetectorRef.markForCheck();
+    }
+    constructor(_dialog, _ngZone, _overlay, _viewContainerRef, _changeDetectorRef, _el, differs, scrollStrategy) {
+        this._dialog = _dialog;
+        this._ngZone = _ngZone;
+        this._overlay = _overlay;
+        this._viewContainerRef = _viewContainerRef;
+        this._changeDetectorRef = _changeDetectorRef;
+        this._el = _el;
+        this.differs = differs;
+        this.scrollStrategy = scrollStrategy;
+        this._onChange = Function.prototype;
+        this._onTouched = Function.prototype;
+        this._validatorChange = Function.prototype;
+        this.minDate = null;
+        this.maxDate = null;
+        this.dateLimit = null;
+        this.showCancel = false;
+        this.timePicker = false;
+        this.showRanges = false;
+        this.timePicker24Hour = false;
+        this.timePickerIncrement = 1;
+        this.timePickerSeconds = false;
+        this._endKey = 'endDate';
+        this._startKey = 'startDate';
+        this.ranges = {
+            'DATERANGE.today': [moment(), moment()],
+            'DATERANGE.yesterday': [moment().subtract(1, 'days'), moment().subtract(1, 'days')],
+            'DATERANGE.last_7days': [moment().subtract(6, 'days'), moment()],
+            'DATERANGE.last_30days': [moment().subtract(29, 'days'), moment()],
+            'DATERANGE.this_month': [moment().startOf('month'), moment().endOf('month')],
+            'DATERANGE.last_month': [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],
+            'DATERANGE.this_year': [moment().startOf('year'), moment().endOf('year')]
+        };
+        this.oTouchUi = false;
+        this.notForChangesProperty = [
+            'locale',
+            'endKey',
+            'startKey'
+        ];
+        this.onChange = new EventEmitter();
+        this.rangeClicked = new EventEmitter();
+        this.datesUpdated = new EventEmitter();
+        this.drops = 'down';
+        this.opens = 'right';
+    }
+    initializeListeners(instance) {
+        instance.rangeClicked.asObservable().subscribe((range) => {
+            this.rangeClicked.emit(range);
+        });
+        instance.datesUpdated.asObservable().subscribe((range) => {
+            this.datesUpdated.emit(range);
+        });
+        instance.choosedDate.asObservable().subscribe((change) => {
+            if (change) {
+                const value = {};
+                value[this._startKey] = change.startDate;
+                value[this._endKey] = change.endDate;
+                this.value = value;
+                this.onChange.emit(value);
+                if (typeof change.chosenLabel === 'string') {
+                    this._el.nativeElement.value = change.chosenLabel;
+                }
+            }
+        });
+        instance.firstMonthDayClass = this.firstMonthDayClass;
+        instance.lastMonthDayClass = this.lastMonthDayClass;
+        instance.emptyWeekRowClass = this.emptyWeekRowClass;
+        instance.firstDayOfNextMonthClass = this.firstDayOfNextMonthClass;
+        instance.lastDayOfPreviousMonthClass = this.lastDayOfPreviousMonthClass;
+        instance.drops = this.drops;
+        instance.opens = this.opens;
+        instance.minDate = this.minDate;
+        instance.maxDate = this.maxDate;
+        instance.locale = this.locale;
+        instance.showWeekNumbers = this.showWeekNumbers;
+        instance.singleDatePicker = this.singleDatePicker;
+        if (this.showRanges) {
+            instance.ranges = this.ranges;
+            instance.keepCalendarOpeningWithRange = true;
+            instance.alwaysShowCalendars = true;
+        }
+        this.localeDiffer = this.differs.find(this.locale).create();
+    }
+    onBlur() {
+        this._onTouched();
+    }
+    open() {
+        if (!this.oTouchUi) {
+            this.openAsPopup();
+        }
+        else {
+            this.openAsDialog();
+        }
+    }
+    ngOnDestroy() {
+        this.close();
+        if (this._popupRef) {
+            this._popupRef.dispose();
+            this._popupComponentRef = null;
+        }
+    }
+    clear() {
+        this._popupComponentRef.instance.clear();
+    }
+    writeValue(value) {
+        this.setValue(value);
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouched = fn;
+    }
+    setValueInDateComponent(instance, val) {
+        if (val) {
+            if (val[this._startKey]) {
+                instance.setStartDate(val[this._startKey]);
+            }
+            if (val[this._endKey]) {
+                instance.setEndDate(val[this._endKey]);
+            }
+            instance.calculateChosenLabel();
+            if (instance.chosenLabel) {
+                this._el.nativeElement.value = instance.chosenLabel;
+            }
+        }
+        else {
+            instance.clear();
+        }
+    }
+    setValue(val) {
+        if (val) {
+            this.value = val;
+        }
+    }
+    openAsPopup() {
+        if (!this._calendarPortal) {
+            this._calendarPortal = new ComponentPortal(DaterangepickerComponent, this._viewContainerRef);
+        }
+        if (!this._popupRef) {
+            this._createPopup();
+        }
+        if (!this._popupRef.hasAttached()) {
+            this._popupComponentRef = this._popupRef.attach(this._calendarPortal);
+            this.initializeListeners(this._popupComponentRef.instance);
+            if (this.value) {
+                this.setValueInDateComponent(this._popupComponentRef.instance, this.value);
+            }
+            this._ngZone.onStable.asObservable().pipe(take(1)).subscribe(() => {
+                this._popupRef.updatePosition();
+            });
+        }
+    }
+    _createPopup() {
+        const overlayConfig = new OverlayConfig({
+            positionStrategy: this._createPopupPositionStrategy(),
+            hasBackdrop: true,
+            backdropClass: 'mat-overlay-transparent-backdrop',
+            direction: 'ltr',
+            panelClass: 'o-daterangepicker-popup',
+            scrollStrategy: this.scrollStrategy.close()
+        });
+        this._popupRef = this._overlay.create(overlayConfig);
+        this._popupRef.overlayElement.setAttribute('role', 'dialog');
+        merge(this._popupRef.backdropClick(), this._popupRef.detachments(), this._popupRef.keydownEvents().pipe(filter(event => {
+            return event.keyCode === ESCAPE ||
+                (this._el && event.altKey && event.keyCode === UP_ARROW);
+        }))).subscribe(() => this.close());
+    }
+    _createPopupPositionStrategy() {
+        return this._overlay.position()
+            .flexibleConnectedTo(this._el)
+            .withViewportMargin(8)
+            .withPositions([
+            {
+                originX: 'start',
+                originY: 'bottom',
+                overlayX: 'start',
+                overlayY: 'top'
+            },
+            {
+                originX: 'start',
+                originY: 'top',
+                overlayX: 'start',
+                overlayY: 'bottom'
+            },
+            {
+                originX: 'end',
+                originY: 'bottom',
+                overlayX: 'end',
+                overlayY: 'top'
+            },
+            {
+                originX: 'end',
+                originY: 'top',
+                overlayX: 'end',
+                overlayY: 'bottom'
+            }
+        ]);
+    }
+    openAsDialog() {
+        if (this._dialogRef) {
+            this._dialogRef.close();
+        }
+        this._dialogRef = this._dialog.open(DaterangepickerComponent, {
+            direction: 'ltr',
+            viewContainerRef: this._viewContainerRef,
+            panelClass: 'mat-datepicker-dialog',
+        });
+        this.initializeListeners(this._dialogRef.componentInstance);
+        if (this.value) {
+            this.setValueInDateComponent(this._dialogRef.componentInstance, this.value);
+        }
+        this._dialogRef.afterClosed().subscribe(() => this.close());
+    }
+    close() {
+        if (this._popupRef && this._popupRef.hasAttached()) {
+            this._popupRef.detach();
+        }
+        if (this._dialogRef) {
+            this._dialogRef.close();
+        }
+        if (this._calendarPortal && this._calendarPortal.isAttached) {
+            this._calendarPortal.detach();
+        }
+    }
+}
+ODaterangepickerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ODaterangepickerDirective, deps: [{ token: i1.MatDialog }, { token: i0.NgZone }, { token: i2.Overlay }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }, { token: i0.ElementRef }, { token: i0.KeyValueDiffers }, { token: i2.ScrollStrategyOptions }], target: i0.ɵɵFactoryTarget.Directive });
+ODaterangepickerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.2.10", type: ODaterangepickerDirective, selector: "input[o-daterange-input]", inputs: { minDate: "minDate", maxDate: "maxDate", showCustomRangeLabel: "showCustomRangeLabel", linkedCalendars: "linkedCalendars", dateLimit: "dateLimit", singleDatePicker: "singleDatePicker", showWeekNumbers: "showWeekNumbers", showISOWeekNumbers: "showISOWeekNumbers", showDropdowns: "showDropdowns", isInvalidDate: "isInvalidDate", isCustomDate: "isCustomDate", opens: "opens", drops: "drops", lastMonthDayClass: "lastMonthDayClass", emptyWeekRowClass: "emptyWeekRowClass", firstDayOfNextMonthClass: "firstDayOfNextMonthClass", lastDayOfPreviousMonthClass: "lastDayOfPreviousMonthClass", keepCalendarOpeningWithRange: "keepCalendarOpeningWithRange", showRangeLabelOnInput: "showRangeLabelOnInput", showCancel: "showCancel", timePicker: "timePicker", showRanges: "showRanges", timePicker24Hour: "timePicker24Hour", timePickerIncrement: "timePickerIncrement", timePickerSeconds: "timePickerSeconds", separator: "separator", locale: "locale", _endKey: "_endKey", oTouchUi: "oTouchUi", startKey: "startKey", endKey: "endKey" }, outputs: { onChange: "onChange", rangeClicked: "rangeClicked", datesUpdated: "datesUpdated" }, host: { listeners: { "keyup.esc": "close()", "blur": "onBlur()" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => ODaterangepickerDirective), multi: true
+        }
+    ], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ODaterangepickerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[o-daterange-input]',
+                    host: {
+                        '(keyup.esc)': 'close()',
+                        '(blur)': 'onBlur()'
+                    },
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ODaterangepickerDirective), multi: true
+                        }
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i1.MatDialog }, { type: i0.NgZone }, { type: i2.Overlay }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }, { type: i0.ElementRef }, { type: i0.KeyValueDiffers }, { type: i2.ScrollStrategyOptions }]; }, propDecorators: { minDate: [{
+                type: Input
+            }], maxDate: [{
+                type: Input
+            }], showCustomRangeLabel: [{
+                type: Input
+            }], linkedCalendars: [{
+                type: Input
+            }], dateLimit: [{
+                type: Input
+            }], singleDatePicker: [{
+                type: Input
+            }], showWeekNumbers: [{
+                type: Input
+            }], showISOWeekNumbers: [{
+                type: Input
+            }], showDropdowns: [{
+                type: Input
+            }], isInvalidDate: [{
+                type: Input
+            }], isCustomDate: [{
+                type: Input
+            }], opens: [{
+                type: Input
+            }], drops: [{
+                type: Input
+            }], lastMonthDayClass: [{
+                type: Input
+            }], emptyWeekRowClass: [{
+                type: Input
+            }], firstDayOfNextMonthClass: [{
+                type: Input
+            }], lastDayOfPreviousMonthClass: [{
+                type: Input
+            }], keepCalendarOpeningWithRange: [{
+                type: Input
+            }], showRangeLabelOnInput: [{
+                type: Input
+            }], showCancel: [{
+                type: Input
+            }], timePicker: [{
+                type: Input
+            }], showRanges: [{
+                type: Input
+            }], timePicker24Hour: [{
+                type: Input
+            }], timePickerIncrement: [{
+                type: Input
+            }], timePickerSeconds: [{
+                type: Input
+            }], separator: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }], _endKey: [{
+                type: Input
+            }], oTouchUi: [{
+                type: Input
+            }], startKey: [{
+                type: Input
+            }], endKey: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }], rangeClicked: [{
+                type: Output
+            }], datesUpdated: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"o-daterange-input.directive.js","sourceRoot":"","sources":["../../../../../../projects/ontimize-web-ngx/src/lib/components/input/date-range-legacy/o-daterange-input.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { ESCAPE, UP_ARROW } from '@angular/cdk/keycodes';\nimport { Overlay, OverlayConfig, OverlayRef, PositionStrategy, ScrollStrategyOptions } from '@angular/cdk/overlay';\nimport { ComponentPortal } from '@angular/cdk/portal';\nimport { ChangeDetectorRef, ComponentRef, Directive, ElementRef, EventEmitter, forwardRef, Input, KeyValueDiffer, KeyValueDiffers, NgZone, Output, ViewContainerRef, OnDestroy } from '@angular/core';\nimport { NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { MatDialog, MatDialogRef } from '@angular/material/dialog';\nimport moment from 'moment'\nimport { merge } from 'rxjs';\nimport { filter, take } from 'rxjs/operators';\nimport { DaterangepickerComponent } from './o-daterange-picker.component';\n\n@Directive({\n  selector: 'input[o-daterange-input]',\n  host: {\n    '(keyup.esc)': 'close()',\n    '(blur)': 'onBlur()'\n  },\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => ODaterangepickerDirective), multi: true\n    }\n  ]\n})\nexport class ODaterangepickerDirective implements OnDestroy {\n\n  private _onChange = Function.prototype;\n  private _onTouched = Function.prototype;\n  public _validatorChange = Function.prototype;\n  private _value: any;\n\n  public localeDiffer: KeyValueDiffer<string, any>;\n\n  @Input()\n  minDate: moment.Moment = null;\n  @Input()\n  maxDate: moment.Moment = null;\n  @Input()\n  showCustomRangeLabel: boolean;\n  @Input()\n  linkedCalendars: boolean;\n  @Input()\n  dateLimit: number = null;\n  @Input()\n  singleDatePicker: boolean;\n  @Input()\n  showWeekNumbers: boolean;\n  @Input()\n  showISOWeekNumbers: boolean;\n  @Input()\n  showDropdowns: boolean;\n  @Input()\n  isInvalidDate: () => boolean;\n  @Input()\n  isCustomDate: () => boolean;\n  // @Input()\n  // showClearButton: boolean;\n\n\n  @Input()\n  opens: string;\n  @Input()\n  drops: string;\n  firstMonthDayClass: string;\n  @Input()\n  lastMonthDayClass: string;\n  @Input()\n  emptyWeekRowClass: string;\n  @Input()\n  firstDayOfNextMonthClass: string;\n  @Input()\n  lastDayOfPreviousMonthClass: string;\n  @Input()\n  keepCalendarOpeningWithRange: boolean;\n  @Input()\n  showRangeLabelOnInput: boolean;\n  @Input()\n  showCancel: boolean = false;\n  // timepicker variables\n  @Input()\n  timePicker: boolean = false;\n  @Input()\n  showRanges: boolean = false;\n  @Input()\n  timePicker24Hour: boolean = false;\n  @Input()\n  timePickerIncrement: number = 1;\n  @Input()\n  timePickerSeconds: boolean = false;\n  _locale: any;\n  _separator: string;\n\n  @Input() set separator(value) {\n    if (value !== null) {\n      this._separator = value;\n      if (this._locale) {\n        this._locale.separator = value;\n      }\n    }\n  }\n\n  @Input() set locale(value) {\n    if (value !== null) {\n      this._locale = value;\n      if (this._separator) {\n        this._locale.separator = this._separator;\n      }\n    }\n  }\n  get locale(): any {\n    return this._locale;\n  }\n\n  @Input()\n  private _endKey: string = 'endDate';\n  private _startKey: string = 'startDate';\n\n  public ranges: any = {\n    'DATERANGE.today': [moment(), moment()],\n    'DATERANGE.yesterday': [moment().subtract(1, 'days'), moment().subtract(1, 'days')],\n    'DATERANGE.last_7days': [moment().subtract(6, 'days'), moment()],\n    'DATERANGE.last_30days': [moment().subtract(29, 'days'), moment()],\n    'DATERANGE.this_month': [moment().startOf('month'), moment().endOf('month')],\n    'DATERANGE.last_month': [moment().subtract(1, 'month').startOf('month'), moment().subtract(1, 'month').endOf('month')],\n    'DATERANGE.this_year': [moment().startOf('year'), moment().endOf('year')]\n  };\n\n  @Input()\n  oTouchUi: boolean = false;\n\n  @Input() set startKey(value) {\n    if (value && value !== null) {\n      this._startKey = value;\n    } else {\n      this._startKey = 'startDate';\n    }\n  }\n  get startKey(): string {\n    return this._startKey;\n  }\n  @Input() set endKey(value) {\n    if (value && value !== null) {\n      this._endKey = value;\n    } else {\n      this._endKey = 'endDate';\n    }\n  }\n  get endKey(): string {\n    return this._endKey;\n  }\n  notForChangesProperty: Array<string> = [\n    'locale',\n    'endKey',\n    'startKey'\n  ];\n\n  get value() {\n    return this._value || null;\n  }\n  set value(val) {\n    this._value = val;\n    this._onChange(val);\n    this._changeDetectorRef.markForCheck();\n  }\n  @Output() onChange: EventEmitter<object> = new EventEmitter();\n  @Output() rangeClicked: EventEmitter<object> = new EventEmitter();\n  @Output() datesUpdated: EventEmitter<object> = new EventEmitter();\n\n  private _popupComponentRef: ComponentRef<DaterangepickerComponent> | null;\n  private _calendarPortal: ComponentPortal<DaterangepickerComponent>;\n  _popupRef: OverlayRef;\n  private _dialogRef: MatDialogRef<DaterangepickerComponent> | null;\n\n  constructor(\n    private _dialog: MatDialog,\n    private _ngZone: NgZone,\n    private _overlay: Overlay,\n    public _viewContainerRef: ViewContainerRef,\n    public _changeDetectorRef: ChangeDetectorRef,\n    public _el: ElementRef,\n    private differs: KeyValueDiffers,\n    private scrollStrategy: ScrollStrategyOptions\n  ) {\n    this.drops = 'down';\n    this.opens = 'right';\n  }\n\n  initializeListeners(instance) {\n    instance.rangeClicked.asObservable().subscribe((range: any) => {\n      this.rangeClicked.emit(range);\n    });\n    instance.datesUpdated.asObservable().subscribe((range: any) => {\n      this.datesUpdated.emit(range);\n    });\n    instance.choosedDate.asObservable().subscribe((change: any) => {\n      if (change) {\n        const value = {};\n        value[this._startKey] = change.startDate;\n        value[this._endKey] = change.endDate;\n        this.value = value;\n        this.onChange.emit(value);\n        if (typeof change.chosenLabel === 'string') {\n          this._el.nativeElement.value = change.chosenLabel;\n        }\n      }\n    });\n    instance.firstMonthDayClass = this.firstMonthDayClass;\n    instance.lastMonthDayClass = this.lastMonthDayClass;\n    instance.emptyWeekRowClass = this.emptyWeekRowClass;\n    instance.firstDayOfNextMonthClass = this.firstDayOfNextMonthClass;\n    instance.lastDayOfPreviousMonthClass = this.lastDayOfPreviousMonthClass;\n    instance.drops = this.drops;\n    instance.opens = this.opens;\n    instance.minDate = this.minDate;\n    instance.maxDate = this.maxDate;\n    instance.locale = this.locale;\n    instance.showWeekNumbers = this.showWeekNumbers;\n    instance.singleDatePicker = this.singleDatePicker;\n\n    if (this.showRanges) {\n      instance.ranges = this.ranges;\n      instance.keepCalendarOpeningWithRange = true;\n      instance.alwaysShowCalendars = true;\n    }\n    this.localeDiffer = this.differs.find(this.locale).create();\n  }\n\n  // ngOnChanges(changes: SimpleChanges): void  {\n  //   for (let change in changes) {\n  //     if (changes.hasOwnProperty(change)) {\n  //       if (this.notForChangesProperty.indexOf(change) === -1) {\n  //         this.picker[change] = changes[change].currentValue;\n  //       }\n  //     }\n  //   }\n  // }\n\n  // ngDoCheck() {\n  //   if (this.localeDiffer) {\n  //     const changes = this.localeDiffer.diff(this.locale);\n  //     if (changes) {\n  //       this.picker.updateLocale(this.locale);\n  //     }\n  //   }\n  // }\n\n  onBlur() {\n    this._onTouched();\n  }\n\n  open() {\n    if (!this.oTouchUi) {\n      this.openAsPopup();\n\n    } else {\n      this.openAsDialog();\n    }\n  }\n\n  ngOnDestroy() {\n    this.close();\n\n    if (this._popupRef) {\n      this._popupRef.dispose();\n      this._popupComponentRef = null;\n    }\n  }\n\n  clear() {\n    this._popupComponentRef.instance.clear();\n  }\n\n  writeValue(value) {\n    this.setValue(value);\n  }\n  registerOnChange(fn) {\n    this._onChange = fn;\n  }\n  registerOnTouched(fn) {\n    this._onTouched = fn;\n  }\n\n  setValueInDateComponent(instance, val) {\n    if (val) {\n      if (val[this._startKey]) {\n        instance.setStartDate(val[this._startKey]);\n      }\n      if (val[this._endKey]) {\n        instance.setEndDate(val[this._endKey]);\n      }\n      instance.calculateChosenLabel();\n      if (instance.chosenLabel) {\n        this._el.nativeElement.value = instance.chosenLabel;\n      }\n    } else {\n      instance.clear();\n    }\n\n  }\n  private setValue(val: any) {\n    if (val) {\n      this.value = val;\n\n    }\n  }\n  /**\n   * Set position of the calendar\n   */\n  // setPosition() {\n  //   let style;\n  //   let containerTop;\n  //   const container = this.picker.pickerContainer.nativeElement;\n  //   const element = this._el.nativeElement;\n  //   if (this.drops && this.drops == 'up') {\n  //     containerTop = (element.offsetTop - container.clientHeight) + 'px';\n  //   } else {\n  //     containerTop = 'auto';\n  //   }\n  //   if (this.opens == 'left') {\n  //     style = {\n  //         top: containerTop,\n  //         left: (element.offsetLeft - container.clientWidth + element.clientWidth) + 'px',\n  //         right: 'auto'\n  //     };\n  //   } else if (this.opens == 'center') {\n  //       style = {\n  //         top: containerTop,\n  //         left: (element.offsetLeft  +  element.clientWidth / 2\n  //                 - container.clientWidth / 2) + 'px',\n  //         right: 'auto'\n  //       };\n  //   } else {\n  //       style = {\n  //         top: containerTop,\n  //         left: element.offsetLeft  + 'px',\n  //         right: 'auto'\n  //       }\n  //   }\n  //   if (style) {\n  //     this._renderer.setStyle(container, 'top', style.top);\n  //     this._renderer.setStyle(container, 'left', style.left);\n  //     this._renderer.setStyle(container, 'right', style.right);\n  //     this._renderer.setStyle(container, 'position', 'fixed');\n  //   }\n  // }\n  /**\n   * For click outside of the calendar's container\n   * @param event event object\n   * @param targetElement target element object\n   */\n  // @HostListener('document:click', ['$event', '$event.target'])\n  // outsideClick(event, targetElement: HTMLElement): void {\n  //     if (!targetElement) {\n  //       return;\n  //     }\n  //     if (targetElement.classList.contains('ngx-daterangepicker-action')) {\n  //       return;\n  //     }\n  //     const clickedInside = this._el.nativeElement.contains(targetElement);\n  //     if (!clickedInside) {\n  //        this.hide()\n  //     }\n  // }\n\n\n\n  /** */\n  public openAsPopup(): void {\n    if (!this._calendarPortal) {\n      this._calendarPortal = new ComponentPortal<DaterangepickerComponent>(DaterangepickerComponent,\n        this._viewContainerRef);\n    }\n\n    if (!this._popupRef) {\n      this._createPopup();\n    }\n\n\n    if (!this._popupRef.hasAttached()) {\n      this._popupComponentRef = this._popupRef.attach(this._calendarPortal);\n      this.initializeListeners(this._popupComponentRef.instance);\n      if (this.value) {\n        this.setValueInDateComponent(this._popupComponentRef.instance, this.value);\n      }\n\n      // Update the position once the calendar has rendered.\n      this._ngZone.onStable.asObservable().pipe(take(1)).subscribe(() => {\n        this._popupRef.updatePosition();\n      });\n    }\n  }\n  /** Create the popup. */\n  private _createPopup(): void {\n    const overlayConfig = new OverlayConfig({\n      positionStrategy: this._createPopupPositionStrategy(),\n      hasBackdrop: true,\n      backdropClass: 'mat-overlay-transparent-backdrop',\n      direction: 'ltr',\n      panelClass: 'o-daterangepicker-popup',\n      scrollStrategy: this.scrollStrategy.close()\n    });\n\n    this._popupRef = this._overlay.create(overlayConfig);\n    this._popupRef.overlayElement.setAttribute('role', 'dialog');\n\n    merge(\n      this._popupRef.backdropClick(),\n      this._popupRef.detachments(),\n      this._popupRef.keydownEvents().pipe(filter(event => {\n        // Closing on alt + up is only valid when there's an input associated with the datepicker.\n        return event.keyCode === ESCAPE ||\n          (this._el && event.altKey && event.keyCode === UP_ARROW);\n      }))\n    ).subscribe(() => this.close());\n  }\n\n  private _createPopupPositionStrategy(): PositionStrategy {\n    return this._overlay.position()\n      .flexibleConnectedTo(this._el)\n      // .withTransformOriginOn('.mat-datepicker-content')\n      // .withFlexibleDimensions(false)\n      .withViewportMargin(8)\n      // .withLockedPosition()\n      .withPositions([\n        {\n          originX: 'start',\n          originY: 'bottom',\n          overlayX: 'start',\n          overlayY: 'top'\n        },\n        {\n          originX: 'start',\n          originY: 'top',\n          overlayX: 'start',\n          overlayY: 'bottom'\n        },\n        {\n          originX: 'end',\n          originY: 'bottom',\n          overlayX: 'end',\n          overlayY: 'top'\n        },\n        {\n          originX: 'end',\n          originY: 'top',\n          overlayX: 'end',\n          overlayY: 'bottom'\n        }\n      ]);\n  }\n\n\n  /** Open the calendar as a dialog. */\n  public openAsDialog(): void {\n    // Usually this would be handled by `open` which ensures that we can only have one overlay\n    // open at a time, however since we reset the variables in async handlers some overlays\n    // may slip through if the user opens and closes multiple times in quick succession (e.g.\n    // by holding down the enter key).\n    if (this._dialogRef) {\n      this._dialogRef.close();\n    }\n\n    this._dialogRef = this._dialog.open<DaterangepickerComponent>(DaterangepickerComponent, {\n      direction: 'ltr',\n      viewContainerRef: this._viewContainerRef,\n      panelClass: 'mat-datepicker-dialog',\n    });\n\n    this.initializeListeners(this._dialogRef.componentInstance);\n    if (this.value) {\n      this.setValueInDateComponent(this._dialogRef.componentInstance, this.value);\n    }\n    this._dialogRef.afterClosed().subscribe(() => this.close());\n    // this._dialogRef.componentInstance. = this;\n\n  }\n\n  close(): void {\n    if (this._popupRef && this._popupRef.hasAttached()) {\n      this._popupRef.detach();\n    }\n\n    if (this._dialogRef) {\n      this._dialogRef.close();\n    }\n\n    if (this._calendarPortal && this._calendarPortal.isAttached) {\n      this._calendarPortal.detach();\n    }\n  }\n}\n"]}

package/esm2020/lib/components/input/date-range-legacy/o-daterange-input.module.mjs

@@ -0,0 +1,21 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { OSharedModule } from '../../../shared/shared.module';
+import { ODateRangeLegacyInputComponent } from './o-daterange-input.component';
+import { ODaterangepickerDirective } from './o-daterange-input.directive';
+import { DaterangepickerComponent } from './o-daterange-picker.component';
+import * as i0 from "@angular/core";
+export class ODateRangeLegacyInputModule {
+}
+ODateRangeLegacyInputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ODateRangeLegacyInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ODateRangeLegacyInputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.10", ngImport: i0, type: ODateRangeLegacyInputModule, declarations: [DaterangepickerComponent, ODateRangeLegacyInputComponent, ODaterangepickerDirective], imports: [CommonModule, OSharedModule], exports: [ODateRangeLegacyInputComponent] });
+ODateRangeLegacyInputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ODateRangeLegacyInputModule, imports: [CommonModule, OSharedModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImport: i0, type: ODateRangeLegacyInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [DaterangepickerComponent, ODateRangeLegacyInputComponent, ODaterangepickerDirective],
+                    imports: [CommonModule, OSharedModule],
+                    exports: [ODateRangeLegacyInputComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiby1kYXRlcmFuZ2UtaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvb250aW1pemUtd2ViLW5neC9zcmMvbGliL2NvbXBvbmVudHMvaW5wdXQvZGF0ZS1yYW5nZS1sZWdhY3kvby1kYXRlcmFuZ2UtaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRXpDLE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUM5RCxPQUFPLEVBQUUsOEJBQThCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMvRSxPQUFPLEVBQUUseUJBQXlCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUMxRSxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7QUFPMUUsTUFBTSxPQUFPLDJCQUEyQjs7eUhBQTNCLDJCQUEyQjswSEFBM0IsMkJBQTJCLGlCQUpyQix3QkFBd0IsRUFBRSw4QkFBOEIsRUFBRSx5QkFBeUIsYUFDeEYsWUFBWSxFQUFFLGFBQWEsYUFDM0IsOEJBQThCOzBIQUUvQiwyQkFBMkIsWUFIMUIsWUFBWSxFQUFFLGFBQWE7NEZBRzVCLDJCQUEyQjtrQkFMdkMsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsRUFBRSw4QkFBOEIsRUFBRSx5QkFBeUIsQ0FBQztvQkFDbkcsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLGFBQWEsQ0FBQztvQkFDdEMsT0FBTyxFQUFFLENBQUMsOEJBQThCLENBQUM7aUJBQzVDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE9TaGFyZWRNb2R1bGUgfSBmcm9tICcuLi8uLi8uLi9zaGFyZWQvc2hhcmVkLm1vZHVsZSc7XG5pbXBvcnQgeyBPRGF0ZVJhbmdlTGVnYWN5SW5wdXRDb21wb25lbnQgfSBmcm9tICcuL28tZGF0ZXJhbmdlLWlucHV0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBPRGF0ZXJhbmdlcGlja2VyRGlyZWN0aXZlIH0gZnJvbSAnLi9vLWRhdGVyYW5nZS1pbnB1dC5kaXJlY3RpdmUnO1xuaW1wb3J0IHsgRGF0ZXJhbmdlcGlja2VyQ29tcG9uZW50IH0gZnJvbSAnLi9vLWRhdGVyYW5nZS1waWNrZXIuY29tcG9uZW50JztcblxuQE5nTW9kdWxlKHtcbiAgICBkZWNsYXJhdGlvbnM6IFtEYXRlcmFuZ2VwaWNrZXJDb21wb25lbnQsIE9EYXRlUmFuZ2VMZWdhY3lJbnB1dENvbXBvbmVudCwgT0RhdGVyYW5nZXBpY2tlckRpcmVjdGl2ZV0sXG4gICAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgT1NoYXJlZE1vZHVsZV0sXG4gICAgZXhwb3J0czogW09EYXRlUmFuZ2VMZWdhY3lJbnB1dENvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgT0RhdGVSYW5nZUxlZ2FjeUlucHV0TW9kdWxlIHsgfVxuIl19