@ampath-kenya/ngx-openmrs-formentry 3.0.0-alpha9 → 3.0.0-ampath.1-beta.0

package/esm5/components/date-time-picker/date-time-picker.component.js

@@ -0,0 +1,113 @@
+import { Component, Input, forwardRef, EventEmitter, Output } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as moment_ from 'moment';
+var Moment = moment_;
+var DateTimePickerComponent = /** @class */ (function () {
+    function DateTimePickerComponent() {
+        this.showDate = true;
+        this.showTime = false;
+        this.showWeeks = false;
+        this.weeks = [2, 4, 6, 8, 12, 16, 24];
+        this.onDateChange = new EventEmitter();
+        this.showDatePicker = false;
+        this.showTimePicker = false;
+        this.onChange = function () { };
+        this.onTouched = function () { };
+    }
+    DateTimePickerComponent.prototype.ngOnInit = function () { };
+    DateTimePickerComponent.prototype.weeksSelected = function (count) {
+        var now = new Date();
+        var nextDate = now.setDate(now.getDate() + count * 7);
+        this.value = Moment(nextDate).format();
+    };
+    DateTimePickerComponent.prototype.setDate = function (date) {
+        if (date && date !== '') {
+            this.value = Moment(date).format();
+        }
+        else {
+            this.value = date;
+        }
+    };
+    DateTimePickerComponent.prototype.setTime = function (time) {
+        if (time && time !== '') {
+            this.value = Moment(time).format();
+        }
+        else {
+            this.value = time;
+        }
+        return;
+    };
+    DateTimePickerComponent.prototype.toggleDatePicker = function (status) {
+        this.showDatePicker = status;
+        /*setTimeout(function() {
+            let _body = document.getElementById('content-wrapper').getBoundingClientRect(),
+              elem = document.getElementById('section-modal-main');
+            if (elem) {
+              let elemBox = elem.getBoundingClientRect();
+              if (elemBox.bottom > _body.bottom) {
+                elem.style.bottom = '36px';
+              }
+            }
+          }, 0);*/
+        return;
+    };
+    DateTimePickerComponent.prototype.toggleTimePicker = function (status) {
+        this.showTimePicker = status;
+        return;
+    };
+    Object.defineProperty(DateTimePickerComponent.prototype, "value", {
+        get: function () {
+            return this.modelValue;
+        },
+        set: function (val) {
+            this.modelValue = val;
+            this.onDateChange.emit(val);
+            this.onChange(val);
+            this.onTouched();
+        },
+        enumerable: true,
+        configurable: true
+    });
+    DateTimePickerComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    DateTimePickerComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    DateTimePickerComponent.prototype.writeValue = function (value) {
+        if (value instanceof Date) {
+            this.value = Moment(value).format();
+        }
+        else {
+            this.value = value;
+        }
+    };
+    DateTimePickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'date-time-picker',
+                    template: "<div class=\"row\">\n  <div *ngIf=\"!showTime\" class=\"col-xs-12 col-md-12\">\n    <input\n      *ngIf=\"!showWeeks\"\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'mediumDate'\"\n      (focus)=\"toggleDatePicker(true)\"\n      readonly\n      placeholder=\"Select Date\"\n    />\n    <div *ngIf=\"showWeeks\" class=\"input-group\">\n      <input\n        type=\"text\"\n        class=\"form-control\"\n        class=\"form-control\"\n        [value]=\"value | date: 'mediumDate'\"\n        (focus)=\"toggleDatePicker(true)\"\n        readonly\n        placeholder=\"Select Date\"\n      />\n      <div class=\"input-group-btn\">\n        <button\n          type=\"button\"\n          class=\"btn btn-default dropdown-toggle\"\n          data-toggle=\"dropdown\"\n          aria-haspopup=\"true\"\n          aria-expanded=\"false\"\n        >\n          Weeks <span class=\"caret\"></span>\n        </button>\n        <ul class=\"dropdown-menu up\">\n          <li (click)=\"weeksSelected(count)\" *ngFor=\"let count of weeks\">\n            <span> {{ count }} Weeks</span>\n          </li>\n        </ul>\n      </div>\n    </div>\n  </div>\n  <div *ngIf=\"showTime\" class=\"col-xs-8 col-md-8\">\n    <input\n      *ngIf=\"!showWeeks\"\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'mediumDate'\"\n      (focus)=\"toggleDatePicker(true)\"\n      readonly\n      placeholder=\"Select Date\"\n    />\n    <div *ngIf=\"showWeeks\" class=\"input-group\">\n      <input\n        type=\"text\"\n        class=\"form-control\"\n        class=\"form-control\"\n        [value]=\"value | date: 'mediumDate'\"\n        (focus)=\"toggleDatePicker(true)\"\n        readonly\n        placeholder=\"Select Date\"\n      />\n      <div class=\"input-group-btn\">\n        <button\n          type=\"button\"\n          class=\"btn btn-default dropdown-toggle\"\n          data-toggle=\"dropdown\"\n          aria-haspopup=\"true\"\n          aria-expanded=\"false\"\n        >\n          Weeks <span class=\"caret\"></span>\n        </button>\n        <ul class=\"dropdown-menu up\">\n          <li (click)=\"weeksSelected(count)\" *ngFor=\"let count of weeks\">\n            <span> {{ count }} Weeks</span>\n          </li>\n        </ul>\n      </div>\n    </div>\n  </div>\n  <div *ngIf=\"showTime\" class=\"col-xs-4 col-md-4\">\n    <input\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'shortTime'\"\n      (focus)=\"toggleTimePicker(true)\"\n      readonly\n      placeholder=\"Select Time\"\n    />\n  </div>\n</div>\n<date-picker\n  *ngIf=\"showDatePicker\"\n  [initDate]=\"value\"\n  (onSelectDate)=\"setDate($event)\"\n  (onDatePickerCancel)=\"toggleDatePicker($event)\"\n></date-picker>\n\n<time-picker\n  *ngIf=\"showTimePicker\"\n  [initTime]=\"value\"\n  [use12Hour]=\"true\"\n  (onSelectTime)=\"setTime($event)\"\n  (onTimePickerCancel)=\"toggleTimePicker($event)\"\n></time-picker>\n",
+                    styles: ["input[readonly]{background-color:#fff}.up{bottom:100%!important;top:auto!important}.glyphicon{top:1px}"],
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(function () { return DateTimePickerComponent; }),
+                            multi: true
+                        }
+                    ]
+                },] },
+    ];
+    /** @nocollapse */
+    DateTimePickerComponent.ctorParameters = function () { return []; };
+    DateTimePickerComponent.propDecorators = {
+        modelValue: [{ type: Input }],
+        showDate: [{ type: Input }],
+        showTime: [{ type: Input }],
+        showWeeks: [{ type: Input }],
+        weeks: [{ type: Input }],
+        onDateChange: [{ type: Output }]
+    };
+    return DateTimePickerComponent;
+}());
+export { DateTimePickerComponent };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-time-picker.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/date-time-picker/date-time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  EventEmitter,\n  Output\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport * as moment_ from 'moment';\n\nconst Moment = moment_;\n\n@Component({\n  selector: 'date-time-picker',\n  template: `<div class=\"row\">\n  <div *ngIf=\"!showTime\" class=\"col-xs-12 col-md-12\">\n    <input\n      *ngIf=\"!showWeeks\"\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'mediumDate'\"\n      (focus)=\"toggleDatePicker(true)\"\n      readonly\n      placeholder=\"Select Date\"\n    />\n    <div *ngIf=\"showWeeks\" class=\"input-group\">\n      <input\n        type=\"text\"\n        class=\"form-control\"\n        class=\"form-control\"\n        [value]=\"value | date: 'mediumDate'\"\n        (focus)=\"toggleDatePicker(true)\"\n        readonly\n        placeholder=\"Select Date\"\n      />\n      <div class=\"input-group-btn\">\n        <button\n          type=\"button\"\n          class=\"btn btn-default dropdown-toggle\"\n          data-toggle=\"dropdown\"\n          aria-haspopup=\"true\"\n          aria-expanded=\"false\"\n        >\n          Weeks <span class=\"caret\"></span>\n        </button>\n        <ul class=\"dropdown-menu up\">\n          <li (click)=\"weeksSelected(count)\" *ngFor=\"let count of weeks\">\n            <span> {{ count }} Weeks</span>\n          </li>\n        </ul>\n      </div>\n    </div>\n  </div>\n  <div *ngIf=\"showTime\" class=\"col-xs-8 col-md-8\">\n    <input\n      *ngIf=\"!showWeeks\"\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'mediumDate'\"\n      (focus)=\"toggleDatePicker(true)\"\n      readonly\n      placeholder=\"Select Date\"\n    />\n    <div *ngIf=\"showWeeks\" class=\"input-group\">\n      <input\n        type=\"text\"\n        class=\"form-control\"\n        class=\"form-control\"\n        [value]=\"value | date: 'mediumDate'\"\n        (focus)=\"toggleDatePicker(true)\"\n        readonly\n        placeholder=\"Select Date\"\n      />\n      <div class=\"input-group-btn\">\n        <button\n          type=\"button\"\n          class=\"btn btn-default dropdown-toggle\"\n          data-toggle=\"dropdown\"\n          aria-haspopup=\"true\"\n          aria-expanded=\"false\"\n        >\n          Weeks <span class=\"caret\"></span>\n        </button>\n        <ul class=\"dropdown-menu up\">\n          <li (click)=\"weeksSelected(count)\" *ngFor=\"let count of weeks\">\n            <span> {{ count }} Weeks</span>\n          </li>\n        </ul>\n      </div>\n    </div>\n  </div>\n  <div *ngIf=\"showTime\" class=\"col-xs-4 col-md-4\">\n    <input\n      type=\"text\"\n      class=\"form-control\"\n      [value]=\"value | date: 'shortTime'\"\n      (focus)=\"toggleTimePicker(true)\"\n      readonly\n      placeholder=\"Select Time\"\n    />\n  </div>\n</div>\n<date-picker\n  *ngIf=\"showDatePicker\"\n  [initDate]=\"value\"\n  (onSelectDate)=\"setDate($event)\"\n  (onDatePickerCancel)=\"toggleDatePicker($event)\"\n></date-picker>\n\n<time-picker\n  *ngIf=\"showTimePicker\"\n  [initTime]=\"value\"\n  [use12Hour]=\"true\"\n  (onSelectTime)=\"setTime($event)\"\n  (onTimePickerCancel)=\"toggleTimePicker($event)\"\n></time-picker>\n`,\n  styles: [`input[readonly]{background-color:#fff}.up{bottom:100%!important;top:auto!important}.glyphicon{top:1px}`],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => DateTimePickerComponent),\n      multi: true\n    }\n  ]\n})\nexport class DateTimePickerComponent implements OnInit, ControlValueAccessor {\n  @Input() modelValue: any;\n  @Input() showDate = true;\n  @Input() showTime = false;\n  @Input() showWeeks = false;\n  @Input() weeks: number[] = [2, 4, 6, 8, 12, 16, 24];\n  @Output() onDateChange = new EventEmitter<any>();\n  public showDatePicker = false;\n  public showTimePicker = false;\n  onChange: any = () => {};\n  onTouched: any = () => {};\n\n  constructor() {}\n\n  ngOnInit() {}\n\n  weeksSelected(count) {\n    const now = new Date();\n    const nextDate = now.setDate(now.getDate() + count * 7);\n    this.value = Moment(nextDate).format();\n  }\n  setDate(date: any): void {\n    if (date && date !== '') {\n      this.value = Moment(date).format();\n    } else {\n      this.value = date;\n    }\n  }\n\n  setTime(time: any): void {\n    if (time && time !== '') {\n      this.value = Moment(time).format();\n    } else {\n      this.value = time;\n    }\n    return;\n  }\n\n  toggleDatePicker(status: boolean): void {\n    this.showDatePicker = status;\n    /*setTimeout(function() {\n        let _body = document.getElementById('content-wrapper').getBoundingClientRect(),\n          elem = document.getElementById('section-modal-main');\n        if (elem) {\n          let elemBox = elem.getBoundingClientRect();\n          if (elemBox.bottom > _body.bottom) {\n            elem.style.bottom = '36px';\n          }\n        }\n      }, 0);*/\n    return;\n  }\n\n  toggleTimePicker(status: boolean): void {\n    this.showTimePicker = status;\n    return;\n  }\n  get value() {\n    return this.modelValue;\n  }\n\n  set value(val) {\n    this.modelValue = val;\n    this.onDateChange.emit(val);\n    this.onChange(val);\n    this.onTouched();\n  }\n\n  registerOnChange(fn) {\n    this.onChange = fn;\n  }\n\n  registerOnTouched(fn) {\n    this.onTouched = fn;\n  }\n\n  writeValue(value) {\n    if (value instanceof Date) {\n      this.value = Moment(value).format();\n    } else {\n      this.value = value;\n    }\n  }\n}\n"]}

package/esm5/components/date-time-picker/date-time-picker.module.js

@@ -0,0 +1,39 @@
+/**
+ * date-time-picker.module
+ */
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { DatePickerComponent } from './date-picker/date-picker.component';
+import { TimePickerComponent } from './time-picker/time-picker.component';
+import { ModalComponent } from './picker-modal/modal.component';
+import { MomentPipe } from './pipes/moment.pipe';
+import { DateTimePickerComponent } from './date-time-picker.component';
+var DateTimePickerModule = /** @class */ (function () {
+    function DateTimePickerModule() {
+    }
+    DateTimePickerModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [CommonModule, FormsModule],
+                    declarations: [
+                        DatePickerComponent,
+                        TimePickerComponent,
+                        ModalComponent,
+                        MomentPipe,
+                        DateTimePickerComponent
+                    ],
+                    exports: [
+                        DatePickerComponent,
+                        TimePickerComponent,
+                        ModalComponent,
+                        MomentPipe,
+                        DateTimePickerComponent
+                    ],
+                    providers: []
+                },] },
+    ];
+    return DateTimePickerModule;
+}());
+export { DateTimePickerModule };
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/date-time-picker/picker-modal/modal.component.js

@@ -0,0 +1,34 @@
+/**
+ * modal.component
+ */
+import { Component, Output, EventEmitter, ChangeDetectionStrategy } from '@angular/core';
+// const myDpStyles: string = require('./modal.component.css');
+// const myDpTpl: string = require('./modal.component.html');
+// webpack2_
+var ModalComponent = /** @class */ (function () {
+    function ModalComponent() {
+        this.onOverlayClick = new EventEmitter();
+    }
+    ModalComponent.prototype.ngOnInit = function () { };
+    ModalComponent.prototype.closeModal = function () {
+        this.onOverlayClick.emit(false);
+    };
+    ModalComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'picker-modal',
+                    template: "<section class=\"x-modal\">\n  <section class=\"modal-overlay\" (click)=\"closeModal()\"></section>\n  <section class=\"modal-main\" id=\"section-modal-main\">\n    <ng-content></ng-content>\n  </section>\n</section>\n",
+                    styles: [":host{z-index:9999999999}*,::after,::before{box-sizing:border-box}.modal-main{position:absolute;left:19.6%;right:auto;top:auto;z-index:111;background-color:#fff;border:1px solid #d7dad7;border-radius:6px;-webkit-transform:translate(-50%,0);transform:translate(-50%,0);box-shadow:0 5px 15px rgba(0,0,0,.3)}"],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    animations: []
+                },] },
+    ];
+    /** @nocollapse */
+    ModalComponent.ctorParameters = function () { return []; };
+    ModalComponent.propDecorators = {
+        onOverlayClick: [{ type: Output }]
+    };
+    return ModalComponent;
+}());
+export { ModalComponent };
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/date-time-picker/pipes/moment.pipe.js

@@ -0,0 +1,18 @@
+/**
+ * moment.pipe
+ */
+import { Pipe } from '@angular/core';
+var MomentPipe = /** @class */ (function () {
+    function MomentPipe() {
+    }
+    MomentPipe.prototype.transform = function (moment, format) {
+        return format ? moment.format(format) : moment.format('MMM DD, YYYY');
+    };
+    MomentPipe.decorators = [
+        { type: Pipe, args: [{ name: 'moment' },] },
+    ];
+    return MomentPipe;
+}());
+export { MomentPipe };
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9tZW50LnBpcGUuanMiLCJzb3VyY2VSb290Ijoibmc6Ly9AYW1wYXRoLWtlbnlhL25neC1vcGVubXJzLWZvcm1lbnRyeS8iLCJzb3VyY2VzIjpbImNvbXBvbmVudHMvZGF0ZS10aW1lLXBpY2tlci9waXBlcy9tb21lbnQucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBR3BEO0lBQUE7SUFLQSxDQUFDO0lBSEMsOEJBQVMsR0FBVCxVQUFVLE1BQWMsRUFBRSxNQUFlO1FBQ3ZDLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLENBQUM7SUFDeEUsQ0FBQzs7Z0JBSkYsSUFBSSxTQUFDLEVBQUUsSUFBSSxFQUFFLFFBQVEsRUFBRTs7SUFLeEIsaUJBQUM7Q0FBQSxBQUxELElBS0M7U0FKWSxVQUFVIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBtb21lbnQucGlwZVxuICovXG5cbmltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IE1vbWVudCB9IGZyb20gJ21vbWVudC9tb21lbnQnO1xuXG5AUGlwZSh7IG5hbWU6ICdtb21lbnQnIH0pXG5leHBvcnQgY2xhc3MgTW9tZW50UGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0obW9tZW50OiBNb21lbnQsIGZvcm1hdD86IHN0cmluZyk6IHN0cmluZyB7XG4gICAgcmV0dXJuIGZvcm1hdCA/IG1vbWVudC5mb3JtYXQoZm9ybWF0KSA6IG1vbWVudC5mb3JtYXQoJ01NTSBERCwgWVlZWScpO1xuICB9XG59XG4iXX0=

package/esm5/components/date-time-picker/time-picker/time-picker.component.js

@@ -0,0 +1,119 @@
+/**
+ * time-picker.component
+ */
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import * as moment_ from 'moment';
+var moment = moment_;
+// const myDpStyles: string = require('./time-picker.component.css');
+// const myDpTpl: string = require('./time-picker.component.html');
+// webpack2_
+var TimePickerComponent = /** @class */ (function () {
+    function TimePickerComponent() {
+        this.showSecond = true;
+        this.viewFormat = 'hh:mm A';
+        this.use12Hour = false;
+        this.returnObject = 'js';
+        this.onSelectTime = new EventEmitter();
+        this.onTimePickerCancel = new EventEmitter();
+        this.hourFormat = 'HH';
+    }
+    TimePickerComponent.prototype.ngOnInit = function () {
+        if (this.use12Hour) {
+            this.hourFormat = 'hh';
+        }
+        this.time = this.initTime
+            ? moment(this.initTime, this.viewFormat)
+            : moment();
+        // check if the input initDate has value
+        if (this.initTime) {
+            this.time =
+                this.returnObject === 'string'
+                    ? moment(this.initTime, this.viewFormat)
+                    : moment(this.initTime);
+        }
+        else {
+            this.time = moment();
+        }
+    };
+    TimePickerComponent.prototype.increaseHour = function () {
+        this.time = this.time.clone().add(1, 'h');
+    };
+    TimePickerComponent.prototype.decreaseHour = function () {
+        this.time = this.time.clone().subtract(1, 'h');
+    };
+    TimePickerComponent.prototype.increaseMinute = function () {
+        this.time = this.time.clone().add(1, 'm');
+    };
+    TimePickerComponent.prototype.decreaseMinute = function () {
+        this.time = this.time.clone().subtract(1, 'm');
+    };
+    TimePickerComponent.prototype.increaseSecond = function () {
+        this.time = this.time.clone().add(1, 's');
+    };
+    TimePickerComponent.prototype.decreaseSecond = function () {
+        this.time = this.time.clone().subtract(1, 's');
+    };
+    TimePickerComponent.prototype.selectTime = function () {
+        var selectTime = this.parseToReturnObjectType(this.time);
+        this.onSelectTime.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    };
+    TimePickerComponent.prototype.selectNow = function () {
+        var selectTime = this.parseToReturnObjectType(moment());
+        this.onSelectTime.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    };
+    TimePickerComponent.prototype.clearTime = function () {
+        this.onSelectTime.emit(null);
+        this.cancelTimePicker();
+        return;
+    };
+    TimePickerComponent.prototype.cancelTimePicker = function () {
+        this.onTimePickerCancel.emit(false);
+        return;
+    };
+    TimePickerComponent.prototype.parseToReturnObjectType = function (time) {
+        switch (this.returnObject) {
+            case 'js':
+                return time.toDate();
+            case 'string':
+                return time.format(this.viewFormat);
+            case 'moment':
+                return time;
+            case 'json':
+                return time.toJSON();
+            case 'array':
+                return time.toArray();
+            case 'iso':
+                return time.toISOString();
+            case 'object':
+                return time.toObject();
+            default:
+                return time;
+        }
+    };
+    TimePickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'time-picker',
+                    template: "<picker-modal (onOverlayClick)=\"cancelTimePicker()\">\n  <div class=\"picker-wrap\">\n    <div class=\"picker-box\">\n      <div class=\"picker-header\">Time Picker</div>\n      <div class=\"picker-table\">\n        <ul class=\"picker-table-time\">\n          <li class=\"picker-table-number hour\">\n            <span class=\"arrow up\" (click)=\"increaseHour()\"></span>\n            {{ time | moment: hourFormat }}\n            <span class=\"arrow down\" (click)=\"decreaseHour()\"></span>\n          </li>\n          <li class=\"picker-table-separator\">:</li>\n          <li class=\"picker-table-number minute\">\n            <span class=\"arrow up\" (click)=\"increaseMinute()\"></span>\n            {{ time | moment: 'mm' }}\n            <span class=\"arrow down\" (click)=\"decreaseMinute()\"></span>\n          </li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-separator\">:</li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-number second\">\n            <span class=\"arrow up\" (click)=\"increaseSecond()\"></span>\n            {{ time | moment: 'ss' }}\n            <span class=\"arrow down\" (click)=\"decreaseSecond()\"></span>\n          </li>\n          <li *ngIf=\"use12Hour\" class=\"picker-table-meridiem meridiem\">\n            {{ time | moment: 'A' }}\n          </li>\n        </ul>\n      </div>\n      <div class=\"picker-footer\">\n        <div class=\"picker-action action-now\" (click)=\"selectNow()\">\n          <span class=\"text\">Now</span>\n        </div>\n        <div class=\"picker-action action-confirm\" (click)=\"selectTime()\">\n          <span class=\"text\">Confirm</span>\n        </div>\n        <div class=\"picker-action action-clear\" (click)=\"clearTime()\">\n          <span class=\"text\">Clear</span>\n        </div>\n        <div class=\"picker-action action-close\" (click)=\"cancelTimePicker()\">\n          <span class=\"text\">Close</span>\n        </div>\n      </div>\n    </div>\n  </div>\n</picker-modal>\n",
+                    styles: ["*,::after,::before{box-sizing:border-box}.picker-wrap{width:95vw;max-width:40rem;font-family:'Open Sans'}.picker-box{width:100%;padding:.625rem 1rem;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.picker-footer,.picker-header{font-size:1.333rem;line-height:2.5rem;height:2.5rem;width:100%}.picker-header{text-align:center}.picker-table{width:100%;margin:2.5rem 0}.picker-table-time{font-size:2.37rem;line-height:2.5rem;list-style:none;margin:0;padding:0;display:flex;justify-content:center;width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.picker-table-meridiem,.picker-table-number,.picker-table-separator{text-align:center}.picker-table-meridiem,.picker-table-number{position:relative;width:20%}.arrow{position:absolute;left:50%;border:solid #777;border-width:0 .2rem .2rem 0;display:inline-block;padding:.25rem;cursor:pointer}.arrow.up{top:-1rem;-webkit-transform:translateX(-50%) rotate(-135deg);transform:translateX(-50%) rotate(-135deg)}.arrow.down{bottom:-1rem;-webkit-transform:translateX(-50%) rotate(45deg);transform:translateX(-50%) rotate(45deg)}.arrow:hover{border-color:#1975d2}.picker-table-separator{width:calc(20% / 3)}.picker-footer{display:flex;justify-content:center;width:100%;cursor:pointer}.picker-footer .picker-action{width:25%;text-align:center}.picker-footer .picker-action:hover{background-color:#b1dcfb}.picker-footer .picker-action .text{padding-left:.8rem}.picker-footer .action-clear::before,.picker-footer .action-close::before,.picker-footer .action-confirm::before,.picker-footer .action-now::before{content:' ';position:relative;display:inline-block;height:0;width:0}.picker-footer .action-now::before{border-top:.66em solid #0059bc;border-left:.66em solid transparent}.picker-footer .action-confirm::before{width:1rem;height:1rem;border-radius:100%;background-color:#00b5ad}.picker-footer .action-clear::before{top:-.5rem;width:1rem;border-top:3px solid #e20}.picker-footer .action-close::before{width:1rem;height:1rem;background:linear-gradient(to bottom,transparent 35%,#777 35%,#777 65%,transparent 65%),linear-gradient(to right,transparent 35%,#777 35%,#777 65%,transparent 65%);-webkit-transform:rotate(45deg);transform:rotate(45deg)}"]
+                },] },
+    ];
+    /** @nocollapse */
+    TimePickerComponent.ctorParameters = function () { return []; };
+    TimePickerComponent.propDecorators = {
+        initTime: [{ type: Input }],
+        showSecond: [{ type: Input }],
+        viewFormat: [{ type: Input }],
+        use12Hour: [{ type: Input }],
+        returnObject: [{ type: Input }],
+        onSelectTime: [{ type: Output }],
+        onTimePickerCancel: [{ type: Output }]
+    };
+    return TimePickerComponent;
+}());
+export { TimePickerComponent };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-picker.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/date-time-picker/time-picker/time-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * time-picker.component\n */\n\nimport { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\nimport * as moment_ from 'moment';\n\nconst moment = moment_;\nimport { Moment } from 'moment/moment';\n\n// webpack1_\ndeclare let require: any;\n// const myDpStyles: string = require('./time-picker.component.css');\n// const myDpTpl: string = require('./time-picker.component.html');\n// webpack2_\n\n@Component({\n  selector: 'time-picker',\n  template: `<picker-modal (onOverlayClick)=\"cancelTimePicker()\">\n  <div class=\"picker-wrap\">\n    <div class=\"picker-box\">\n      <div class=\"picker-header\">Time Picker</div>\n      <div class=\"picker-table\">\n        <ul class=\"picker-table-time\">\n          <li class=\"picker-table-number hour\">\n            <span class=\"arrow up\" (click)=\"increaseHour()\"></span>\n            {{ time | moment: hourFormat }}\n            <span class=\"arrow down\" (click)=\"decreaseHour()\"></span>\n          </li>\n          <li class=\"picker-table-separator\">:</li>\n          <li class=\"picker-table-number minute\">\n            <span class=\"arrow up\" (click)=\"increaseMinute()\"></span>\n            {{ time | moment: 'mm' }}\n            <span class=\"arrow down\" (click)=\"decreaseMinute()\"></span>\n          </li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-separator\">:</li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-number second\">\n            <span class=\"arrow up\" (click)=\"increaseSecond()\"></span>\n            {{ time | moment: 'ss' }}\n            <span class=\"arrow down\" (click)=\"decreaseSecond()\"></span>\n          </li>\n          <li *ngIf=\"use12Hour\" class=\"picker-table-meridiem meridiem\">\n            {{ time | moment: 'A' }}\n          </li>\n        </ul>\n      </div>\n      <div class=\"picker-footer\">\n        <div class=\"picker-action action-now\" (click)=\"selectNow()\">\n          <span class=\"text\">Now</span>\n        </div>\n        <div class=\"picker-action action-confirm\" (click)=\"selectTime()\">\n          <span class=\"text\">Confirm</span>\n        </div>\n        <div class=\"picker-action action-clear\" (click)=\"clearTime()\">\n          <span class=\"text\">Clear</span>\n        </div>\n        <div class=\"picker-action action-close\" (click)=\"cancelTimePicker()\">\n          <span class=\"text\">Close</span>\n        </div>\n      </div>\n    </div>\n  </div>\n</picker-modal>\n`,\n  styles: [`*,::after,::before{box-sizing:border-box}.picker-wrap{width:95vw;max-width:40rem;font-family:'Open Sans'}.picker-box{width:100%;padding:.625rem 1rem;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.picker-footer,.picker-header{font-size:1.333rem;line-height:2.5rem;height:2.5rem;width:100%}.picker-header{text-align:center}.picker-table{width:100%;margin:2.5rem 0}.picker-table-time{font-size:2.37rem;line-height:2.5rem;list-style:none;margin:0;padding:0;display:flex;justify-content:center;width:100%;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.picker-table-meridiem,.picker-table-number,.picker-table-separator{text-align:center}.picker-table-meridiem,.picker-table-number{position:relative;width:20%}.arrow{position:absolute;left:50%;border:solid #777;border-width:0 .2rem .2rem 0;display:inline-block;padding:.25rem;cursor:pointer}.arrow.up{top:-1rem;-webkit-transform:translateX(-50%) rotate(-135deg);transform:translateX(-50%) rotate(-135deg)}.arrow.down{bottom:-1rem;-webkit-transform:translateX(-50%) rotate(45deg);transform:translateX(-50%) rotate(45deg)}.arrow:hover{border-color:#1975d2}.picker-table-separator{width:calc(20% / 3)}.picker-footer{display:flex;justify-content:center;width:100%;cursor:pointer}.picker-footer .picker-action{width:25%;text-align:center}.picker-footer .picker-action:hover{background-color:#b1dcfb}.picker-footer .picker-action .text{padding-left:.8rem}.picker-footer .action-clear::before,.picker-footer .action-close::before,.picker-footer .action-confirm::before,.picker-footer .action-now::before{content:' ';position:relative;display:inline-block;height:0;width:0}.picker-footer .action-now::before{border-top:.66em solid #0059bc;border-left:.66em solid transparent}.picker-footer .action-confirm::before{width:1rem;height:1rem;border-radius:100%;background-color:#00b5ad}.picker-footer .action-clear::before{top:-.5rem;width:1rem;border-top:3px solid #e20}.picker-footer .action-close::before{width:1rem;height:1rem;background:linear-gradient(to bottom,transparent 35%,#777 35%,#777 65%,transparent 65%),linear-gradient(to right,transparent 35%,#777 35%,#777 65%,transparent 65%);-webkit-transform:rotate(45deg);transform:rotate(45deg)}`]\n})\nexport class TimePickerComponent implements OnInit {\n  @Input() initTime: any;\n  @Input() showSecond = true;\n  @Input() viewFormat = 'hh:mm A';\n  @Input() use12Hour = false;\n  @Input() returnObject = 'js';\n  @Output() onSelectTime = new EventEmitter<any>();\n  @Output() onTimePickerCancel = new EventEmitter<boolean>();\n  hourFormat = 'HH';\n  public time: Moment;\n\n  constructor() {}\n\n  ngOnInit(): void {\n    if (this.use12Hour) {\n      this.hourFormat = 'hh';\n    }\n    this.time = this.initTime\n      ? moment(this.initTime, this.viewFormat)\n      : moment();\n\n    // check if the input initDate has value\n    if (this.initTime) {\n      this.time =\n        this.returnObject === 'string'\n          ? moment(this.initTime, this.viewFormat)\n          : moment(this.initTime);\n    } else {\n      this.time = moment();\n    }\n  }\n\n  increaseHour(): void {\n    this.time = this.time.clone().add(1, 'h');\n  }\n\n  decreaseHour(): void {\n    this.time = this.time.clone().subtract(1, 'h');\n  }\n\n  increaseMinute() {\n    this.time = this.time.clone().add(1, 'm');\n  }\n\n  decreaseMinute() {\n    this.time = this.time.clone().subtract(1, 'm');\n  }\n\n  increaseSecond(): void {\n    this.time = this.time.clone().add(1, 's');\n  }\n\n  decreaseSecond(): void {\n    this.time = this.time.clone().subtract(1, 's');\n  }\n\n  selectTime(): void {\n    const selectTime = this.parseToReturnObjectType(this.time);\n    this.onSelectTime.emit(selectTime);\n    this.cancelTimePicker();\n    return;\n  }\n\n  selectNow(): void {\n    const selectTime = this.parseToReturnObjectType(moment());\n    this.onSelectTime.emit(selectTime);\n    this.cancelTimePicker();\n    return;\n  }\n\n  clearTime(): void {\n    this.onSelectTime.emit(null);\n    this.cancelTimePicker();\n    return;\n  }\n\n  cancelTimePicker(): void {\n    this.onTimePickerCancel.emit(false);\n    return;\n  }\n\n  protected parseToReturnObjectType(time: Moment): any {\n    switch (this.returnObject) {\n      case 'js':\n        return time.toDate();\n\n      case 'string':\n        return time.format(this.viewFormat);\n\n      case 'moment':\n        return time;\n\n      case 'json':\n        return time.toJSON();\n\n      case 'array':\n        return time.toArray();\n\n      case 'iso':\n        return time.toISOString();\n\n      case 'object':\n        return time.toObject();\n\n      default:\n        return time;\n    }\n  }\n}\n"]}

package/esm5/components/file-upload/file-upload.component.js

@@ -0,0 +1,128 @@
+import * as tslib_1 from "tslib";
+import { Component, Input, forwardRef, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var FileUploadComponent = /** @class */ (function () {
+    function FileUploadComponent(renderer) {
+        this.renderer = renderer;
+        this.uploading = false;
+        this.fileUuid = null;
+        this.pdfUploaded = false;
+        this.formEntryMode = true;
+        // the method set in registerOnChange, it is just
+        // a placeholder for a method that takes one parameter,
+        // we use it to emit changes back to the form
+        this.propagateChange = function (_) { };
+    }
+    Object.defineProperty(FileUploadComponent.prototype, "dataSource", {
+        get: function () {
+            return this._dataSource;
+        },
+        set: function (v) {
+            this._dataSource = v;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    FileUploadComponent.prototype.ngOnInit = function () {
+        if (this.fileUuid) {
+            this.checkFileType();
+        }
+    };
+    FileUploadComponent.prototype.onFileChange = function (fileList) {
+        try {
+            for (var fileList_1 = tslib_1.__values(fileList), fileList_1_1 = fileList_1.next(); !fileList_1_1.done; fileList_1_1 = fileList_1.next()) {
+                var file = fileList_1_1.value;
+                this.upload(file);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (fileList_1_1 && !fileList_1_1.done && (_a = fileList_1.return)) _a.call(fileList_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        var e_1, _a;
+    };
+    FileUploadComponent.prototype.upload = function (data) {
+        var _this = this;
+        if (this.dataSource) {
+            this.uploading = true;
+            this.dataSource.fileUpload(data).subscribe(function (result) {
+                _this.fileUuid = result.image;
+                _this.checkFileType();
+                _this.propagateChange(_this.fileUuid);
+                _this.uploading = false;
+            }, function (error) {
+                _this.uploading = false;
+            });
+        }
+    };
+    // this is the initial value set to the component
+    FileUploadComponent.prototype.writeValue = function (value) {
+        if (value !== this.fileUuid) {
+            this.fileUuid = value;
+            this.checkFileType();
+        }
+    };
+    // registers 'fn' that will be fired when changes are made
+    // this is how we emit the changes back to the form
+    FileUploadComponent.prototype.registerOnChange = function (fn) {
+        this.propagateChange = fn;
+    };
+    // not used, used for touch input
+    FileUploadComponent.prototype.registerOnTouched = function () { };
+    // change events from the textarea
+    FileUploadComponent.prototype.onChange = function (event) {
+        this.propagateChange(event.id);
+        // .....
+        // update the form
+        // this.propagateChange(this.data);
+    };
+    FileUploadComponent.prototype.clearValue = function () {
+        this.fileUuid = null;
+        this.pdfUploaded = false;
+        this.pdfUrl = null;
+        this.propagateChange(this.fileUuid);
+    };
+    FileUploadComponent.prototype.getPdfUrl = function (fileUuid) {
+        var _this = this;
+        this.dataSource.fetchFile(fileUuid, 'pdf').subscribe(function (file) {
+            _this.pdfUploaded = true;
+            _this.pdfUrl = file.changingThisBreaksApplicationSecurity;
+        });
+    };
+    FileUploadComponent.prototype.checkFileType = function () {
+        var re = /pdf/gi;
+        if (this.fileUuid.search(re) !== -1) {
+            this.getPdfUrl(this.fileUuid);
+        }
+    };
+    FileUploadComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'app-file-upload',
+                    template: "<lib-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-file-uploader>\n<div *ngIf=\"fileUuid\">\n  <img\n    *ngIf=\"!pdfUploaded\"\n    class=\"img-responsive\"\n    [src]=\"fileUuid | secure: this.dataSource.fetchFile\"\n    alt=\"\"\n  />\n</div>\n",
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(function () { return FileUploadComponent; }),
+                            multi: true
+                        }
+                    ],
+                    styles: [
+                        "\n      img {\n        margin-left: auto;\n        margin-right: auto;\n        display: block;\n      }\n    "
+                    ]
+                },] },
+    ];
+    /** @nocollapse */
+    FileUploadComponent.ctorParameters = function () { return [
+        { type: Renderer2 }
+    ]; };
+    FileUploadComponent.propDecorators = {
+        dataSource: [{ type: Input }]
+    };
+    return FileUploadComponent;
+}());
+export { FileUploadComponent };
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-upload.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/file-upload/file-upload.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Component,\n  OnInit,\n  Input,\n  forwardRef,\n  Renderer2,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { DomSanitizer } from '@angular/platform-browser';\nimport { DataSource } from '../../form-entry/question-models/interfaces/data-source';\nimport { SecurePipe } from './secure.pipe';\n@Component({\n  selector: 'app-file-upload',\n  template: `<lib-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-file-uploader>\n<div *ngIf=\"fileUuid\">\n  <img\n    *ngIf=\"!pdfUploaded\"\n    class=\"img-responsive\"\n    [src]=\"fileUuid | secure: this.dataSource.fetchFile\"\n    alt=\"\"\n  />\n</div>\n`,\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: forwardRef(() => FileUploadComponent),\n      multi: true\n    }\n  ],\n  styles: [\n    `\n      img {\n        margin-left: auto;\n        margin-right: auto;\n        display: block;\n      }\n    `\n  ]\n})\nexport class FileUploadComponent implements OnInit, ControlValueAccessor {\n  uploading = false;\n  fileUuid = null;\n  pdfUploaded = false;\n  formEntryMode = true;\n  pdfUrl: string;\n  private _dataSource: DataSource;\n  @Input()\n  public get dataSource(): DataSource {\n    return this._dataSource;\n  }\n  public set dataSource(v: DataSource) {\n    this._dataSource = v;\n  }\n\n  constructor(private renderer: Renderer2) {}\n\n  ngOnInit() {\n    if (this.fileUuid) {\n      this.checkFileType();\n    }\n  }\n  public onFileChange(fileList) {\n    for (const file of fileList) {\n      this.upload(file);\n    }\n  }\n  upload(data) {\n    if (this.dataSource) {\n      this.uploading = true;\n      this.dataSource.fileUpload(data).subscribe(\n        (result) => {\n          this.fileUuid = result.image;\n          this.checkFileType();\n          this.propagateChange(this.fileUuid);\n          this.uploading = false;\n        },\n        (error) => {\n          this.uploading = false;\n        }\n      );\n    }\n  }\n\n  // this is the initial value set to the component\n  public writeValue(value: any) {\n    if (value !== this.fileUuid) {\n      this.fileUuid = value;\n      this.checkFileType();\n    }\n  }\n  // registers 'fn' that will be fired when changes are made\n  // this is how we emit the changes back to the form\n  public registerOnChange(fn: any) {\n    this.propagateChange = fn;\n  }\n\n  // not used, used for touch input\n  public registerOnTouched() {}\n  // change events from the textarea\n  onChange(event) {\n    this.propagateChange(event.id);\n    // .....\n    // update the form\n    // this.propagateChange(this.data);\n  }\n\n  // the method set in registerOnChange, it is just\n  // a placeholder for a method that takes one parameter,\n  // we use it to emit changes back to the form\n  private propagateChange = (_: any) => {};\n\n  public clearValue() {\n    this.fileUuid = null;\n    this.pdfUploaded = false;\n    this.pdfUrl = null;\n    this.propagateChange(this.fileUuid);\n  }\n\n  public getPdfUrl(fileUuid: string) {\n    this.dataSource.fetchFile(fileUuid, 'pdf').subscribe((file) => {\n      this.pdfUploaded = true;\n      this.pdfUrl = file.changingThisBreaksApplicationSecurity;\n    });\n  }\n  public checkFileType() {\n    const re = /pdf/gi;\n    if (this.fileUuid.search(re) !== -1) {\n      this.getPdfUrl(this.fileUuid);\n    }\n  }\n}\n"]}

package/esm5/components/file-upload/file-upload.module.js

@@ -0,0 +1,32 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { NgxFileUploaderModule } from 'ngx-file-uploader';
+import { SharedModule } from '../../shared.module';
+// import { SelectModule } from 'ng2-select/ng2-select';
+import { SelectModule } from '../../components/select/select.module';
+import { FileUploadComponent } from './file-upload.component';
+import { WebcamModule } from 'ngx-webcam';
+var RemoteFileUploadModule = /** @class */ (function () {
+    function RemoteFileUploadModule() {
+    }
+    RemoteFileUploadModule.decorators = [
+        { type: NgModule, args: [{
+                    imports: [
+                        CommonModule,
+                        SelectModule,
+                        FormsModule,
+                        SharedModule,
+                        WebcamModule,
+                        NgxFileUploaderModule
+                    ],
+                    exports: [FileUploadComponent],
+                    declarations: [FileUploadComponent],
+                    providers: []
+                },] },
+    ];
+    return RemoteFileUploadModule;
+}());
+export { RemoteFileUploadModule };
+
+//# sourceMappingURL=data:application/json;base64,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