slick-components 4.4.13 → 4.4.16

package/esm2020/slick-date-picker/slick-date-picker.component.mjs

@@ -0,0 +1,278 @@
+import { Component, ViewChild, Input, HostListener, forwardRef, EventEmitter, Output } from "@angular/core";
+import { NG_VALUE_ACCESSOR } from "@angular/forms";
+import { SlickSleepService } from "../utils/slick-sleep.service";
+import { SlickUtilsService } from "../utils/slick-utils.service";
+import * as moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../slick-calendar/slick-calendar.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+export class SlickDatePickerComponent {
+    constructor(el) {
+        this.el = el;
+        this.format = "M/D/YYYY";
+        this.condensed = false;
+        this.mobile = false;
+        this.onDateChange = new EventEmitter();
+        this.fnDocumentClick = (e) => this.documentClick(e);
+        this.fnDocumentMouseDown = (e) => this.documentMouseDown(e);
+        this.uuid = SlickUtilsService.newGuid();
+        this.ignoreBlur = false;
+        this.showDatePicker = false;
+        this.datePickerVisiblity = "hidden";
+        this.datePickerOpacity = '0';
+        this.selectedDate = null;
+        this.isInitial = true;
+        this.propagateChange = (_) => { };
+    }
+    // Make sure they only press valid keys
+    async onKeydown(event) {
+        if (event.altKey || event.ctrlKey || event.metaKey === true)
+            return;
+        this.hideCalendar();
+        // Allow: backspace, delete, tab, escape, enter
+        if ((event.keyCode === 46 || event.keyCode === 8) ||
+            (event.keyCode === 9 || event.keyCode === 27 || event.keyCode === 13) ||
+            // Allow F1-F12 keys
+            ((event.keyCode >= 112 && event.keyCode <= 123)) ||
+            // Allow: home, end, left, right, down, up
+            (event.keyCode >= 35 && event.keyCode <= 40)) {
+            // let it happen, don't do anything
+            return;
+        }
+        // Ensure that it is a number and stop the keypress
+        if ((event.shiftKey || event.altKey || event.key < '0' || event.key > '9') &&
+            event.key !== '/' && // Allow /
+            event.key !== '-') { // Allow -		
+            event.preventDefault();
+            return;
+        }
+    }
+    // When we first focus, show the date picker
+    onFocus(event) {
+        this.showCalendar();
+    }
+    // When we blur, update the model
+    async onBlur(event, targetElement) {
+        // If the user clicked on the calendar, it will trigger a mouse down event before the blur event.  Don't blur
+        // if they clicked on the calendar.
+        if (this.ignoreBlur === true) {
+            this.ignoreBlur = false;
+            return;
+        }
+        const textVal = this.el.nativeElement.value;
+        if (!textVal) {
+            this.doPropagate(null);
+            return;
+        }
+        if (moment(textVal, this.format).isValid()) {
+            var newDate = moment(textVal, this.format);
+            this.doPropagate(newDate.toDate());
+            this.el.nativeElement.value = newDate.format(this.format);
+        }
+    }
+    async ngOnInit() {
+        this.mobile = (this.mobile || 'false').toString().toLowerCase() === 'true' ? true : false;
+        this.condensed = (this.condensed || 'false').toString().toLowerCase() === 'true' ? true : false;
+        // Since this.mobile isn't necessarily defined yet, we need to sleep to allow the ngIf's to do their thing
+        await SlickSleepService.sleep();
+        // Remove this from the inline version and put it on the body so that it doesn't hide behind the bottom
+        // of a div when it expands beyond the bottom.
+        this.containerRef.nativeElement.remove(this.containerRef);
+        document.body.appendChild(this.containerRef.nativeElement);
+        await SlickSleepService.sleep();
+        this.inputGroupPrepend = SlickUtilsService.getClosestSibling(this.el.nativeElement, "input-group-prepend");
+    }
+    ngOnDestroy() {
+        document.removeEventListener("mousedown", this.fnDocumentMouseDown, true);
+        document.removeEventListener("click", this.fnDocumentClick, true);
+        // Is okay if this fails.  It just means it was already removed.
+        try {
+            document.body.removeChild(this.containerRef.nativeElement);
+        }
+        catch { }
+    }
+    doPropagate(date) {
+        // We don't always go through the emit on the first call, so make sure this isn't the first change
+        this.isInitial = false;
+        if (!date) {
+            if (this.selectedDate) {
+                this.propagateChange(null);
+                this.emitDateChange(null);
+            }
+            this.selectedDate = null;
+            return;
+        }
+        else {
+            const newDate = moment(date);
+            // If the date is not valid, return
+            if (newDate.isValid() === false)
+                return;
+            // Don't propogate if the dates are the same
+            if (moment(this.selectedDate).isSame(newDate))
+                return;
+            // Setting this selectedDate will trigger the ngModelChange of the calendar.  Ignore this.
+            this.selectedDate = moment(date).startOf("date").toDate();
+            this.propagateChange(this.selectedDate);
+            this.emitDateChange(this.selectedDate);
+        }
+    }
+    emitDateChange(date) {
+        if (this.onDateChange && !this.isInitial)
+            this.onDateChange.emit(date);
+        this.isInitial = false;
+    }
+    // this is the initial value set to the component
+    writeValue(obj) {
+        if (obj) {
+            if (moment(obj).isValid() === false) {
+                this.selectedDate = null;
+                this.el.nativeElement.value = "Invalid Date";
+                this.isInitial = false;
+                return;
+            }
+            let updatedDate;
+            if (obj instanceof Date || obj.indexOf("Z") >= 0)
+                updatedDate = moment(obj).startOf("date");
+            else
+                updatedDate = moment(obj, this.format).startOf("date");
+            if (moment(this.selectedDate || new Date()).isSame(updatedDate)) {
+                this.isInitial = false;
+                return;
+            }
+            this.selectedDate = updatedDate.toDate();
+            this.el.nativeElement.value = moment(this.selectedDate).format(this.format);
+        }
+        else {
+            if (!this.selectedDate && !obj) {
+                this.isInitial = false;
+                return;
+            }
+            this.el.nativeElement.value = '';
+            this.selectedDate = null;
+        }
+    }
+    // registers 'fn' that will be fired when changes are made
+    // this is how we emit the changes back to the form
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    // not used, used for touch input
+    registerOnTouched() { }
+    documentMouseDown(e) {
+        // This is the only way to capture that they clicked on the calendar before the blur event
+        // fires.  
+        if (SlickUtilsService.checkParentClassExists(e.target, "slick-calendar") === true)
+            this.ignoreBlur = true;
+    }
+    documentClick(e) {
+        if (!e.target)
+            return;
+        let targetElement = e.target;
+        if (SlickUtilsService.checkParentClassExists(targetElement, "slick-calendar") === true)
+            return;
+        if (this.inputGroupPrepend && ((targetElement === this.inputGroupPrepend)
+            || (targetElement.parentElement && targetElement.parentElement === this.inputGroupPrepend))
+            || (targetElement.parentElement && targetElement.parentElement.parentElement && targetElement.parentElement.parentElement === this.inputGroupPrepend)) {
+            this.toggleCalendar();
+            return;
+        }
+        const clickedInside = this.el.nativeElement.contains(targetElement);
+        if (!clickedInside) {
+            this.hideCalendar();
+        }
+    }
+    onDateSelect(date) {
+        this.el.nativeElement.value = moment(date).format(this.format);
+        this.hideCalendar();
+        const newDate = moment(this.el.nativeElement.value, this.format).toDate();
+        this.doPropagate(newDate);
+    }
+    async showCalendar() {
+        document.removeEventListener("mousedown", this.fnDocumentMouseDown, true);
+        document.removeEventListener("click", this.fnDocumentClick, true);
+        this.showDatePicker = true;
+        if (!this.mobile) {
+            this.reposition();
+        }
+        this.datePickerOpacity = '1';
+        this.datePickerVisiblity = 'visible';
+        // Not sure why, but the click event is called immediately, which hides the calendar
+        setTimeout(() => {
+            document.addEventListener("mousedown", this.fnDocumentMouseDown, true);
+            document.addEventListener("click", this.fnDocumentClick, true);
+        }, 350);
+    }
+    hideCalendar() {
+        document.removeEventListener("mousedown", this.fnDocumentMouseDown, true);
+        document.removeEventListener("click", this.fnDocumentClick, true);
+        this.datePickerVisiblity = 'hidden';
+        this.datePickerOpacity = '0';
+        this.showDatePicker = false;
+    }
+    reposition() {
+        if (this.mobile === true)
+            return;
+        // Reposition the element to be where the textbox is, either below or above if there isn't enough room
+        const inputEl = this.el.nativeElement;
+        const rect = inputEl.getBoundingClientRect();
+        const textboxLeft = rect.left;
+        const textboxTop = rect.top;
+        const textboxHeight = inputEl.offsetHeight;
+        const containerHeight = this.containerRef.nativeElement.offsetHeight;
+        this.left = textboxLeft + "px";
+        this.top = (textboxTop + textboxHeight) + "px";
+        if (textboxTop + textboxHeight + containerHeight > window.innerHeight) {
+            this.top = (textboxTop - containerHeight - 2) + "px";
+        }
+    }
+    toggleCalendar() {
+        (this.showDatePicker === true) ? this.hideCalendar() : this.showCalendar();
+    }
+}
+/** @nocollapse */ SlickDatePickerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerComponent, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickDatePickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickDatePickerComponent, selector: "[slick-date-picker]", inputs: { slickDatePicker: ["slick-date-picker", "slickDatePicker"], format: ["slick-date-picker-format", "format"], condensed: ["slick-date-picker-condensed", "condensed"], mobile: ["slick-date-picker-mobile", "mobile"] }, outputs: { onDateChange: "onDateChange" }, host: { listeners: { "keydown": "onKeydown($event)", "focus": "onFocus($event)", "blur": "onBlur($event,$event.target)" } }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef((() => SlickDatePickerComponent)),
+            multi: true
+        }
+    ], viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["containerRef"], descendants: true }], ngImport: i0, template: "<ng-content></ng-content>\r\n<div *ngIf=\"mobile === false\" #containerRef class=\"slick-date-picker-container\" [style.left]=\"left\" [style.top]=\"top\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n</div>\r\n<div *ngIf=\"mobile === true\" #containerRef class=\"slick-date-picker-mobile-container\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<div class=\"slick-date-picker-mobile-calendar\">\r\n\t\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n\t</div>\r\n</div>\r\n", components: [{ type: i1.SlickCalendarComponent, selector: "slick-calendar", inputs: ["condensed", "monthsToShow", "inactiveDates", "inactiveWeekends", "showDaysNotInMonth", "multiSelect", "multiSelectDates"], outputs: ["multiSelectDatesChange", "onDateSelect", "onDateChange", "onMonthChange", "onMultiDateChange"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i3.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: '[slick-date-picker]', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef((() => SlickDatePickerComponent)),
+                            multi: true
+                        }
+                    ], template: "<ng-content></ng-content>\r\n<div *ngIf=\"mobile === false\" #containerRef class=\"slick-date-picker-container\" [style.left]=\"left\" [style.top]=\"top\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n</div>\r\n<div *ngIf=\"mobile === true\" #containerRef class=\"slick-date-picker-mobile-container\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<div class=\"slick-date-picker-mobile-calendar\">\r\n\t\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n\t</div>\r\n</div>\r\n" }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { slickDatePicker: [{
+                type: Input,
+                args: ["slick-date-picker"]
+            }], format: [{
+                type: Input,
+                args: ["slick-date-picker-format"]
+            }], condensed: [{
+                type: Input,
+                args: ["slick-date-picker-condensed"]
+            }], mobile: [{
+                type: Input,
+                args: ["slick-date-picker-mobile"]
+            }], onDateChange: [{
+                type: Output,
+                args: ["onDateChange"]
+            }], containerRef: [{
+                type: ViewChild,
+                args: ["containerRef"]
+            }], onKeydown: [{
+                type: HostListener,
+                args: ['keydown', ['$event']]
+            }], onFocus: [{
+                type: HostListener,
+                args: ['focus', ['$event']]
+            }], onBlur: [{
+                type: HostListener,
+                args: ['blur', ['$event', '$event.target']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"slick-date-picker.component.js","sourceRoot":"","sources":["../../../../projects/components/src/slick-date-picker/slick-date-picker.component.ts","../../../../projects/components/src/slick-date-picker/slick-date-picker.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, ElementRef, ViewChild, Input, HostListener, forwardRef, OnInit, OnDestroy, EventEmitter, Output } from \"@angular/core\";\r\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from \"@angular/forms\";\r\nimport { SlickSleepService } from \"../utils/slick-sleep.service\";\r\nimport { SlickUtilsService } from \"../utils/slick-utils.service\";\r\nimport * as moment from 'moment';\r\n\r\n@Component({\r\n\tselector: '[slick-date-picker]',\r\n\tproviders: [\r\n\t\t{\r\n\t\t\tprovide: NG_VALUE_ACCESSOR,\r\n\t\t\tuseExisting: forwardRef(() => SlickDatePickerComponent),\r\n\t\t\tmulti: true\r\n\t\t}],\r\n\ttemplateUrl: 'slick-date-picker.component.html'\r\n})\r\nexport class SlickDatePickerComponent implements OnInit, OnDestroy, ControlValueAccessor {\r\n\t@Input(\"slick-date-picker\") slickDatePicker: SlickDatePickerComponent;\r\n\t@Input(\"slick-date-picker-format\") format: string = \"M/D/YYYY\";\r\n\t@Input(\"slick-date-picker-condensed\") condensed: boolean = false;\r\n\t@Input(\"slick-date-picker-mobile\") mobile: boolean = false;\r\n\t@Output(\"onDateChange\") onDateChange = new EventEmitter<Date>();\r\n\t@ViewChild(\"containerRef\") containerRef: ElementRef;\r\n\r\n\tfnDocumentClick = (e) => this.documentClick(e);\r\n\tfnDocumentMouseDown = (e) => this.documentMouseDown(e);\r\n\r\n\t// Make sure they only press valid keys\r\n\t@HostListener('keydown', ['$event'])\r\n\tasync onKeydown(event: KeyboardEvent) {\t\t\r\n\t\tif (event.altKey || event.ctrlKey || event.metaKey === true)\r\n\t\t\treturn;\r\n\r\n\t\tthis.hideCalendar();\r\n\r\n\t\t// Allow: backspace, delete, tab, escape, enter\r\n\t\tif ((event.keyCode === 46 || event.keyCode === 8) ||\r\n\t\t\t(event.keyCode === 9 || event.keyCode === 27 || event.keyCode === 13) ||\r\n\t\t\t// Allow F1-F12 keys\r\n\t\t\t((event.keyCode >= 112 && event.keyCode <= 123)) ||\r\n\t\t\t// Allow: home, end, left, right, down, up\r\n\t\t\t(event.keyCode >= 35 && event.keyCode <= 40)) {\r\n\t\t\t// let it happen, don't do anything\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\t// Ensure that it is a number and stop the keypress\r\n\t\tif ((event.shiftKey || event.altKey || event.key < '0' || event.key > '9') &&\r\n\t\t\tevent.key !== '/' &&  // Allow /\r\n\t\t\tevent.key !== '-') {  // Allow -\t\t\r\n\t\t\tevent.preventDefault();\r\n\t\t\treturn;\r\n\t\t}\r\n\t}\r\n\r\n\t// When we first focus, show the date picker\r\n\t@HostListener('focus', ['$event'])\r\n\tonFocus(event: FocusEvent): void {\r\n\t\tthis.showCalendar();\r\n\t}\r\n\r\n\t// When we blur, update the model\r\n\t@HostListener('blur', ['$event', '$event.target'])\r\n\tasync onBlur(event: FocusEvent, targetElement: HTMLElement) {\r\n\t\t// If the user clicked on the calendar, it will trigger a mouse down event before the blur event.  Don't blur\r\n\t\t// if they clicked on the calendar.\r\n\t\tif (this.ignoreBlur === true) {\r\n\t\t\tthis.ignoreBlur = false;\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst textVal = this.el.nativeElement.value;\r\n\r\n\t\tif (!textVal) {\r\n\t\t\tthis.doPropagate(null);\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tif (moment(textVal, this.format).isValid()) {\r\n\t\t\tvar newDate = moment(textVal, this.format);\r\n\t\t\tthis.doPropagate(newDate.toDate())\r\n\t\t\tthis.el.nativeElement.value = newDate.format(this.format);\r\n\t\t}\r\n\t}\r\n\r\n\tuuid: string = SlickUtilsService.newGuid();\r\n\tignoreBlur: boolean = false;\r\n\tshowDatePicker: boolean = false;\r\n\tdatePickerVisiblity: string = \"hidden\";\r\n\tdatePickerOpacity: string = '0';\r\n\tleft: string;\r\n\ttop: string;\r\n\tselectedDate: Date = null;\r\n\tisInitial = true;\r\n\r\n\tprivate inputGroupPrepend: HTMLElement;\r\n\r\n\tconstructor(private el: ElementRef) {\r\n\t}\r\n\r\n\tasync ngOnInit() {\r\n\r\n\t\tthis.mobile = (this.mobile || 'false').toString().toLowerCase() === 'true' ? true : false;\r\n\t\tthis.condensed = (this.condensed || 'false').toString().toLowerCase() === 'true' ? true : false;\r\n\r\n\t\t// Since this.mobile isn't necessarily defined yet, we need to sleep to allow the ngIf's to do their thing\r\n\t\tawait SlickSleepService.sleep();\r\n\t\t// Remove this from the inline version and put it on the body so that it doesn't hide behind the bottom\r\n\t\t// of a div when it expands beyond the bottom.\r\n\t\tthis.containerRef.nativeElement.remove(this.containerRef);\r\n\t\tdocument.body.appendChild(this.containerRef.nativeElement);\r\n\r\n\t\tawait SlickSleepService.sleep();\r\n\t\tthis.inputGroupPrepend = SlickUtilsService.getClosestSibling(this.el.nativeElement, \"input-group-prepend\");\r\n\t}\r\n\r\n\tngOnDestroy() {\r\n\t\tdocument.removeEventListener(\"mousedown\", this.fnDocumentMouseDown, true);\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\t// Is okay if this fails.  It just means it was already removed.\r\n\t\ttry {\r\n\t\t\tdocument.body.removeChild(this.containerRef.nativeElement);\r\n\t\t}\r\n\t\tcatch { }\r\n\t}\r\n\r\n\tpropagateChange = (_: any) => { };\r\n\r\n    private doPropagate(date: Date) {\r\n        // We don't always go through the emit on the first call, so make sure this isn't the first change\r\n        this.isInitial = false;\r\n\r\n\t\tif (!date) {\r\n\t\t\tif (this.selectedDate) {\r\n\t\t\t\tthis.propagateChange(null);\r\n\t\t\t\tthis.emitDateChange(null);\r\n\t\t\t}\r\n\r\n\t\t\tthis.selectedDate = null;\r\n\t\t\treturn;\r\n\t\t}\r\n\t\telse {\r\n\t\t\tconst newDate = moment(date);\r\n\t\t\t// If the date is not valid, return\r\n\t\t\tif (newDate.isValid() === false)\r\n\t\t\t\treturn;\r\n\r\n\t\t\t// Don't propogate if the dates are the same\r\n\t\t\tif (moment(this.selectedDate).isSame(newDate))\r\n\t\t\t\treturn;\r\n\r\n\r\n\t\t\t// Setting this selectedDate will trigger the ngModelChange of the calendar.  Ignore this.\r\n\t\t\tthis.selectedDate = moment(date).startOf(\"date\").toDate();\r\n\t\t\tthis.propagateChange(this.selectedDate);\r\n\t\t\tthis.emitDateChange(this.selectedDate);\r\n\t\t}\r\n\t}\r\n\r\n\tprivate emitDateChange(date: Date) {\r\n\t\tif (this.onDateChange && !this.isInitial)\r\n\t\t\tthis.onDateChange.emit(date);\r\n\r\n\t\tthis.isInitial = false;\r\n\t}\r\n\r\n\t// this is the initial value set to the component\r\n\tpublic writeValue(obj: any) {\r\n\t\tif (obj) {\r\n\t\t\tif (moment(obj).isValid() === false) {\r\n\t\t\t\tthis.selectedDate = null;\r\n                this.el.nativeElement.value = \"Invalid Date\";\r\n                this.isInitial = false;\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tlet updatedDate: moment.Moment;\r\n\t\t\tif (obj instanceof Date || obj.indexOf(\"Z\") >= 0)\r\n\t\t\t\tupdatedDate = moment(obj).startOf(\"date\");\r\n\t\t\telse\r\n\t\t\t\tupdatedDate = moment(obj, this.format).startOf(\"date\");\r\n\r\n            if (moment(this.selectedDate || new Date()).isSame(updatedDate)) {\r\n                this.isInitial = false;\r\n                return;\r\n            }\r\n\r\n\t\t\tthis.selectedDate = updatedDate.toDate();\r\n\t\t\tthis.el.nativeElement.value = moment(this.selectedDate).format(this.format);\r\n\t\t}\r\n\t\telse {\r\n            if (!this.selectedDate && !obj) {\r\n                this.isInitial = false;\r\n                return;\r\n            }\r\n\r\n\t\t\tthis.el.nativeElement.value = '';\r\n\t\t\tthis.selectedDate = null;\r\n\t\t}\r\n\t}\r\n\r\n\t// registers 'fn' that will be fired when changes are made\r\n\t// this is how we emit the changes back to the form\r\n\tpublic registerOnChange(fn: any) {\r\n\t\tthis.propagateChange = fn;\r\n\t}\r\n\r\n\t// not used, used for touch input\r\n\tpublic registerOnTouched() { }\r\n\r\n\tprivate documentMouseDown(e: MouseEvent) {\r\n\t\t// This is the only way to capture that they clicked on the calendar before the blur event\r\n\t\t// fires.  \r\n\t\tif (SlickUtilsService.checkParentClassExists(<HTMLElement>e.target, \"slick-calendar\") === true)\r\n\t\t\tthis.ignoreBlur = true;\r\n\t}\r\n\r\n\tprivate documentClick(e: MouseEvent) {\r\n\t\tif (!e.target)\r\n\t\t\treturn;\r\n\r\n\t\tlet targetElement: HTMLElement = (<HTMLElement>e.target);\r\n\r\n\t\tif (SlickUtilsService.checkParentClassExists(targetElement, \"slick-calendar\") === true)\r\n\t\t\treturn;\r\n\r\n\t\tif (this.inputGroupPrepend && ((targetElement === this.inputGroupPrepend)\r\n\t\t\t|| (targetElement.parentElement && targetElement.parentElement === this.inputGroupPrepend))\r\n\t\t\t|| (targetElement.parentElement && targetElement.parentElement.parentElement && targetElement.parentElement.parentElement === this.inputGroupPrepend)) {\r\n\t\t\tthis.toggleCalendar();\r\n\t\t\treturn;\r\n\t\t}\r\n\r\n\t\tconst clickedInside = this.el.nativeElement.contains(targetElement);\r\n\t\tif (!clickedInside) {\r\n\t\t\tthis.hideCalendar();\r\n\t\t}\r\n\t}\r\n\r\n\tonDateSelect(date) {\r\n\t\tthis.el.nativeElement.value = moment(date).format(this.format);\r\n\t\tthis.hideCalendar();\r\n\r\n\t\tconst newDate = moment(this.el.nativeElement.value, this.format).toDate();\r\n\r\n\t\tthis.doPropagate(newDate);\t\t\r\n\t}\r\n\r\n\tasync showCalendar() {\r\n\t\tdocument.removeEventListener(\"mousedown\", this.fnDocumentMouseDown, true);\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\r\n\t\tthis.showDatePicker = true;\r\n\r\n\t\tif (!this.mobile) {\r\n\t\t\tthis.reposition();\r\n\t\t}\r\n\r\n\t\tthis.datePickerOpacity = '1';\r\n\t\tthis.datePickerVisiblity = 'visible';\r\n\r\n\t\t// Not sure why, but the click event is called immediately, which hides the calendar\r\n\t\tsetTimeout(() => {\r\n\t\t\tdocument.addEventListener(\"mousedown\", this.fnDocumentMouseDown, true);\r\n\t\t\tdocument.addEventListener(\"click\", this.fnDocumentClick, true);\r\n\t\t}, 350)\r\n\t}\r\n\r\n\thideCalendar() {\r\n\t\tdocument.removeEventListener(\"mousedown\", this.fnDocumentMouseDown, true);\r\n\t\tdocument.removeEventListener(\"click\", this.fnDocumentClick, true);\r\n\r\n\t\tthis.datePickerVisiblity = 'hidden';\r\n\t\tthis.datePickerOpacity = '0';\r\n\t\tthis.showDatePicker = false;\r\n\t}\r\n\r\n\tprivate reposition() {\r\n\t\tif (this.mobile === true)\r\n\t\t\treturn;\r\n\r\n\t\t// Reposition the element to be where the textbox is, either below or above if there isn't enough room\r\n\t\tconst inputEl: HTMLInputElement = this.el.nativeElement;\r\n\r\n\t\tconst rect = inputEl.getBoundingClientRect();\r\n\t\tconst textboxLeft = rect.left;\r\n\t\tconst textboxTop = rect.top;\r\n\t\tconst textboxHeight = inputEl.offsetHeight;\r\n\t\tconst containerHeight = (<HTMLDivElement>this.containerRef.nativeElement).offsetHeight;\r\n\r\n\t\tthis.left = textboxLeft + \"px\";\r\n\t\tthis.top = (textboxTop + textboxHeight) + \"px\";\r\n\r\n\t\tif (textboxTop + textboxHeight + containerHeight > window.innerHeight) {\r\n\t\t\tthis.top = (textboxTop - containerHeight - 2) + \"px\";\r\n\t\t}\r\n\r\n\t}\r\n\r\n\ttoggleCalendar() {\r\n\t\t(this.showDatePicker === true) ? this.hideCalendar() : this.showCalendar();\r\n\t}\r\n}","<ng-content></ng-content>\r\n<div *ngIf=\"mobile === false\" #containerRef class=\"slick-date-picker-container\" [style.left]=\"left\" [style.top]=\"top\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n</div>\r\n<div *ngIf=\"mobile === true\" #containerRef class=\"slick-date-picker-mobile-container\" [style.visibility]=\"datePickerVisiblity\" [style.opacity]=\"datePickerOpacity\">\r\n\t<div class=\"slick-date-picker-mobile-calendar\">\r\n\t\t<slick-calendar [ngModel]=\"selectedDate\" [condensed]=\"condensed\" (onDateSelect)=\"onDateSelect($event)\"></slick-calendar>\r\n\t</div>\r\n</div>\r\n"]}

package/esm2020/slick-date-picker/slick-date-picker.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { FormsModule } from '@angular/forms';
+import { SlickDatePickerComponent } from "./slick-date-picker.component";
+import { SlickCalendarModule } from "../slick-calendar/slick-calendar.module";
+import * as i0 from "@angular/core";
+export class SlickDatePickerModule {
+}
+/** @nocollapse */ SlickDatePickerModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ SlickDatePickerModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerModule, declarations: [SlickDatePickerComponent], imports: [CommonModule, FormsModule, SlickCalendarModule], exports: [SlickDatePickerComponent, SlickCalendarModule] });
+/** @nocollapse */ SlickDatePickerModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerModule, imports: [[CommonModule, FormsModule, SlickCalendarModule], SlickCalendarModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDatePickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, FormsModule, SlickCalendarModule],
+                    declarations: [SlickDatePickerComponent],
+                    exports: [SlickDatePickerComponent, SlickCalendarModule]
+                }]
+        }] });
+export { SlickDatePickerComponent };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZGF0ZS1waWNrZXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvY29tcG9uZW50cy9zcmMvc2xpY2stZGF0ZS1waWNrZXIvc2xpY2stZGF0ZS1waWNrZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsd0JBQXdCLEVBQUUsTUFBTSwrQkFBK0IsQ0FBQztBQUN6RSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5Q0FBeUMsQ0FBQzs7QUFPOUUsTUFBTSxPQUFPLHFCQUFxQjs7cUlBQXJCLHFCQUFxQjtzSUFBckIscUJBQXFCLGlCQUhsQix3QkFBd0IsYUFEN0IsWUFBWSxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsYUFFOUMsd0JBQXdCLEVBQUUsbUJBQW1CO3NJQUUzQyxxQkFBcUIsWUFKeEIsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLG1CQUFtQixDQUFDLEVBRXJCLG1CQUFtQjsyRkFFM0MscUJBQXFCO2tCQUxqQyxRQUFRO21CQUFDO29CQUNULE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsbUJBQW1CLENBQUM7b0JBQ3pELFlBQVksRUFBRSxDQUFDLHdCQUF3QixDQUFDO29CQUN4QyxPQUFPLEVBQUUsQ0FBQyx3QkFBd0IsRUFBRSxtQkFBbUIsQ0FBQztpQkFDeEQ7O0FBR0QsT0FBTyxFQUFFLHdCQUF3QixFQUFFLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gXCJAYW5ndWxhci9jb21tb25cIjtcclxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcbmltcG9ydCB7IFNsaWNrRGF0ZVBpY2tlckNvbXBvbmVudCB9IGZyb20gXCIuL3NsaWNrLWRhdGUtcGlja2VyLmNvbXBvbmVudFwiO1xyXG5pbXBvcnQgeyBTbGlja0NhbGVuZGFyTW9kdWxlIH0gZnJvbSBcIi4uL3NsaWNrLWNhbGVuZGFyL3NsaWNrLWNhbGVuZGFyLm1vZHVsZVwiO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuXHRpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZSwgU2xpY2tDYWxlbmRhck1vZHVsZV0sXHJcblx0ZGVjbGFyYXRpb25zOiBbU2xpY2tEYXRlUGlja2VyQ29tcG9uZW50XSxcclxuXHRleHBvcnRzOiBbU2xpY2tEYXRlUGlja2VyQ29tcG9uZW50LCBTbGlja0NhbGVuZGFyTW9kdWxlXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgU2xpY2tEYXRlUGlja2VyTW9kdWxlIHsgfVxyXG5cclxuZXhwb3J0IHsgU2xpY2tEYXRlUGlja2VyQ29tcG9uZW50IH0iXX0=

package/esm2020/slick-dialog/slick-dialog-footer.component.mjs

@@ -0,0 +1,24 @@
+import { Component, HostBinding } from "@angular/core";
+import * as i0 from "@angular/core";
+export class SlickDialogFooterComponent {
+    constructor() {
+        this.flex = '1 1';
+        this.textAlign = 'center';
+    }
+}
+/** @nocollapse */ SlickDialogFooterComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDialogFooterComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ SlickDialogFooterComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.3", type: SlickDialogFooterComponent, selector: "slick-dialog-footer", host: { properties: { "style.flex": "this.flex", "style.textAlign": "this.textAlign" } }, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.3", ngImport: i0, type: SlickDialogFooterComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'slick-dialog-footer',
+                    template: `<ng-content></ng-content>`
+                }]
+        }], propDecorators: { flex: [{
+                type: HostBinding,
+                args: ['style.flex']
+            }], textAlign: [{
+                type: HostBinding,
+                args: ['style.textAlign']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2xpY2stZGlhbG9nLWZvb3Rlci5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9jb21wb25lbnRzL3NyYy9zbGljay1kaWFsb2cvc2xpY2stZGlhbG9nLWZvb3Rlci5jb21wb25lbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxXQUFXLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBTXZELE1BQU0sT0FBTywwQkFBMEI7SUFKdkM7UUFLNEIsU0FBSSxHQUFHLEtBQUssQ0FBQztRQUNSLGNBQVMsR0FBRyxRQUFRLENBQUM7S0FDckQ7OzBJQUhZLDBCQUEwQjs4SEFBMUIsMEJBQTBCLHFKQUY1QiwyQkFBMkI7MkZBRXpCLDBCQUEwQjtrQkFKdEMsU0FBUzttQkFBQztvQkFDVixRQUFRLEVBQUUscUJBQXFCO29CQUMvQixRQUFRLEVBQUUsMkJBQTJCO2lCQUNyQzs4QkFFMkIsSUFBSTtzQkFBOUIsV0FBVzt1QkFBQyxZQUFZO2dCQUNPLFNBQVM7c0JBQXhDLFdBQVc7dUJBQUMsaUJBQWlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tcG9uZW50LCBIb3N0QmluZGluZyB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuXHRzZWxlY3RvcjogJ3NsaWNrLWRpYWxvZy1mb290ZXInLFxyXG5cdHRlbXBsYXRlOiBgPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PmBcclxufSlcclxuZXhwb3J0IGNsYXNzIFNsaWNrRGlhbG9nRm9vdGVyQ29tcG9uZW50IHtcclxuXHRASG9zdEJpbmRpbmcoJ3N0eWxlLmZsZXgnKSBmbGV4ID0gJzEgMSc7XHJcblx0QEhvc3RCaW5kaW5nKCdzdHlsZS50ZXh0QWxpZ24nKSB0ZXh0QWxpZ24gPSAnY2VudGVyJztcclxufVxyXG4iXX0=