mis-crystal-design-system 2.9.9 → 3.0.0

package/esm2015/timepicker/timepicker.component.js

@@ -0,0 +1,189 @@
+import { Component, EventEmitter, Input, Output, ViewChild, ViewChildren } from "@angular/core";
+import * as moment from "moment-timezone";
+import { TimepickerDirective } from "./timepicker.directive";
+export class TimePickerComponent {
+    constructor() {
+        this.openStatus = false;
+        this.isHighlighted = 0;
+        this.isInvalid = false;
+        this.timeIntervals = [];
+        this.shouldScroll = false;
+        this.userInputFlag = false;
+        this.clockFormat = 12;
+        this.timezone = "Asia/Kolkata";
+        this.height = "max-content";
+        this.inputWidth = "100px";
+        this.interval = 15;
+        this.dateAsEpoch = moment().valueOf();
+        this.rangeValidity = true;
+        this.timeEmitter = new EventEmitter();
+    }
+    // gets all the li elements from the dropdown and scrolls to the highlighted element
+    set timeIntervalRefs(intervals) {
+        intervals.forEach(interval => {
+            if (interval.nativeElement.classList[0] === "highlight") {
+                const highlighted = interval.nativeElement;
+                setTimeout(() => highlighted.scrollIntoView({ behavior: "smooth", block: "center" }));
+            }
+        });
+    }
+    ngOnInit() {
+        this.timeFormat = this.clockFormat === 12 ? "hh:mm a" : "HH:mm";
+        this.populateDropdown();
+        this.chosenTime = this.timeIntervals[0];
+        this.calculateClosestInterval(this.chosenTime);
+        this.emitTime({
+            valid: !this.isInvalid,
+            time: this.chosenTime
+        });
+    }
+    ngOnChanges() {
+        moment.tz.setDefault(this.timezone);
+        this.currTime = moment().format();
+        if (this.timeFormat) {
+            // if the first interval is >= the chosen time
+            // then only update the value of chosen time
+            // else it remains the same
+            const chosenTimeMoment = moment(`${moment(this.dateAsEpoch).format("DD-MM-YYYY")} ${this.chosenTime}`, `'DD-MM-YYYY' ${this.timeFormat}`);
+            if (this.firstInterval >= chosenTimeMoment.valueOf() && this.rangeValidity && !this.userInputFlag) {
+                this.chosenTime = moment(this.firstInterval).format(this.timeFormat);
+            }
+            if (!this.userInputFlag)
+                this.populateDropdown();
+            this.userInputFlag = false;
+            this.isInvalid = !this.checkTimeValidity(this.chosenTime.trim());
+            this.emitTime({
+                valid: !this.isInvalid,
+                time: this.chosenTime
+            });
+            this.calculateClosestInterval(this.chosenTime);
+        }
+    }
+    emitTime(data) {
+        this.timeEmitter.emit(data);
+    }
+    // gets a boolean from overlay event to close the dropdown
+    closeDropdown(val) {
+        this.openStatus = val;
+    }
+    // toggle timepicker dropdown
+    openDropdown() {
+        this.openStatus = true;
+    }
+    checkTimeValidity(time) {
+        const RE12 = /^(([0-9][1-9]|1[0-2]):([0-5][0-9])( )?(am|pm|AM|PM))$/i;
+        const RE24 = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
+        const RE = this.clockFormat === 12 ? RE12 : RE24;
+        const timeMoment = moment(`${moment(this.dateAsEpoch).format("DD-MM-YYYY")} ${time}`, `'DD-MM-YYYY' ${this.timeFormat}`);
+        let flag = false;
+        // if the first interval is set to the start of the day
+        // then we don't check its validity against the current time
+        if (this.firstInterval &&
+            moment(this.firstInterval).format(this.timeFormat).valueOf() === moment().startOf("d").format(this.timeFormat).valueOf()) {
+            flag = time.match(RE) ? true : false;
+        }
+        else {
+            flag = time.match(RE) && timeMoment.isAfter(moment());
+        }
+        return flag;
+    }
+    // update chosen time as soon as the user clicks on an interval
+    onTimeSelect(time) {
+        this.isInvalid = !this.checkTimeValidity(time.trim());
+        if (!this.isInvalid) {
+            this.chosenTime = time;
+            this.calculateClosestInterval(this.chosenTime);
+        }
+        this.emitTime({
+            valid: !this.isInvalid,
+            time: time
+        });
+        this.openStatus = false;
+        if (this.timepickerDirective)
+            this.timepickerDirective.destroyOverlay();
+    }
+    // checks validity of time on input change and calculates the closest interval
+    onTimeChange(time) {
+        this.isInvalid = !this.checkTimeValidity(time.trim());
+        if (!this.isInvalid) {
+            this.userInputFlag = true;
+            this.calculateClosestInterval(time);
+        }
+        this.emitTime({
+            valid: !this.isInvalid,
+            time: time
+        });
+    }
+    calculateClosestInterval(time) {
+        const intervalMS = this.interval * 60 * 1000;
+        const chosenDate = moment(this.dateAsEpoch).format("DD-MM-YYYY");
+        // converting time passed as parameter to moment object and adding date
+        const parsedTimeWithDate = moment(`${chosenDate} ${time}`, `DD-MM-YYYY ${this.timeFormat}`);
+        // converting moment object to epoch so that calculations for rounding off are easier to do
+        const currEpoch = parsedTimeWithDate.valueOf();
+        const offset = currEpoch % intervalMS;
+        const roundedEpoch = offset >= intervalMS / 2 ? currEpoch + (intervalMS - offset) : currEpoch - offset;
+        // finding the index of element that needs to be highlighted
+        this.timeIntervals.forEach((interval, index, array) => {
+            const intervalObj = moment(`${chosenDate} ${interval}`, `DD-MM-YYYY ${this.timeFormat}`);
+            if (intervalObj.valueOf() === roundedEpoch)
+                this.isHighlighted = index;
+            if (array.length === 1)
+                this.isHighlighted = 0;
+        });
+    }
+    // populates the dropdown according to the first interval received
+    populateDropdown() {
+        this.timeIntervals = [];
+        // if picker is used as an individual component
+        if (!this.firstInterval) {
+            // firstInterval is initialised according to the current time
+            // if the date is same as the current date
+            if (moment(this.dateAsEpoch).format("DD-MM-YYYY") === moment().format("DD-MM-YYYY")) {
+                const offset = this.interval - (moment().minutes() % this.interval);
+                this.firstInterval = moment().add(offset, "m").valueOf();
+            }
+            // else the firstInterval is initialised as start of day
+            else {
+                this.firstInterval = moment().startOf("d").valueOf();
+            }
+        }
+        const start = moment(this.firstInterval);
+        const end = moment().endOf("d");
+        while (start.valueOf() < end.valueOf()) {
+            this.timeIntervals.push(start.format(this.timeFormat));
+            start.add(this.interval, "m");
+        }
+        // if the start time is equal to the interval just before midnight
+        // and the start date = end date
+        // push 11:59pm only
+        if (this.timeIntervals.length === 0) {
+            this.chosenTime = moment().endOf("d").format(this.timeFormat);
+            this.timeIntervals.push(moment().endOf("d").format(this.timeFormat));
+        }
+    }
+}
+TimePickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: "mis-timepicker",
+                template: "<div class=\"timepicker-container\" [ngStyle]=\"{ height: height }\">\n  <input\n    type=\"text\"\n    [(ngModel)]=\"chosenTime\"\n    (ngModelChange)=\"onTimeChange(chosenTime)\"\n    [ngClass]=\"{ invalid: isInvalid || !rangeValidity }\"\n    [ngStyle]=\"{ width: inputWidth }\"\n    (click)=\"openDropdown()\"\n    misToolTip\n    [showToolTip]=\"isInvalid || !rangeValidity\"\n    [text]=\"'Invalid Time'\"\n    [position]=\"'top'\"\n    [showOnHover]=\"false\"\n    #input\n    cdkOverlayOrigin\n    class=\"p\"\n  />\n\n  <ng-template #dropdownContainer libDropdownScroll libTimepicker [originEl]=\"input\" [openStatus]=\"openStatus\" (statusEmitter)=\"closeDropdown($event)\">\n    <div *ngIf=\"openStatus\" class=\"timepicker-dropdown\" [ngStyle]=\"{ width: dropdownWidth || inputWidth }\">\n      <ul #dropdown>\n        <li #timeInterval (click)=\"onTimeSelect(interval)\" *ngFor=\"let interval of timeIntervals; index as i\" [ngClass]=\"{ highlight: i === isHighlighted }\">\n          {{ interval }}\n          <div class=\"ic-ui-check-24 selected-icon\" *ngIf=\"interval === chosenTime\"></div>\n        </li>\n      </ul>\n    </div>\n  </ng-template>\n</div>\n",
+                styles: [".h1{font-size:40px;line-height:48px}.h1,.h2{font-weight:400;letter-spacing:0}.h2{font-size:32px;line-height:40px}.h3{font-size:28px;line-height:36px}.h3,.h4{font-weight:400;letter-spacing:0}.h4{font-size:24px;line-height:32px}.h5-b{font-weight:700;letter-spacing:.25px}.h5,.h5-b{font-size:20px;line-height:28px}.h5{font-weight:400;letter-spacing:.15px}.h6-b{font-weight:700}.h6,.h6-b{font-size:16px;letter-spacing:0;line-height:24px}.h6,.p{font-weight:400}.p{font-size:16px;letter-spacing:0;line-height:180%}.h7-b{font-weight:700;letter-spacing:.25px}.h7,.h7-b{font-size:14px;line-height:20px}.h7{font-weight:400;letter-spacing:.2px}.h8-b{font-weight:700;letter-spacing:.25px}.h8,.h8-b{font-size:12px;line-height:18px}.h8{letter-spacing:.2px}.h8,.h9{font-weight:400}.h9{font-size:10px;letter-spacing:0;line-height:15px}.btn-lg-b{font-weight:700;letter-spacing:.5px}.btn-lg,.btn-lg-b{font-size:16px;line-height:24px}.btn-lg{font-weight:400;letter-spacing:.2px}.btn-sm{font-size:14px;font-weight:400;letter-spacing:.25px;line-height:20px}.btn-link{font-size:16px;line-height:24px}.btn-link,.display-1{font-weight:400;letter-spacing:0}.display-1{font-size:48px;line-height:56px}.display-2{font-size:14px;font-weight:400;letter-spacing:.5px;line-height:20px}*{box-sizing:border-box;font-family:Lato}.timepicker-container{display:inline-block;position:relative}input{text-align:center;border:none;border-bottom:1px solid #e0e0e0;outline:none;height:100%;width:100px;padding:4px 16px}input:hover{background:#f5f7fc}input:active,input:focus{background:#e6ebf7;border-bottom:1px solid #0937b2}.timepicker-dropdown{position:absolute;top:calc(100% + 4px);left:0;max-height:200px;overflow-y:auto;border:1px solid #e0e0e0;box-shadow:0 12px 24px rgba(0,0,0,.12),0 4px 8px rgba(0,0,0,.12);border-radius:4px;padding:8px;background:#fff}.timepicker-dropdown::-webkit-scrollbar{display:none}.timepicker-dropdown ul{margin:0;padding:0}.timepicker-dropdown li{text-align:start;list-style:none;padding:6px 12px;cursor:pointer;font-size:16px;color:#181f33;display:flex;justify-content:space-between;align-items:center}.timepicker-dropdown li:hover{background:#f5f7fc;border-radius:6px}.timepicker-dropdown li .selected-icon{font-weight:900}.highlight{background-color:#f5f7fc;border-radius:6px}.invalid{background:#fae1ea!important;border-bottom:1px solid #b00020!important}"]
+            },] }
+];
+TimePickerComponent.ctorParameters = () => [];
+TimePickerComponent.propDecorators = {
+    clockFormat: [{ type: Input }],
+    timezone: [{ type: Input }],
+    height: [{ type: Input }],
+    inputWidth: [{ type: Input }],
+    dropdownWidth: [{ type: Input }],
+    interval: [{ type: Input }],
+    dateAsEpoch: [{ type: Input }],
+    firstInterval: [{ type: Input }],
+    rangeValidity: [{ type: Input }],
+    timeEmitter: [{ type: Output }],
+    input: [{ type: ViewChild, args: ["input", { static: true },] }],
+    timepickerDirective: [{ type: ViewChild, args: [TimepickerDirective,] }],
+    timeIntervalRefs: [{ type: ViewChildren, args: ["timeInterval",] }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timepicker.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/timepicker/timepicker.component.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAc,YAAY,EAAE,KAAK,EAAE,MAAM,EAA0B,SAAS,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AACpI,OAAO,KAAK,MAAM,MAAM,iBAAiB,CAAC;AAE1C,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAO7D,MAAM,OAAO,mBAAmB;IAoC9B;QAjCA,eAAU,GAAY,KAAK,CAAC;QAC5B,kBAAa,GAAW,CAAC,CAAC;QAC1B,cAAS,GAAY,KAAK,CAAC;QAC3B,kBAAa,GAAa,EAAE,CAAC;QAC7B,iBAAY,GAAY,KAAK,CAAC;QAC9B,kBAAa,GAAY,KAAK,CAAC;QAEtB,gBAAW,GAAW,EAAE,CAAC;QAGzB,aAAQ,GAAW,cAAc,CAAC;QAClC,WAAM,GAAW,aAAa,CAAC;QAC/B,eAAU,GAAW,OAAO,CAAC;QAE7B,aAAQ,GAAW,EAAE,CAAC;QACtB,gBAAW,GAAW,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC;QAEzC,kBAAa,GAAY,IAAI,CAAC;QAE7B,gBAAW,GAAG,IAAI,YAAY,EAAS,CAAC;IAcnC,CAAC;IAVhB,oFAAoF;IACpF,IAAkC,gBAAgB,CAAC,SAAS;QAC1D,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE;YAC3B,IAAI,QAAQ,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,WAAW,EAAE;gBACvD,MAAM,WAAW,GAAG,QAAQ,CAAC,aAAa,CAAC;gBAC3C,UAAU,CAAC,GAAG,EAAE,CAAC,WAAW,CAAC,cAAc,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC;aACvF;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAGD,QAAQ;QACN,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC;QAChE,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACxB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;QACxC,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC;YACZ,KAAK,EAAE,CAAC,IAAI,CAAC,SAAS;YACtB,IAAI,EAAE,IAAI,CAAC,UAAU;SACtB,CAAC,CAAC;IACL,CAAC;IAED,WAAW;QACT,MAAM,CAAC,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACpC,IAAI,CAAC,QAAQ,GAAG,MAAM,EAAE,CAAC,MAAM,EAAE,CAAC;QAClC,IAAI,IAAI,CAAC,UAAU,EAAE;YACnB,8CAA8C;YAC9C,4CAA4C;YAC5C,2BAA2B;YAC3B,MAAM,gBAAgB,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,IAAI,CAAC,UAAU,EAAE,EAAE,gBAAgB,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YAE1I,IAAI,IAAI,CAAC,aAAa,IAAI,gBAAgB,CAAC,OAAO,EAAE,IAAI,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;gBACjG,IAAI,CAAC,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;aACtE;YACD,IAAI,CAAC,IAAI,CAAC,aAAa;gBAAE,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACjD,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YAC3B,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,CAAC,CAAC;YACjE,IAAI,CAAC,QAAQ,CAAC;gBACZ,KAAK,EAAE,CAAC,IAAI,CAAC,SAAS;gBACtB,IAAI,EAAE,IAAI,CAAC,UAAU;aACtB,CAAC,CAAC;YACH,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAChD;IACH,CAAC;IAED,QAAQ,CAAC,IAAW;QAClB,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,0DAA0D;IAC1D,aAAa,CAAC,GAAY;QACxB,IAAI,CAAC,UAAU,GAAG,GAAG,CAAC;IACxB,CAAC;IAED,6BAA6B;IAC7B,YAAY;QACV,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;IACzB,CAAC;IAED,iBAAiB,CAAC,IAAY;QAC5B,MAAM,IAAI,GAAG,wDAAwD,CAAC;QACtE,MAAM,IAAI,GAAG,iCAAiC,CAAC;QAC/C,MAAM,EAAE,GAAG,IAAI,CAAC,WAAW,KAAK,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;QAEjD,MAAM,UAAU,GAAG,MAAM,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,IAAI,EAAE,EAAE,gBAAgB,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QACzH,IAAI,IAAI,GAAY,KAAK,CAAC;QAE1B,uDAAuD;QACvD,4DAA4D;QAC5D,IACE,IAAI,CAAC,aAAa;YAClB,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,KAAK,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,OAAO,EAAE,EACxH;YACA,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC;SACtC;aAAM;YACL,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;SACvD;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,+DAA+D;IAC/D,YAAY,CAAC,IAAY;QACvB,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;SAChD;QACD,IAAI,CAAC,QAAQ,CAAC;YACZ,KAAK,EAAE,CAAC,IAAI,CAAC,SAAS;YACtB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;QACH,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;QACxB,IAAI,IAAI,CAAC,mBAAmB;YAAE,IAAI,CAAC,mBAAmB,CAAC,cAAc,EAAE,CAAC;IAC1E,CAAC;IAED,8EAA8E;IAC9E,YAAY,CAAC,IAAY;QACvB,IAAI,CAAC,SAAS,GAAG,CAAC,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACtD,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;YACnB,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;YAC1B,IAAI,CAAC,wBAAwB,CAAC,IAAI,CAAC,CAAC;SACrC;QACD,IAAI,CAAC,QAAQ,CAAC;YACZ,KAAK,EAAE,CAAC,IAAI,CAAC,SAAS;YACtB,IAAI,EAAE,IAAI;SACX,CAAC,CAAC;IACL,CAAC;IAED,wBAAwB,CAAC,IAAY;QACnC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,GAAG,EAAE,GAAG,IAAI,CAAC;QAC7C,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC;QAEjE,uEAAuE;QACvE,MAAM,kBAAkB,GAAG,MAAM,CAAC,GAAG,UAAU,IAAI,IAAI,EAAE,EAAE,cAAc,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;QAE5F,2FAA2F;QAC3F,MAAM,SAAS,GAAG,kBAAkB,CAAC,OAAO,EAAE,CAAC;QAE/C,MAAM,MAAM,GAAG,SAAS,GAAG,UAAU,CAAC;QACtC,MAAM,YAAY,GAAG,MAAM,IAAI,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,SAAS,GAAG,MAAM,CAAC;QAEvG,4DAA4D;QAC5D,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;YACpD,MAAM,WAAW,GAAG,MAAM,CAAC,GAAG,UAAU,IAAI,QAAQ,EAAE,EAAE,cAAc,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC;YACzF,IAAI,WAAW,CAAC,OAAO,EAAE,KAAK,YAAY;gBAAE,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC;YACvE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,IAAI,CAAC,aAAa,GAAG,CAAC,CAAC;QACjD,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kEAAkE;IAClE,gBAAgB;QACd,IAAI,CAAC,aAAa,GAAG,EAAE,CAAC;QAExB,+CAA+C;QAC/C,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE;YACvB,6DAA6D;YAC7D,0CAA0C;YAC1C,IAAI,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,KAAK,MAAM,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,EAAE;gBACnF,MAAM,MAAM,GAAG,IAAI,CAAC,QAAQ,GAAG,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACpE,IAAI,CAAC,aAAa,GAAG,MAAM,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;aAC1D;YAED,wDAAwD;iBACnD;gBACH,IAAI,CAAC,aAAa,GAAG,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,CAAC;aACtD;SACF;QAED,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QACzC,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QAEhC,OAAO,KAAK,CAAC,OAAO,EAAE,GAAG,GAAG,CAAC,OAAO,EAAE,EAAE;YACtC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;YACvD,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;SAC/B;QAED,kEAAkE;QAClE,gCAAgC;QAChC,oBAAoB;QACpB,IAAI,IAAI,CAAC,aAAa,CAAC,MAAM,KAAK,CAAC,EAAE;YACnC,IAAI,CAAC,UAAU,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAC9D,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;SACtE;IACH,CAAC;;;YAnMF,SAAS,SAAC;gBACT,QAAQ,EAAE,gBAAgB;gBAC1B,oqCAA0C;;aAE3C;;;;0BAWE,KAAK;uBAGL,KAAK;qBACL,KAAK;yBACL,KAAK;4BACL,KAAK;uBACL,KAAK;0BACL,KAAK;4BACL,KAAK;4BACL,KAAK;0BAEL,MAAM;oBACN,SAAS,SAAC,OAAO,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE;kCACnC,SAAS,SAAC,mBAAmB;+BAG7B,YAAY,SAAC,cAAc","sourcesContent":["import { Component, ElementRef, EventEmitter, Input, Output, QueryList, TemplateRef, ViewChild, ViewChildren } from \"@angular/core\";\nimport * as moment from \"moment-timezone\";\nimport { ITime } from \"./time.namespace\";\nimport { TimepickerDirective } from \"./timepicker.directive\";\n\n@Component({\n  selector: \"mis-timepicker\",\n  templateUrl: \"./timepicker.component.html\",\n  styleUrls: [\"./timepicker.component.scss\"]\n})\nexport class TimePickerComponent {\n  currTime!: string;\n  chosenTime: string;\n  openStatus: boolean = false;\n  isHighlighted: number = 0;\n  isInvalid: boolean = false;\n  timeIntervals: string[] = [];\n  shouldScroll: boolean = false;\n  userInputFlag: boolean = false;\n\n  @Input() clockFormat: number = 12;\n  timeFormat!: string;\n\n  @Input() timezone: string = \"Asia/Kolkata\";\n  @Input() height: string = \"max-content\";\n  @Input() inputWidth: string = \"100px\";\n  @Input() dropdownWidth?: string;\n  @Input() interval: number = 15;\n  @Input() dateAsEpoch: number = moment().valueOf();\n  @Input() firstInterval!: number;\n  @Input() rangeValidity: boolean = true;\n\n  @Output() timeEmitter = new EventEmitter<ITime>();\n  @ViewChild(\"input\", { static: true }) input: ElementRef;\n  @ViewChild(TimepickerDirective) timepickerDirective: TimepickerDirective;\n\n  // gets all the li elements from the dropdown and scrolls to the highlighted element\n  @ViewChildren(\"timeInterval\") set timeIntervalRefs(intervals) {\n    intervals.forEach(interval => {\n      if (interval.nativeElement.classList[0] === \"highlight\") {\n        const highlighted = interval.nativeElement;\n        setTimeout(() => highlighted.scrollIntoView({ behavior: \"smooth\", block: \"center\" }));\n      }\n    });\n  }\n\n  constructor() {}\n  ngOnInit(): void {\n    this.timeFormat = this.clockFormat === 12 ? \"hh:mm a\" : \"HH:mm\";\n    this.populateDropdown();\n    this.chosenTime = this.timeIntervals[0];\n    this.calculateClosestInterval(this.chosenTime);\n    this.emitTime({\n      valid: !this.isInvalid,\n      time: this.chosenTime\n    });\n  }\n\n  ngOnChanges(): void {\n    moment.tz.setDefault(this.timezone);\n    this.currTime = moment().format();\n    if (this.timeFormat) {\n      // if the first interval is >= the chosen time\n      // then only update the value of chosen time\n      // else it remains the same\n      const chosenTimeMoment = moment(`${moment(this.dateAsEpoch).format(\"DD-MM-YYYY\")} ${this.chosenTime}`, `'DD-MM-YYYY' ${this.timeFormat}`);\n\n      if (this.firstInterval >= chosenTimeMoment.valueOf() && this.rangeValidity && !this.userInputFlag) {\n        this.chosenTime = moment(this.firstInterval).format(this.timeFormat);\n      }\n      if (!this.userInputFlag) this.populateDropdown();\n      this.userInputFlag = false;\n      this.isInvalid = !this.checkTimeValidity(this.chosenTime.trim());\n      this.emitTime({\n        valid: !this.isInvalid,\n        time: this.chosenTime\n      });\n      this.calculateClosestInterval(this.chosenTime);\n    }\n  }\n\n  emitTime(data: ITime): void {\n    this.timeEmitter.emit(data);\n  }\n\n  // gets a boolean from overlay event to close the dropdown\n  closeDropdown(val: boolean) {\n    this.openStatus = val;\n  }\n\n  // toggle timepicker dropdown\n  openDropdown(): void {\n    this.openStatus = true;\n  }\n\n  checkTimeValidity(time: string): boolean {\n    const RE12 = /^(([0-9][1-9]|1[0-2]):([0-5][0-9])( )?(am|pm|AM|PM))$/i;\n    const RE24 = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;\n    const RE = this.clockFormat === 12 ? RE12 : RE24;\n\n    const timeMoment = moment(`${moment(this.dateAsEpoch).format(\"DD-MM-YYYY\")} ${time}`, `'DD-MM-YYYY' ${this.timeFormat}`);\n    let flag: boolean = false;\n\n    // if the first interval is set to the start of the day\n    // then we don't check its validity against the current time\n    if (\n      this.firstInterval &&\n      moment(this.firstInterval).format(this.timeFormat).valueOf() === moment().startOf(\"d\").format(this.timeFormat).valueOf()\n    ) {\n      flag = time.match(RE) ? true : false;\n    } else {\n      flag = time.match(RE) && timeMoment.isAfter(moment());\n    }\n\n    return flag;\n  }\n\n  // update chosen time as soon as the user clicks on an interval\n  onTimeSelect(time: string): void {\n    this.isInvalid = !this.checkTimeValidity(time.trim());\n    if (!this.isInvalid) {\n      this.chosenTime = time;\n      this.calculateClosestInterval(this.chosenTime);\n    }\n    this.emitTime({\n      valid: !this.isInvalid,\n      time: time\n    });\n    this.openStatus = false;\n    if (this.timepickerDirective) this.timepickerDirective.destroyOverlay();\n  }\n\n  // checks validity of time on input change and calculates the closest interval\n  onTimeChange(time: string): void {\n    this.isInvalid = !this.checkTimeValidity(time.trim());\n    if (!this.isInvalid) {\n      this.userInputFlag = true;\n      this.calculateClosestInterval(time);\n    }\n    this.emitTime({\n      valid: !this.isInvalid,\n      time: time\n    });\n  }\n\n  calculateClosestInterval(time: string): void {\n    const intervalMS = this.interval * 60 * 1000;\n    const chosenDate = moment(this.dateAsEpoch).format(\"DD-MM-YYYY\");\n\n    // converting time passed as parameter to moment object and adding date\n    const parsedTimeWithDate = moment(`${chosenDate} ${time}`, `DD-MM-YYYY ${this.timeFormat}`);\n\n    // converting moment object to epoch so that calculations for rounding off are easier to do\n    const currEpoch = parsedTimeWithDate.valueOf();\n\n    const offset = currEpoch % intervalMS;\n    const roundedEpoch = offset >= intervalMS / 2 ? currEpoch + (intervalMS - offset) : currEpoch - offset;\n\n    // finding the index of element that needs to be highlighted\n    this.timeIntervals.forEach((interval, index, array) => {\n      const intervalObj = moment(`${chosenDate} ${interval}`, `DD-MM-YYYY ${this.timeFormat}`);\n      if (intervalObj.valueOf() === roundedEpoch) this.isHighlighted = index;\n      if (array.length === 1) this.isHighlighted = 0;\n    });\n  }\n\n  // populates the dropdown according to the first interval received\n  populateDropdown(): void {\n    this.timeIntervals = [];\n\n    // if picker is used as an individual component\n    if (!this.firstInterval) {\n      // firstInterval is initialised according to the current time\n      // if the date is same as the current date\n      if (moment(this.dateAsEpoch).format(\"DD-MM-YYYY\") === moment().format(\"DD-MM-YYYY\")) {\n        const offset = this.interval - (moment().minutes() % this.interval);\n        this.firstInterval = moment().add(offset, \"m\").valueOf();\n      }\n\n      // else the firstInterval is initialised as start of day\n      else {\n        this.firstInterval = moment().startOf(\"d\").valueOf();\n      }\n    }\n\n    const start = moment(this.firstInterval);\n    const end = moment().endOf(\"d\");\n\n    while (start.valueOf() < end.valueOf()) {\n      this.timeIntervals.push(start.format(this.timeFormat));\n      start.add(this.interval, \"m\");\n    }\n\n    // if the start time is equal to the interval just before midnight\n    // and the start date = end date\n    // push 11:59pm only\n    if (this.timeIntervals.length === 0) {\n      this.chosenTime = moment().endOf(\"d\").format(this.timeFormat);\n      this.timeIntervals.push(moment().endOf(\"d\").format(this.timeFormat));\n    }\n  }\n}\n"]}

package/esm2015/timepicker/timepicker.directive.js

@@ -0,0 +1,62 @@
+import { Directive, Output, TemplateRef } from '@angular/core';
+import { EventEmitter, Input, ViewContainerRef } from "@angular/core";
+import { ConnectionPositionPair, Overlay, OverlayConfig } from "@angular/cdk/overlay";
+import { TemplatePortal } from "@angular/cdk/portal";
+export class TimepickerDirective {
+    constructor(templateRef, overlay, viewContainerRef) {
+        this.templateRef = templateRef;
+        this.overlay = overlay;
+        this.viewContainerRef = viewContainerRef;
+        this.openStatus = false;
+        this.statusEmitter = new EventEmitter();
+    }
+    set createOverlayOnInput(openStatus) {
+        this.openStatus = openStatus;
+        if (this.originEl && this.openStatus)
+            this.createOverlay(this.originEl);
+    }
+    ;
+    createOverlay(origin) {
+        const positions = [
+            new ConnectionPositionPair({ originX: "start", originY: "bottom" }, { overlayX: "start", overlayY: "top" }, 0, 4),
+            new ConnectionPositionPair({ originX: "end", originY: "bottom" }, { overlayX: "end", overlayY: "top" }, 0, 4)
+        ];
+        const overlayConfig = new OverlayConfig({
+            hasBackdrop: true,
+            backdropClass: "cdk-overlay-transparent-backdrop",
+            positionStrategy: this.overlay
+                .position()
+                //connecting the dropdown overlay to the input element
+                .flexibleConnectedTo(origin)
+                .withPositions([...positions])
+                .withPush(true)
+        });
+        this.overlayRef = this.overlay.create(overlayConfig);
+        const dropdownPortal = new TemplatePortal(this.templateRef, this.viewContainerRef);
+        this.overlayRef.attach(dropdownPortal);
+        this.overlayRef.backdropClick().subscribe(resp => {
+            this.openStatus = false;
+            this.statusEmitter.emit(false);
+            this.overlayRef.detach();
+        });
+    }
+    destroyOverlay() {
+        this.overlayRef.detach();
+    }
+}
+TimepickerDirective.decorators = [
+    { type: Directive, args: [{
+                selector: '[libTimepicker]'
+            },] }
+];
+TimepickerDirective.ctorParameters = () => [
+    { type: TemplateRef },
+    { type: Overlay },
+    { type: ViewContainerRef }
+];
+TimepickerDirective.propDecorators = {
+    originEl: [{ type: Input, args: ['originEl',] }],
+    statusEmitter: [{ type: Output }],
+    createOverlayOnInput: [{ type: Input, args: ['openStatus',] }]
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXBpY2tlci5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9taXMtY29tcG9uZW50cy90aW1lcGlja2VyL3RpbWVwaWNrZXIuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUMvRCxPQUFPLEVBQUUsWUFBWSxFQUFFLEtBQUssRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN0RSxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsT0FBTyxFQUFFLGFBQWEsRUFBYyxNQUFNLHNCQUFzQixDQUFDO0FBQ2xHLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUtyRCxNQUFNLE9BQU8sbUJBQW1CO0lBVTlCLFlBQW9CLFdBQWlDLEVBQVUsT0FBZ0IsRUFBVSxnQkFBa0M7UUFBdkcsZ0JBQVcsR0FBWCxXQUFXLENBQXNCO1FBQVUsWUFBTyxHQUFQLE9BQU8sQ0FBUztRQUFVLHFCQUFnQixHQUFoQixnQkFBZ0IsQ0FBa0I7UUFUbkgsZUFBVSxHQUFZLEtBQUssQ0FBQztRQUUxQixrQkFBYSxHQUFHLElBQUksWUFBWSxFQUFXLENBQUM7SUFPd0UsQ0FBQztJQUwvSCxJQUEwQixvQkFBb0IsQ0FBQyxVQUFVO1FBQ3ZELElBQUksQ0FBQyxVQUFVLEdBQUcsVUFBVSxDQUFDO1FBQzdCLElBQUcsSUFBSSxDQUFDLFFBQVEsSUFBSSxJQUFJLENBQUMsVUFBVTtZQUFFLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3pFLENBQUM7SUFBQSxDQUFDO0lBSUYsYUFBYSxDQUFDLE1BQVc7UUFDdkIsTUFBTSxTQUFTLEdBQUc7WUFDaEIsSUFBSSxzQkFBc0IsQ0FBQyxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsT0FBTyxFQUFFLFFBQVEsRUFBRSxFQUFFLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLEVBQUUsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUNqSCxJQUFJLHNCQUFzQixDQUFDLEVBQUUsT0FBTyxFQUFFLEtBQUssRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLEVBQUUsRUFBRSxRQUFRLEVBQUUsS0FBSyxFQUFFLFFBQVEsRUFBRSxLQUFLLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxDQUFDO1NBQzlHLENBQUM7UUFFRixNQUFNLGFBQWEsR0FBRyxJQUFJLGFBQWEsQ0FBQztZQUN0QyxXQUFXLEVBQUUsSUFBSTtZQUNqQixhQUFhLEVBQUUsa0NBQWtDO1lBQ2pELGdCQUFnQixFQUFFLElBQUksQ0FBQyxPQUFPO2lCQUMzQixRQUFRLEVBQUU7Z0JBQ1gsc0RBQXNEO2lCQUNyRCxtQkFBbUIsQ0FBQyxNQUFNLENBQUM7aUJBQzNCLGFBQWEsQ0FBQyxDQUFDLEdBQUcsU0FBUyxDQUFDLENBQUM7aUJBQzdCLFFBQVEsQ0FBQyxJQUFJLENBQUM7U0FDbEIsQ0FBQyxDQUFDO1FBRUgsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUNyRCxNQUFNLGNBQWMsR0FBRyxJQUFJLGNBQWMsQ0FBQyxJQUFJLENBQUMsV0FBVyxFQUFFLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO1FBQ25GLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxDQUFDO1FBQ3ZDLElBQUksQ0FBQyxVQUFVLENBQUMsYUFBYSxFQUFFLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxFQUFFO1lBQy9DLElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1lBQ3hCLElBQUksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1lBQy9CLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUM7UUFDM0IsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRUQsY0FBYztRQUNaLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDM0IsQ0FBQzs7O1lBNUNGLFNBQVMsU0FBQztnQkFDVCxRQUFRLEVBQUUsaUJBQWlCO2FBQzVCOzs7WUFQMkIsV0FBVztZQUVOLE9BQU87WUFEVixnQkFBZ0I7Ozt1QkFTM0MsS0FBSyxTQUFDLFVBQVU7NEJBQ2hCLE1BQU07bUNBRU4sS0FBSyxTQUFDLFlBQVkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIE91dHB1dCwgVGVtcGxhdGVSZWYgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEV2ZW50RW1pdHRlciwgSW5wdXQsIFZpZXdDb250YWluZXJSZWYgfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xuaW1wb3J0IHsgQ29ubmVjdGlvblBvc2l0aW9uUGFpciwgT3ZlcmxheSwgT3ZlcmxheUNvbmZpZywgT3ZlcmxheVJlZiB9IGZyb20gXCJAYW5ndWxhci9jZGsvb3ZlcmxheVwiO1xuaW1wb3J0IHsgVGVtcGxhdGVQb3J0YWwgfSBmcm9tIFwiQGFuZ3VsYXIvY2RrL3BvcnRhbFwiO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICdbbGliVGltZXBpY2tlcl0nXG59KVxuZXhwb3J0IGNsYXNzIFRpbWVwaWNrZXJEaXJlY3RpdmUge1xuICBwcml2YXRlIG9wZW5TdGF0dXM6IGJvb2xlYW4gPSBmYWxzZTtcbiAgQElucHV0KCdvcmlnaW5FbCcpIG9yaWdpbkVsIDogYW55O1xuICBAT3V0cHV0KCkgc3RhdHVzRW1pdHRlciA9IG5ldyBFdmVudEVtaXR0ZXI8Ym9vbGVhbj4oKTsgXG5cbiAgQElucHV0KCdvcGVuU3RhdHVzJykgIHNldCBjcmVhdGVPdmVybGF5T25JbnB1dChvcGVuU3RhdHVzKXtcbiAgICB0aGlzLm9wZW5TdGF0dXMgPSBvcGVuU3RhdHVzO1xuICAgIGlmKHRoaXMub3JpZ2luRWwgJiYgdGhpcy5vcGVuU3RhdHVzKSB0aGlzLmNyZWF0ZU92ZXJsYXkodGhpcy5vcmlnaW5FbCk7XG4gIH07IFxuICBwcml2YXRlIG92ZXJsYXlSZWYhOiBPdmVybGF5UmVmO1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxFbGVtZW50PiwgcHJpdmF0ZSBvdmVybGF5OiBPdmVybGF5LCBwcml2YXRlIHZpZXdDb250YWluZXJSZWY6IFZpZXdDb250YWluZXJSZWYpIHt9XG5cbiAgY3JlYXRlT3ZlcmxheShvcmlnaW46IGFueSk6IHZvaWQge1xuICAgIGNvbnN0IHBvc2l0aW9ucyA9IFtcbiAgICAgIG5ldyBDb25uZWN0aW9uUG9zaXRpb25QYWlyKHsgb3JpZ2luWDogXCJzdGFydFwiLCBvcmlnaW5ZOiBcImJvdHRvbVwiIH0sIHsgb3ZlcmxheVg6IFwic3RhcnRcIiwgb3ZlcmxheVk6IFwidG9wXCIgfSwgMCwgNCksXG4gICAgICBuZXcgQ29ubmVjdGlvblBvc2l0aW9uUGFpcih7IG9yaWdpblg6IFwiZW5kXCIsIG9yaWdpblk6IFwiYm90dG9tXCIgfSwgeyBvdmVybGF5WDogXCJlbmRcIiwgb3ZlcmxheVk6IFwidG9wXCIgfSwgMCwgNClcbiAgICBdO1xuXG4gICAgY29uc3Qgb3ZlcmxheUNvbmZpZyA9IG5ldyBPdmVybGF5Q29uZmlnKHtcbiAgICAgIGhhc0JhY2tkcm9wOiB0cnVlLFxuICAgICAgYmFja2Ryb3BDbGFzczogXCJjZGstb3ZlcmxheS10cmFuc3BhcmVudC1iYWNrZHJvcFwiLFxuICAgICAgcG9zaXRpb25TdHJhdGVneTogdGhpcy5vdmVybGF5XG4gICAgICAgIC5wb3NpdGlvbigpXG4gICAgICAgIC8vY29ubmVjdGluZyB0aGUgZHJvcGRvd24gb3ZlcmxheSB0byB0aGUgaW5wdXQgZWxlbWVudFxuICAgICAgICAuZmxleGlibGVDb25uZWN0ZWRUbyhvcmlnaW4pXG4gICAgICAgIC53aXRoUG9zaXRpb25zKFsuLi5wb3NpdGlvbnNdKVxuICAgICAgICAud2l0aFB1c2godHJ1ZSlcbiAgICB9KTtcblxuICAgIHRoaXMub3ZlcmxheVJlZiA9IHRoaXMub3ZlcmxheS5jcmVhdGUob3ZlcmxheUNvbmZpZyk7XG4gICAgY29uc3QgZHJvcGRvd25Qb3J0YWwgPSBuZXcgVGVtcGxhdGVQb3J0YWwodGhpcy50ZW1wbGF0ZVJlZiwgdGhpcy52aWV3Q29udGFpbmVyUmVmKTtcbiAgICB0aGlzLm92ZXJsYXlSZWYuYXR0YWNoKGRyb3Bkb3duUG9ydGFsKTtcbiAgICB0aGlzLm92ZXJsYXlSZWYuYmFja2Ryb3BDbGljaygpLnN1YnNjcmliZShyZXNwID0+IHtcbiAgICAgIHRoaXMub3BlblN0YXR1cyA9IGZhbHNlO1xuICAgICAgdGhpcy5zdGF0dXNFbWl0dGVyLmVtaXQoZmFsc2UpO1xuICAgICAgdGhpcy5vdmVybGF5UmVmLmRldGFjaCgpO1xuICAgIH0pO1xuICB9XG5cbiAgZGVzdHJveU92ZXJsYXkoKXtcbiAgICB0aGlzLm92ZXJsYXlSZWYuZGV0YWNoKCk7XG4gIH1cbiAgXG59XG4iXX0=

package/esm2015/timepicker/timepicker.module.js

@@ -0,0 +1,20 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { TimePickerComponent } from "./timepicker.component";
+import { ToolTipModule } from "mis-crystal-design-system/tooltip";
+import { OverlayModule } from '@angular/cdk/overlay';
+import { TimepickerDirective } from './timepicker.directive';
+export class TimePickerModule {
+    static forRoot() {
+        return { ngModule: TimePickerModule, providers: [] };
+    }
+}
+TimePickerModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [TimePickerComponent, TimepickerDirective],
+                imports: [CommonModule, FormsModule, ToolTipModule, OverlayModule],
+                exports: [TimePickerComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/timerangepicker/index.js

@@ -0,0 +1,2 @@
+export * from "./public_api";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9taXMtY29tcG9uZW50cy90aW1lcmFuZ2VwaWNrZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tIFwiLi9wdWJsaWNfYXBpXCI7Il19

package/esm2015/timerangepicker/mis-crystal-design-system-timerangepicker.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWlzLWNyeXN0YWwtZGVzaWduLXN5c3RlbS10aW1lcmFuZ2VwaWNrZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9taXMtY29tcG9uZW50cy90aW1lcmFuZ2VwaWNrZXIvbWlzLWNyeXN0YWwtZGVzaWduLXN5c3RlbS10aW1lcmFuZ2VwaWNrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=

package/esm2015/timerangepicker/public_api.js

@@ -0,0 +1,3 @@
+export { TimeRangePickerComponent } from "./timerangepicker.component";
+export { TimeRangePickerModule } from "./timerangepicker.module";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL21pcy1jb21wb25lbnRzL3RpbWVyYW5nZXBpY2tlci9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBQ3ZFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLDBCQUEwQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgVGltZVJhbmdlUGlja2VyQ29tcG9uZW50IH0gZnJvbSBcIi4vdGltZXJhbmdlcGlja2VyLmNvbXBvbmVudFwiO1xuZXhwb3J0IHsgVGltZVJhbmdlUGlja2VyTW9kdWxlIH0gZnJvbSBcIi4vdGltZXJhbmdlcGlja2VyLm1vZHVsZVwiIl19

package/esm2015/timerangepicker/timerange.namespace.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXJhbmdlLm5hbWVzcGFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL21pcy1jb21wb25lbnRzL3RpbWVyYW5nZXBpY2tlci90aW1lcmFuZ2UubmFtZXNwYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgaW50ZXJmYWNlIElUaW1lUmFuZ2V7XG4gIHZhbGlkOiBib29sZWFuLFxuICBzdGFydFRpbWU6IHN0cmluZyxcbiAgZW5kVGltZTogc3RyaW5nXG59XG5cbmV4cG9ydCBpbnRlcmZhY2UgSVRpbWV7XG4gIHZhbGlkOiBib29sZWFuLFxuICB0aW1lOiBzdHJpbmdcbn0iXX0=

package/esm2015/timerangepicker/timerangepicker.component.js

@@ -0,0 +1,123 @@
+import { Component, Input, ChangeDetectorRef, Output, EventEmitter } from "@angular/core";
+import * as moment from "moment-timezone";
+export class TimeRangePickerComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this.inputWidth = '100px';
+        this.height = '46px';
+        this.timezone = "Asia/Kolkata";
+        this.startDateEpoch = moment().tz(this.timezone).valueOf();
+        this.endDateEpoch = moment().tz(this.timezone).valueOf();
+        this.clockFormat = 12;
+        this.interval = 15;
+        this.timeRangeEmitter = new EventEmitter();
+        this.firstIntervalForStartPicker = moment().valueOf();
+        this.firstIntervalForEndPicker = moment().valueOf();
+        this.rangeValidity = true;
+    }
+    ngOnInit() {
+        console.log(this.timezone);
+        this.timeFormat = this.clockFormat === 12 ? "hh:mm a" : "HH:mm";
+        this.setFirstIntervals();
+    }
+    ngOnChanges() {
+        moment.tz.setDefault(this.timezone);
+    }
+    // calculate the first interval of the picker
+    setFirstIntervals() {
+        const startDate = moment(this.startDateEpoch).format("DD-MM-YYYY");
+        const endDate = moment(this.endDateEpoch).format("DD-MM-YYYY");
+        const minutes = moment().minutes();
+        const offset = this.interval - (minutes % this.interval);
+        // first interval for the start picker will always be the one closest to the current time
+        this.firstIntervalForStartPicker = moment().add(offset, "m").valueOf();
+        this.startTime = {
+            valid: true,
+            time: moment().add(offset, "m").format(this.timeFormat)
+        };
+        // for the end picker if the startDate and the endDate is same
+        // the first interval is set one interval ahead of the first interval for start picker
+        // else if the dates are different we set it to the start of the day
+        if (startDate === endDate) {
+            this.firstIntervalForEndPicker = moment().add(offset, "m").add(this.interval, "m").valueOf();
+        }
+        else {
+            this.firstIntervalForEndPicker = moment().startOf("d").valueOf();
+        }
+        this.endTime = {
+            valid: true,
+            time: moment(this.firstIntervalForEndPicker).format(this.timeFormat)
+        };
+    }
+    emitTimeRange(data) {
+        this.timeRangeEmitter.emit(data);
+    }
+    //handlers catch the emitted values and run validation
+    startPickerHandler(time) {
+        this.startTime = time;
+        // if the start time changes and the start date is the same as the end date
+        // and the start time >=  end time
+        // update the first interval of end picker according to the time set in start picker
+        const startDate = moment(this.startDateEpoch).format("DD-MM-YYYY");
+        const endDate = moment(this.endDateEpoch).format("DD-MM-YYYY");
+        if (startDate === endDate) {
+            let minutes = moment(this.startTime.time, this.timeFormat).minutes();
+            let offset = this.interval - (minutes % this.interval);
+            this.firstIntervalForEndPicker = moment(`${startDate} ${this.startTime.time}`, `'DD-MM-YYYY' ${this.timeFormat}`).add(offset, "m").valueOf();
+        }
+    }
+    endPickerHandler(time) {
+        this.endTime = time;
+        const validity = this.checkTimeValidity(this.startTime.time.trim()) && this.checkTimeValidity(this.endTime.time.trim());
+        this.emitTimeRange({
+            valid: validity && this.rangeValidity,
+            startTime: this.startTime.time,
+            endTime: this.endTime.time
+        });
+        this.rangeValidation();
+    }
+    checkTimeValidity(time) {
+        const RE12 = /^(([0-9][1-9]|1[0-2]):([0-5][0-9])( )?(am|pm|AM|PM))$/i;
+        const RE24 = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
+        const RE = this.clockFormat === 12 ? RE12 : RE24;
+        const flag = time.match(RE) ? true : false;
+        return flag;
+    }
+    // validates end picker's input according to the start picker's input
+    rangeValidation() {
+        const startDate = moment(this.startDateEpoch).format("DD-MM-YYYY");
+        const endDate = moment(this.endDateEpoch).format("DD-MM-YYYY");
+        const validity = this.checkTimeValidity(this.startTime.time.trim()) && this.checkTimeValidity(this.endTime.time.trim());
+        if (validity && startDate === endDate) {
+            if (this.endTime.time === moment().endOf("d").add(1, "m").format(this.timeFormat)) {
+                this.endTime.time = moment().endOf("d").format(this.timeFormat);
+            }
+            const startMoment = moment(this.startTime.time, this.timeFormat);
+            const endMoment = moment(this.endTime.time, this.timeFormat);
+            this.rangeValidity = endMoment.diff(startMoment, "m") >= 1 ? true : false;
+            this.cdr.detectChanges();
+        }
+    }
+}
+TimeRangePickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: "mis-timerangepicker",
+                template: "<div class=\"rangepicker-container\">\n  <mis-timepicker\n    [clockFormat]=\"clockFormat\"\n    [interval]=\"interval\"\n    [dateAsEpoch]=\"startDateEpoch\"\n    [firstInterval]=\"firstIntervalForStartPicker\"\n    (timeEmitter)=\"startPickerHandler($event)\"\n    [timezone]=\"timezone\"\n    [height]=\"height\"\n    [inputWidth]=\"'200px'\"\n    [dropdownWidth]=\"dropdownWidth\"\n  ></mis-timepicker>\n  <mis-timepicker\n    [clockFormat]=\"clockFormat\"\n    [interval]=\"interval\"\n    [dateAsEpoch]=\"endDateEpoch\"\n    [firstInterval]=\"firstIntervalForEndPicker\"\n    (timeEmitter)=\"endPickerHandler($event)\"\n    [rangeValidity]=\"rangeValidity\"\n    [timezone]=\"timezone\"\n    [height]=\"height\"\n    [inputWidth]=\"'200px'\"\n    [dropdownWidth]=\"dropdownWidth\"\n  ></mis-timepicker>\n</div>\n",
+                styles: [".rangepicker-container{display:flex;gap:1rem}"]
+            },] }
+];
+TimeRangePickerComponent.ctorParameters = () => [
+    { type: ChangeDetectorRef }
+];
+TimeRangePickerComponent.propDecorators = {
+    inputWidth: [{ type: Input }],
+    dropdownWidth: [{ type: Input }],
+    height: [{ type: Input }],
+    timezone: [{ type: Input }],
+    startDateEpoch: [{ type: Input }],
+    endDateEpoch: [{ type: Input }],
+    clockFormat: [{ type: Input }],
+    interval: [{ type: Input }],
+    timeRangeEmitter: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"timerangepicker.component.js","sourceRoot":"","sources":["../../../../projects/mis-components/timerangepicker/timerangepicker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, Input, ChangeDetectorRef, Output, EventEmitter } from \"@angular/core\";\nimport * as moment from \"moment-timezone\";\nimport { ITimeRange, ITime } from \"./timerange.namespace\";\n\n@Component({\n  selector: \"mis-timerangepicker\",\n  templateUrl: \"./timerangepicker.component.html\",\n  styleUrls: [\"./timerangepicker.component.scss\"]\n})\nexport class TimeRangePickerComponent {\n  @Input() inputWidth :string = '100px';\n  @Input() dropdownWidth?: string;\n  @Input() height: string = '46px';\n  @Input() timezone: string = \"Asia/Kolkata\";\n  @Input() startDateEpoch: number = moment().tz(this.timezone).valueOf();\n  @Input() endDateEpoch: number = moment().tz(this.timezone).valueOf();\n  @Input() clockFormat: number = 12;\n  @Input() interval: number = 15;\n  @Output() timeRangeEmitter = new EventEmitter<ITimeRange>();\n\n  timeFormat!: string;\n  firstIntervalForStartPicker: number = moment().valueOf();\n  firstIntervalForEndPicker: number = moment().valueOf();\n  startTime!: ITime;\n  endTime!: ITime;\n  rangeValidity: boolean = true;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  ngOnInit() {\n    console.log(this.timezone);\n    this.timeFormat = this.clockFormat === 12 ? \"hh:mm a\" : \"HH:mm\";\n    this.setFirstIntervals();\n  }\n\n  ngOnChanges(){\n    moment.tz.setDefault(this.timezone);\n  }\n\n  // calculate the first interval of the picker\n  setFirstIntervals(): void {\n    const startDate = moment(this.startDateEpoch).format(\"DD-MM-YYYY\");\n    const endDate = moment(this.endDateEpoch).format(\"DD-MM-YYYY\");\n    const minutes = moment().minutes();\n    const offset = this.interval - (minutes % this.interval);\n\n    // first interval for the start picker will always be the one closest to the current time\n    this.firstIntervalForStartPicker = moment().add(offset, \"m\").valueOf();\n    this.startTime = {\n      valid: true,\n      time: moment().add(offset, \"m\").format(this.timeFormat)\n    };\n\n    // for the end picker if the startDate and the endDate is same\n    // the first interval is set one interval ahead of the first interval for start picker\n    // else if the dates are different we set it to the start of the day\n    if (startDate === endDate) {\n      this.firstIntervalForEndPicker = moment().add(offset, \"m\").add(this.interval, \"m\").valueOf();\n    } else {\n      this.firstIntervalForEndPicker = moment().startOf(\"d\").valueOf();\n    }\n\n    this.endTime = {\n      valid: true,\n      time: moment(this.firstIntervalForEndPicker).format(this.timeFormat)\n    }\n  }\n\n  emitTimeRange(data: ITimeRange): void {\n    this.timeRangeEmitter.emit(data);\n  }\n\n  //handlers catch the emitted values and run validation\n  startPickerHandler(time: ITime): void {\n    this.startTime = time;\n\n    // if the start time changes and the start date is the same as the end date\n    // and the start time >=  end time\n    // update the first interval of end picker according to the time set in start picker\n    const startDate = moment(this.startDateEpoch).format(\"DD-MM-YYYY\");\n    const endDate = moment(this.endDateEpoch).format(\"DD-MM-YYYY\");\n\n    if (startDate === endDate) {\n      let minutes = moment(this.startTime.time, this.timeFormat).minutes();\n      let offset = this.interval - (minutes % this.interval);\n      this.firstIntervalForEndPicker = moment(`${startDate} ${this.startTime.time}`, `'DD-MM-YYYY' ${this.timeFormat}`).add(offset, \"m\").valueOf();\n    }\n  }\n\n  endPickerHandler(time: ITime): void {\n    this.endTime = time;\n\n    const validity = this.checkTimeValidity(this.startTime.time.trim()) && this.checkTimeValidity(this.endTime.time.trim());\n    this.emitTimeRange({\n      valid: validity && this.rangeValidity,\n      startTime: this.startTime.time,\n      endTime: this.endTime.time\n    });\n\n    this.rangeValidation();\n  }\n\n  checkTimeValidity(time: string): boolean {\n    const RE12 = /^(([0-9][1-9]|1[0-2]):([0-5][0-9])( )?(am|pm|AM|PM))$/i;\n    const RE24 = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;\n    const RE = this.clockFormat === 12 ? RE12 : RE24;\n    const flag = time.match(RE) ? true : false;\n    return flag;\n  }\n\n  // validates end picker's input according to the start picker's input\n  rangeValidation() {\n    const startDate = moment(this.startDateEpoch).format(\"DD-MM-YYYY\");\n    const endDate = moment(this.endDateEpoch).format(\"DD-MM-YYYY\");\n    const validity = this.checkTimeValidity(this.startTime.time.trim()) && this.checkTimeValidity(this.endTime.time.trim());\n    if (validity && startDate === endDate) {\n      if (this.endTime.time === moment().endOf(\"d\").add(1, \"m\").format(this.timeFormat)) {\n        this.endTime.time = moment().endOf(\"d\").format(this.timeFormat);\n      }\n\n      const startMoment = moment(this.startTime.time, this.timeFormat);\n      const endMoment = moment(this.endTime.time, this.timeFormat);\n      this.rangeValidity = endMoment.diff(startMoment, \"m\") >= 1 ? true : false;\n      this.cdr.detectChanges();\n    }\n  }\n}\n"]}

package/esm2015/timerangepicker/timerangepicker.module.js

@@ -0,0 +1,18 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { TimeRangePickerComponent } from "./timerangepicker.component";
+import { TimePickerModule } from "mis-crystal-design-system/timepicker";
+export class TimeRangePickerModule {
+    static forRoot() {
+        return { ngModule: TimeRangePickerModule, providers: [] };
+    }
+}
+TimeRangePickerModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [TimeRangePickerComponent],
+                imports: [CommonModule, FormsModule, TimePickerModule],
+                exports: [TimeRangePickerComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXJhbmdlcGlja2VyLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL21pcy1jb21wb25lbnRzL3RpbWVyYW5nZXBpY2tlci90aW1lcmFuZ2VwaWNrZXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQXVCLE1BQU0sZUFBZSxDQUFDO0FBQzlELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLHdCQUF3QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDdkUsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sc0NBQXNDLENBQUM7QUFPeEUsTUFBTSxPQUFPLHFCQUFxQjtJQUNoQyxNQUFNLENBQUMsT0FBTztRQUNaLE9BQU8sRUFBRSxRQUFRLEVBQUUscUJBQXFCLEVBQUUsU0FBUyxFQUFFLEVBQUUsRUFBRSxDQUFDO0lBQzVELENBQUM7OztZQVJGLFFBQVEsU0FBQztnQkFDUixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztnQkFDeEMsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsRUFBRSxnQkFBZ0IsQ0FBQztnQkFDdEQsT0FBTyxFQUFFLENBQUMsd0JBQXdCLENBQUM7YUFDcEMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSwgTW9kdWxlV2l0aFByb3ZpZGVycyB9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBUaW1lUmFuZ2VQaWNrZXJDb21wb25lbnQgfSBmcm9tIFwiLi90aW1lcmFuZ2VwaWNrZXIuY29tcG9uZW50XCI7XG5pbXBvcnQgeyBUaW1lUGlja2VyTW9kdWxlIH0gZnJvbSBcIm1pcy1jcnlzdGFsLWRlc2lnbi1zeXN0ZW0vdGltZXBpY2tlclwiO1xuXG5ATmdNb2R1bGUoe1xuICBkZWNsYXJhdGlvbnM6IFtUaW1lUmFuZ2VQaWNrZXJDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZSwgVGltZVBpY2tlck1vZHVsZV0sXG4gIGV4cG9ydHM6IFtUaW1lUmFuZ2VQaWNrZXJDb21wb25lbnRdXG59KVxuZXhwb3J0IGNsYXNzIFRpbWVSYW5nZVBpY2tlck1vZHVsZSB7XG4gIHN0YXRpYyBmb3JSb290KCk6IE1vZHVsZVdpdGhQcm92aWRlcnM8VGltZVJhbmdlUGlja2VyTW9kdWxlPiB7XG4gICAgcmV0dXJuIHsgbmdNb2R1bGU6IFRpbWVSYW5nZVBpY2tlck1vZHVsZSwgcHJvdmlkZXJzOiBbXSB9O1xuICB9XG59Il19