@ampath-kenya/ngx-openmrs-formentry 2.12.11 → 2.12.13

package/esm5/components/appointments-overview/appointments-overview.component.js

@@ -0,0 +1,123 @@
+import { Component, Input } from '@angular/core';
+import { LeafNode } from '../../form-entry/form-factory/form-node';
+import * as moment_ from 'moment';
+var moment = moment_;
+var AppointmentsOverviewComponent = /** @class */ (function () {
+    function AppointmentsOverviewComponent() {
+        this.showAppointments = false;
+        this.loadingAppointments = false;
+        this.errorLoadingAppointments = false;
+        this.appointmentsLoaded = false;
+        this.appointments = [];
+        this.today = '';
+    }
+    AppointmentsOverviewComponent.prototype.ngOnInit = function () { };
+    AppointmentsOverviewComponent.prototype.ngOnChanges = function () {
+        var _this = this;
+        this.node.control.valueChanges.subscribe(function (v) {
+            _this.resetProperties();
+            var node = _this.node;
+            if (node.question.extras.questionOptions.concept &&
+                (node.question.extras.questionOptions.concept ===
+                    'a8a666ba-1350-11df-a1f1-0026b9348838' ||
+                    node.question.extras.questionOptions.concept ===
+                        'a89d2398-1350-11df-a1f1-0026b9348838')) {
+                // console.log('what change is here', this.showAppointments);
+                if (!_this.showAppointments) {
+                    _this.loadingAppointments = true;
+                    _this.showAppointments = true;
+                    var dataSource = void 0;
+                    if (node.form && node.form.dataSourcesContainer.dataSources) {
+                        dataSource =
+                            node.form.dataSourcesContainer.dataSources
+                                .monthlyScheduleResourceService;
+                    }
+                    var locationUuid = node.form.dataSourcesContainer.dataSources.userLocation.uuid;
+                    if (dataSource && locationUuid) {
+                        var startDate = moment(v)
+                            .startOf('week')
+                            .add(1, 'day')
+                            .format('YYYY-MM-DD');
+                        var endDate = moment(v)
+                            .endOf('week')
+                            .subtract(1, 'day')
+                            .format('YYYY-MM-DD');
+                        _this.today = moment(v).format('DD-MM-YYYY');
+                        // create 5 week days
+                        var _data_1 = [];
+                        var programTypes = [
+                            '781d85b0-1359-11df-a1f1-0026b9348838',
+                            '781d897a-1359-11df-a1f1-0026b9348838',
+                            '96047aaf-7ab3-45e9-be6a-b61810fe617d',
+                            'c19aec66-1a40-4588-9b03-b6be55a8dd1d',
+                            'f7793d42-11ac-4cfd-9b35-e0a21a7a7c31',
+                            '334c9e98-173f-4454-a8ce-f80b20b7fdf0',
+                            '96ba279b-b23b-4e78-aba9-dcbd46a96b7b',
+                            '781d8880-1359-11df-a1f1-0026b9348838'
+                        ];
+                        var programTypeParams = programTypes.join();
+                        for (var i = 1; i <= 5; i++) {
+                            _data_1.push({
+                                date: moment(v)
+                                    .startOf('week')
+                                    .add(i, 'day')
+                                    .format('DD-MM-YYYY'),
+                                count: 0
+                            });
+                        }
+                        dataSource
+                            .getMonthlySchedule({
+                            startDate: startDate,
+                            endDate: endDate,
+                            limit: 5,
+                            locationUuids: locationUuid,
+                            programType: programTypeParams
+                        })
+                            .subscribe(function (data) {
+                            _this.appointmentsLoaded = true;
+                            _this.loadingAppointments = false;
+                            _data_1.map(function (appointment, index) {
+                                appointment.count =
+                                    data.results[index] !== undefined
+                                        ? data.results[index].count.scheduled
+                                        : 0;
+                            });
+                            _this.appointments = _data_1;
+                        }, function (error) {
+                            _this.loadingAppointments = false;
+                            _this.errorLoadingAppointments = true;
+                            _this.showAppointments = false;
+                            console.error(error);
+                        });
+                    }
+                    else {
+                        _this.showAppointments = false;
+                        _this.errorLoadingAppointments = true;
+                    }
+                }
+            }
+        });
+    };
+    AppointmentsOverviewComponent.prototype.resetProperties = function () {
+        this.loadingAppointments = false;
+        this.appointmentsLoaded = false;
+        this.errorLoadingAppointments = false;
+        this.showAppointments = false;
+        this.appointments = [];
+        this.today = '';
+    };
+    AppointmentsOverviewComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'appointments-overview',
+                    template: "<div *ngIf=\"showAppointments\" class=\"appointments\">\n  <p *ngIf=\"loadingAppointments\">\n    <span *ngIf=\"!appointmentsLoaded && errorLoadingAppointments\"\n      >Error checking appointments</span\n    >\n    <span *ngIf=\"loadingAppointments\"\n      ><span class=\"fa fa-spinner fa-spin\"></span>Checking appointments...</span\n    >\n  </p>\n  <div *ngIf=\"appointmentsLoaded && !errorLoadingAppointments\">\n    <table\n      *ngIf=\"appointments.length > 0\"\n      class=\"table table-stripped table-bordered\"\n    >\n      <thead>\n        <tr>\n          <th\n            *ngFor=\"let appointment of appointments\"\n            [ngClass]=\"{ active: appointment.date === today }\"\n          >\n            <span>{{ appointment.date }}</span>\n          </th>\n        </tr>\n      </thead>\n      <tbody>\n        <tr>\n          <td\n            *ngFor=\"let appointment of appointments\"\n            [ngClass]=\"{ active: appointment.date === today }\"\n          >\n            <span\n              ><strong\n                ><em>{{ appointment.count }}</em></strong\n              ></span\n            >\n          </td>\n        </tr>\n      </tbody>\n    </table>\n  </div>\n</div>\n",
+                    styles: [".appointments{margin-top:12px;font-size:12px;color:#999}.appointments p{padding-top:12px}.appointments th{border-bottom:0!important;color:#333}.appointments td span,.appointments th span{display:block}.appointments td.active,.appointments th.active{background-color:#3c8dbc;color:#fff!important;padding:0}.appointments td.active span,.appointments th.active span{padding:4px}.appointments span.fa{display:inline-block;margin-right:7px}"]
+                },] },
+    ];
+    AppointmentsOverviewComponent.ctorParameters = function () { return []; };
+    AppointmentsOverviewComponent.propDecorators = {
+        node: [{ type: Input }]
+    };
+    return AppointmentsOverviewComponent;
+}());
+export { AppointmentsOverviewComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"appointments-overview.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/appointments-overview/appointments-overview.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, OnChanges, Input } from '@angular/core';\n\nimport { LeafNode } from '../../form-entry/form-factory/form-node';\nimport * as moment_ from 'moment';\n\nconst moment = moment_;\n\n@Component({\n  selector: 'appointments-overview',\n  template: `<div *ngIf=\"showAppointments\" class=\"appointments\">\n  <p *ngIf=\"loadingAppointments\">\n    <span *ngIf=\"!appointmentsLoaded && errorLoadingAppointments\"\n      >Error checking appointments</span\n    >\n    <span *ngIf=\"loadingAppointments\"\n      ><span class=\"fa fa-spinner fa-spin\"></span>Checking appointments...</span\n    >\n  </p>\n  <div *ngIf=\"appointmentsLoaded && !errorLoadingAppointments\">\n    <table\n      *ngIf=\"appointments.length > 0\"\n      class=\"table table-stripped table-bordered\"\n    >\n      <thead>\n        <tr>\n          <th\n            *ngFor=\"let appointment of appointments\"\n            [ngClass]=\"{ active: appointment.date === today }\"\n          >\n            <span>{{ appointment.date }}</span>\n          </th>\n        </tr>\n      </thead>\n      <tbody>\n        <tr>\n          <td\n            *ngFor=\"let appointment of appointments\"\n            [ngClass]=\"{ active: appointment.date === today }\"\n          >\n            <span\n              ><strong\n                ><em>{{ appointment.count }}</em></strong\n              ></span\n            >\n          </td>\n        </tr>\n      </tbody>\n    </table>\n  </div>\n</div>\n`,\n  styles: [`.appointments{margin-top:12px;font-size:12px;color:#999}.appointments p{padding-top:12px}.appointments th{border-bottom:0!important;color:#333}.appointments td span,.appointments th span{display:block}.appointments td.active,.appointments th.active{background-color:#3c8dbc;color:#fff!important;padding:0}.appointments td.active span,.appointments th.active span{padding:4px}.appointments span.fa{display:inline-block;margin-right:7px}`]\n})\nexport class AppointmentsOverviewComponent implements OnInit, OnChanges {\n  @Input() node: LeafNode;\n  showAppointments = false;\n  loadingAppointments = false;\n  errorLoadingAppointments = false;\n  appointmentsLoaded = false;\n  appointments: Array<any> = [];\n  today = '';\n  constructor() {}\n\n  ngOnInit() {}\n\n  ngOnChanges() {\n    this.node.control.valueChanges.subscribe((v) => {\n      this.resetProperties();\n      const node = this.node;\n      if (\n        node.question.extras.questionOptions.concept &&\n        (node.question.extras.questionOptions.concept ===\n          'a8a666ba-1350-11df-a1f1-0026b9348838' ||\n          node.question.extras.questionOptions.concept ===\n            'a89d2398-1350-11df-a1f1-0026b9348838')\n      ) {\n        // console.log('what change is here', this.showAppointments);\n        if (!this.showAppointments) {\n          this.loadingAppointments = true;\n          this.showAppointments = true;\n          let dataSource;\n          if (node.form && node.form.dataSourcesContainer.dataSources) {\n            dataSource =\n              node.form.dataSourcesContainer.dataSources\n                .monthlyScheduleResourceService;\n          }\n          const locationUuid =\n            node.form.dataSourcesContainer.dataSources.userLocation.uuid;\n          if (dataSource && locationUuid) {\n            const startDate = moment(v)\n              .startOf('week')\n              .add(1, 'day')\n              .format('YYYY-MM-DD');\n            const endDate = moment(v)\n              .endOf('week')\n              .subtract(1, 'day')\n              .format('YYYY-MM-DD');\n            this.today = moment(v).format('DD-MM-YYYY');\n            // create 5 week days\n            const _data = [];\n            const programTypes = [\n              '781d85b0-1359-11df-a1f1-0026b9348838',\n              '781d897a-1359-11df-a1f1-0026b9348838',\n              '96047aaf-7ab3-45e9-be6a-b61810fe617d',\n              'c19aec66-1a40-4588-9b03-b6be55a8dd1d',\n              'f7793d42-11ac-4cfd-9b35-e0a21a7a7c31',\n              '334c9e98-173f-4454-a8ce-f80b20b7fdf0',\n              '96ba279b-b23b-4e78-aba9-dcbd46a96b7b',\n              '781d8880-1359-11df-a1f1-0026b9348838'\n            ];\n            const programTypeParams = programTypes.join();\n            for (let i = 1; i <= 5; i++) {\n              _data.push({\n                date: moment(v)\n                  .startOf('week')\n                  .add(i, 'day')\n                  .format('DD-MM-YYYY'),\n                count: 0\n              });\n            }\n            dataSource\n              .getMonthlySchedule({\n                startDate: startDate,\n                endDate: endDate,\n                limit: 5,\n                locationUuids: locationUuid,\n                programType: programTypeParams\n              })\n              .subscribe(\n                (data) => {\n                  this.appointmentsLoaded = true;\n                  this.loadingAppointments = false;\n                  _data.map((appointment, index) => {\n                    appointment.count =\n                    data.results[index] !== undefined\n                        ? data.results[index].count.scheduled\n                        : 0;\n                  });\n                  this.appointments = _data;\n                },\n                (error) => {\n                  this.loadingAppointments = false;\n                  this.errorLoadingAppointments = true;\n                  this.showAppointments = false;\n                  console.error(error);\n                }\n              );\n          } else {\n            this.showAppointments = false;\n            this.errorLoadingAppointments = true;\n          }\n        }\n      }\n    });\n  }\n\n  resetProperties() {\n    this.loadingAppointments = false;\n    this.appointmentsLoaded = false;\n    this.errorLoadingAppointments = false;\n    this.showAppointments = false;\n    this.appointments = [];\n    this.today = '';\n  }\n}\n"]}

package/esm5/components/check-box/checkbox.component.js

@@ -0,0 +1,88 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+var CheckboxControlComponent = /** @class */ (function () {
+    function CheckboxControlComponent() {
+        this._value = [];
+        this.onChange = function (change) { };
+        this.onTouched = function () { };
+    }
+    CheckboxControlComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.options = this.options.map(function (option) {
+            if (_this.selected.indexOf(option.value) !== -1) {
+                Object.assign(option, { checked: true });
+            }
+            return option;
+        });
+    };
+    CheckboxControlComponent.prototype.ngAfterViewInit = function () { };
+    CheckboxControlComponent.prototype.writeValue = function (value) {
+        this.value = value;
+    };
+    CheckboxControlComponent.prototype.registerOnChange = function (fn) {
+        this.onChange = fn;
+    };
+    CheckboxControlComponent.prototype.registerOnTouched = function (fn) {
+        this.onTouched = fn;
+    };
+    Object.defineProperty(CheckboxControlComponent.prototype, "value", {
+        get: function () {
+            if (this._value.length === 0) {
+                return '';
+            }
+            else {
+                return this._value || this._value[0];
+            }
+        },
+        set: function (v) {
+            if (typeof v === 'undefined' || v === null || v === '') {
+                v = [];
+            }
+            else if (typeof v === 'string') {
+                v = [v];
+            }
+            else if (!Array.isArray(v)) {
+                throw new TypeError('Value must be a string or an array.');
+            }
+        },
+        enumerable: true,
+        configurable: true
+    });
+    CheckboxControlComponent.prototype.selectOpt = function (option, event) {
+        var _this = this;
+        if (event.target.checked) {
+            this._value.push(option.value);
+        }
+        else {
+            this.options.forEach(function (o) {
+                if (o.value === option.value) {
+                    _this._value.splice(o, 1);
+                }
+            });
+        }
+        this.onChange(this.value);
+    };
+    CheckboxControlComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'checkbox',
+                    template: "<div *ngFor=\"let option of options; let i = index\">\n  <label class=\"form-control no-border\">\n    <input\n      type=\"checkbox\"\n      id=\"i + 'id'\"\n      (change)=\"selectOpt(option, $event)\"\n      value=\"option.value\"\n      [checked]=\"option.checked\"\n    />\n    {{ option.label }}\n  </label>\n</div>\n",
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(function () { return CheckboxControlComponent; }),
+                            multi: true
+                        }
+                    ],
+                    styles: [
+                        "\n      .no-border {\n        border: 0;\n        box-shadow: none;\n      }\n    "
+                    ]
+                },] },
+    ];
+    CheckboxControlComponent.propDecorators = {
+        options: [{ type: Input }],
+        selected: [{ type: Input }]
+    };
+    return CheckboxControlComponent;
+}());
+export { CheckboxControlComponent };
+//# sourceMappingURL=data:application/json;base64,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

package/esm5/components/check-box/checkbox.module.js

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { CheckboxControlComponent } from './checkbox.component';
+var CheckboxModule = /** @class */ (function () {
+    function CheckboxModule() {
+    }
+    CheckboxModule.decorators = [
+        { type: NgModule, args: [{
+                    declarations: [CheckboxControlComponent],
+                    exports: [CheckboxControlComponent],
+                    imports: [CommonModule, FormsModule]
+                },] },
+    ];
+    return CheckboxModule;
+}());
+export { CheckboxModule };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hlY2tib3gubW9kdWxlLmpzIiwic291cmNlUm9vdCI6Im5nOi8vQGFtcGF0aC1rZW55YS9uZ3gtb3Blbm1ycy1mb3JtZW50cnkvIiwic291cmNlcyI6WyJjb21wb25lbnRzL2NoZWNrLWJveC9jaGVja2JveC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRWhFO0lBQUE7SUFLNkIsQ0FBQzs7Z0JBTDdCLFFBQVEsU0FBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyx3QkFBd0IsQ0FBQztvQkFDeEMsT0FBTyxFQUFFLENBQUMsd0JBQXdCLENBQUM7b0JBQ25DLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLENBQUM7aUJBQ3JDOztJQUM0QixxQkFBQztDQUFBLEFBTDlCLElBSzhCO1NBQWpCLGNBQWMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBDaGVja2JveENvbnRyb2xDb21wb25lbnQgfSBmcm9tICcuL2NoZWNrYm94LmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW0NoZWNrYm94Q29udHJvbENvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtDaGVja2JveENvbnRyb2xDb21wb25lbnRdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgQ2hlY2tib3hNb2R1bGUge31cbiJdfQ==

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

@@ -0,0 +1,186 @@
+/**
+ * date-picker.component
+ */
+import { Component, Output, EventEmitter, Input } from '@angular/core';
+import * as moment_ from 'moment';
+var moment = moment_;
+import * as _ from 'lodash';
+// const myDpStyles: string = require('./date-picker.component.css');
+// const myDpTpl: string = require('./date-picker.component.html');
+// webpack2_
+var DatePickerComponent = /** @class */ (function () {
+    function DatePickerComponent() {
+        this.locale = 'en';
+        this.viewFormat = 'll';
+        this.returnObject = 'js';
+        this.onDatePickerCancel = new EventEmitter();
+        this.onSelectDate = new EventEmitter();
+        this.onDisplayMonths = false;
+        this.onDisplayYears = false;
+        this.displayYearsIndex = 0;
+        this.monthsShort = moment.monthsShort();
+    }
+    DatePickerComponent.prototype.ngOnInit = function () {
+        var _this = this;
+        this.initValue();
+        // default to current year range
+        _.each(this.fullYearRange, function (v, i) {
+            _this.currentYear = _this.calendarDate.clone().startOf('year').year();
+            if (v.indexOf(_this.currentYear) !== -1) {
+                _this.displayYearsIndex = i;
+            }
+        });
+        this.displayYearRange = this.fullYearRange[this.displayYearsIndex];
+        this.generateCalendar();
+    };
+    DatePickerComponent.prototype.prev = function () {
+        if (this.onDisplayYears) {
+            this.displayYearsIndex--;
+            if (this.displayYearsIndex < 0) {
+                this.displayYearsIndex = 0;
+            }
+            this.displayYearRange = this.fullYearRange[this.displayYearsIndex];
+        }
+        else {
+            this.calendarDate = this.calendarDate.clone().subtract(1, 'M');
+        }
+        this.generateCalendar();
+    };
+    DatePickerComponent.prototype.showMonthSelection = function () {
+        this.onDisplayMonths = true;
+        this.onDisplayYears = false;
+    };
+    DatePickerComponent.prototype.showYearSelection = function () {
+        this.onDisplayYears = true;
+        this.onDisplayMonths = false;
+    };
+    DatePickerComponent.prototype.next = function () {
+        if (this.onDisplayYears) {
+            this.displayYearsIndex++;
+            if (this.displayYearsIndex >= this.fullYearRange.length) {
+                this.displayYearsIndex = this.fullYearRange.length - 1;
+            }
+            this.displayYearRange = this.fullYearRange[this.displayYearsIndex++];
+        }
+        else {
+            this.calendarDate = this.calendarDate.clone().add(1, 'M');
+        }
+        this.generateCalendar();
+    };
+    DatePickerComponent.prototype.selectDay = function (day) {
+        var daysDifference = day.diff(this.calendarDate.clone().startOf('date'), 'days');
+        day = this.calendarDate.clone().add(daysDifference, 'd');
+        var selectedDay = this.parseToReturnObjectType(day);
+        this.onSelectDate.emit(selectedDay);
+        this.cancelDatePicker();
+        return;
+    };
+    DatePickerComponent.prototype.selectMonth = function (month) {
+        this.calendarDate = this.calendarDate.clone().month(month);
+        this.onDisplayMonths = false;
+        this.generateCalendar();
+    };
+    DatePickerComponent.prototype.selectYear = function (year) {
+        this.calendarDate = this.calendarDate.clone().year(year);
+        this.onDisplayYears = false;
+        this.generateCalendar();
+    };
+    DatePickerComponent.prototype.selectToday = function () {
+        var today = this.parseToReturnObjectType(moment());
+        this.onSelectDate.emit(today);
+        this.cancelDatePicker();
+        return;
+    };
+    DatePickerComponent.prototype.clearPickDate = function () {
+        this.onSelectDate.emit(null);
+        this.cancelDatePicker();
+        return;
+    };
+    DatePickerComponent.prototype.cancelDatePicker = function () {
+        this.onDatePickerCancel.emit(false);
+        return;
+    };
+    DatePickerComponent.prototype.generateYears = function () {
+        var currentYear = moment().year();
+        var startYr = this.calendarDate.clone().subtract(100, 'y').year();
+        // const endYr = this.calendarDate.clone().add(10, 'y').year();
+        var years = [];
+        for (var year = startYr; year <= currentYear; year++) {
+            years.push(year);
+        }
+        this.fullYearRange = _.chunk(years, 14);
+    };
+    DatePickerComponent.prototype.initValue = function () {
+        // set moment locale (default is en)
+        moment.locale(this.locale);
+        // set today value
+        this.today = moment().startOf('date');
+        this.currentMonth = this.monthsShort[moment().month()];
+        this.currentYear = moment().year();
+        // set week days name array
+        this.dayNames = moment.weekdaysShort(true);
+        // check if the input initDate has value
+        if (this.initDate) {
+            this.calendarDate =
+                this.returnObject === 'string'
+                    ? moment(this.initDate, this.viewFormat)
+                    : moment(this.initDate);
+            this.selectedDate = this.calendarDate.clone().startOf('date');
+        }
+        else {
+            this.calendarDate = moment();
+        }
+        this.generateYears();
+    };
+    DatePickerComponent.prototype.generateCalendar = function () {
+        this.calendarDays = [];
+        var start = 0 -
+            ((this.calendarDate.clone().startOf('month').day() +
+                (7 - moment.localeData().firstDayOfWeek())) %
+                7);
+        var end = 41 + start; // iterator ending point
+        for (var i = start; i <= end; i += 1) {
+            var day = this.calendarDate.clone().startOf('month').add(i, 'days');
+            this.calendarDays.push(day);
+        }
+    };
+    DatePickerComponent.prototype.parseToReturnObjectType = function (day) {
+        switch (this.returnObject) {
+            case 'js':
+                return day.toDate();
+            case 'string':
+                return day.format(this.viewFormat);
+            case 'moment':
+                return day;
+            case 'json':
+                return day.toJSON();
+            case 'array':
+                return day.toArray();
+            case 'iso':
+                return day.toISOString();
+            case 'object':
+                return day.toObject();
+            default:
+                return day;
+        }
+    };
+    DatePickerComponent.decorators = [
+        { type: Component, args: [{
+                    selector: 'date-picker',
+                    template: "<picker-modal (onOverlayClick)=\"cancelDatePicker()\">\n  <div class=\"picker-wrap\">\n    <div class=\"picker-box\">\n      <div class=\"picker-header\">\n        <div class=\"picker-header-nav\">\n          <span class=\"nav-prev\" (click)=\"prev()\"></span>\n        </div>\n        <div class=\"picker-header-content\">\n          <div class=\"content\">\n            <span (click)=\"showMonthSelection()\" class=\"month\">{{\n              calendarDate | moment: 'MMMM'\n            }}</span>\n            <span class=\"seperator\">|</span>\n            <span (click)=\"showYearSelection()\" class=\"year\">{{\n              calendarDate | moment: 'YYYY'\n            }}</span>\n          </div>\n        </div>\n        <div class=\"picker-header-nav\">\n          <span class=\"nav-next\" (click)=\"next()\"></span>\n        </div>\n      </div>\n      <div class=\"picker-calendar\">\n        <div\n          class=\"picker-calendar-row\"\n          *ngIf=\"!onDisplayMonths && !onDisplayYears\"\n        >\n          <span class=\"picker-weekday\" *ngFor=\"let day of dayNames\">{{\n            day\n          }}</span>\n        </div>\n        <div\n          class=\"picker-calendar-row\"\n          *ngIf=\"!onDisplayMonths && !onDisplayYears\"\n        >\n          <span\n            class=\"picker-day\"\n            (click)=\"selectDay(day)\"\n            [ngClass]=\"{\n              'out-focus': day.month() != calendarDate.month(),\n              today: day.isSame(today),\n              selected: day.isSame(selectedDate)\n            }\"\n            *ngFor=\"let day of calendarDays\"\n          >\n            {{ day | moment: 'D' }}\n          </span>\n        </div>\n        <div class=\"picker-calendar-row\" *ngIf=\"onDisplayMonths\">\n          <span\n            class=\"picker-month\"\n            *ngFor=\"let month of monthsShort\"\n            (click)=\"selectMonth(month)\"\n            [ngClass]=\"{\n              selected: month === currentMonth\n            }\"\n          >\n            {{ month }}\n          </span>\n        </div>\n        <div class=\"picker-calendar-row\" *ngIf=\"onDisplayYears\">\n          <span\n            class=\"picker-year\"\n            *ngFor=\"let year of displayYearRange\"\n            (click)=\"selectYear(year)\"\n            [ngClass]=\"{\n              selected: year === currentYear\n            }\"\n          >\n            {{ year }}\n          </span>\n        </div>\n      </div>\n      <div class=\"picker-footer\">\n        <div class=\"picker-action action-today\" (click)=\"selectToday()\">\n          <span class=\"text\">Today</span>\n        </div>\n        <div class=\"picker-action action-clear\" (click)=\"clearPickDate()\">\n          <span class=\"text\">Clear</span>\n        </div>\n        <div class=\"picker-action action-close\" (click)=\"cancelDatePicker()\">\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:666px}.picker-box{font-family:'Open Sans';min-width:400px!important;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;display:flex;height:2.5rem;width:100%}.picker-header-nav{position:relative;cursor:pointer;width:calc(100% / 8)}.picker-header-nav>*{position:absolute;top:50%;right:auto;bottom:auto;left:50%;-webkit-transform:translate(-50%,-50%);transform:translate(-50%,-50%)}.picker-header-nav .nav-next::before,.picker-header-nav .nav-prev::before{content:' ';border-top:.5em solid transparent;border-bottom:.5em solid transparent;border-right:.75em solid #000;width:0;height:0;display:block;margin:0 auto}.picker-header-nav .nav-next::before{border-right:0;border-left:.75em solid #000}.picker-header-content{width:calc(100% * 6 / 8);text-align:center}.picker-header-content .month{font-size:1.778rem;line-height:2.5rem;margin-right:.5rem;font-weight:700}.picker-header-content .year{font-style:italic;color:#999}.picker-calendar{width:100%}.picker-calendar .picker-calendar-row{display:flex;flex-wrap:wrap;width:100%;margin-bottom:.625rem}.picker-calendar .picker-weekday{font-weight:700;text-align:left;color:#999;width:calc(100% / 7)}.picker-calendar .picker-day,.picker-calendar .picker-month,.picker-calendar .picker-year{font-size:1.333rem;line-height:2.5rem;position:relative;height:2.5rem;text-align:center;cursor:pointer;width:calc(100% / 7)}.picker-calendar .picker-day:hover,.picker-calendar .picker-month:hover,.picker-calendar .picker-year:hover{background:#b1dcfb}.picker-calendar .out-focus{color:#ddd}.picker-calendar .out-focus:hover{color:#000}.picker-calendar .selected{background:#0089ec;color:#fff}.picker-calendar .selected:hover{background:#0089ec}.picker-calendar .today::before{content:' ';position:absolute;top:2px;right:2px;width:0;height:0;border-top:.5em solid #0059bc;border-left:.5em solid transparent}.picker-footer{cursor:pointer}.picker-footer .picker-action{text-align:center;width:calc(100% / 3)}.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-today::before{content:' ';position:relative;display:inline-block;height:0;width:0}.picker-footer .action-today::before{border-top:.66em solid #0059bc;border-left:.66em solid transparent}.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)}"]
+                },] },
+    ];
+    DatePickerComponent.ctorParameters = function () { return []; };
+    DatePickerComponent.propDecorators = {
+        initDate: [{ type: Input }],
+        locale: [{ type: Input }],
+        viewFormat: [{ type: Input }],
+        returnObject: [{ type: Input }],
+        onDatePickerCancel: [{ type: Output }],
+        onSelectDate: [{ type: Output }]
+    };
+    return DatePickerComponent;
+}());
+export { DatePickerComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-picker.component.js","sourceRoot":"ng://@ampath-kenya/ngx-openmrs-formentry/","sources":["components/date-time-picker/date-picker/date-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * date-picker.component\n */\n\nimport { Component, OnInit, Output, EventEmitter, Input } from '@angular/core';\nimport * as moment_ from 'moment';\n\nconst moment = moment_;\nimport * as _ from 'lodash';\nimport { Moment } from 'moment/moment';\n\n// webpack1_\ndeclare let require: any;\n// const myDpStyles: string = require('./date-picker.component.css');\n// const myDpTpl: string = require('./date-picker.component.html');\n// webpack2_\n\n@Component({\n  selector: 'date-picker',\n  template: `<picker-modal (onOverlayClick)=\"cancelDatePicker()\">\n  <div class=\"picker-wrap\">\n    <div class=\"picker-box\">\n      <div class=\"picker-header\">\n        <div class=\"picker-header-nav\">\n          <span class=\"nav-prev\" (click)=\"prev()\"></span>\n        </div>\n        <div class=\"picker-header-content\">\n          <div class=\"content\">\n            <span (click)=\"showMonthSelection()\" class=\"month\">{{\n              calendarDate | moment: 'MMMM'\n            }}</span>\n            <span class=\"seperator\">|</span>\n            <span (click)=\"showYearSelection()\" class=\"year\">{{\n              calendarDate | moment: 'YYYY'\n            }}</span>\n          </div>\n        </div>\n        <div class=\"picker-header-nav\">\n          <span class=\"nav-next\" (click)=\"next()\"></span>\n        </div>\n      </div>\n      <div class=\"picker-calendar\">\n        <div\n          class=\"picker-calendar-row\"\n          *ngIf=\"!onDisplayMonths && !onDisplayYears\"\n        >\n          <span class=\"picker-weekday\" *ngFor=\"let day of dayNames\">{{\n            day\n          }}</span>\n        </div>\n        <div\n          class=\"picker-calendar-row\"\n          *ngIf=\"!onDisplayMonths && !onDisplayYears\"\n        >\n          <span\n            class=\"picker-day\"\n            (click)=\"selectDay(day)\"\n            [ngClass]=\"{\n              'out-focus': day.month() != calendarDate.month(),\n              today: day.isSame(today),\n              selected: day.isSame(selectedDate)\n            }\"\n            *ngFor=\"let day of calendarDays\"\n          >\n            {{ day | moment: 'D' }}\n          </span>\n        </div>\n        <div class=\"picker-calendar-row\" *ngIf=\"onDisplayMonths\">\n          <span\n            class=\"picker-month\"\n            *ngFor=\"let month of monthsShort\"\n            (click)=\"selectMonth(month)\"\n            [ngClass]=\"{\n              selected: month === currentMonth\n            }\"\n          >\n            {{ month }}\n          </span>\n        </div>\n        <div class=\"picker-calendar-row\" *ngIf=\"onDisplayYears\">\n          <span\n            class=\"picker-year\"\n            *ngFor=\"let year of displayYearRange\"\n            (click)=\"selectYear(year)\"\n            [ngClass]=\"{\n              selected: year === currentYear\n            }\"\n          >\n            {{ year }}\n          </span>\n        </div>\n      </div>\n      <div class=\"picker-footer\">\n        <div class=\"picker-action action-today\" (click)=\"selectToday()\">\n          <span class=\"text\">Today</span>\n        </div>\n        <div class=\"picker-action action-clear\" (click)=\"clearPickDate()\">\n          <span class=\"text\">Clear</span>\n        </div>\n        <div class=\"picker-action action-close\" (click)=\"cancelDatePicker()\">\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:666px}.picker-box{font-family:'Open Sans';min-width:400px!important;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;display:flex;height:2.5rem;width:100%}.picker-header-nav{position:relative;cursor:pointer;width:calc(100% / 8)}.picker-header-nav>*{position:absolute;top:50%;right:auto;bottom:auto;left:50%;-webkit-transform:translate(-50%,-50%);transform:translate(-50%,-50%)}.picker-header-nav .nav-next::before,.picker-header-nav .nav-prev::before{content:' ';border-top:.5em solid transparent;border-bottom:.5em solid transparent;border-right:.75em solid #000;width:0;height:0;display:block;margin:0 auto}.picker-header-nav .nav-next::before{border-right:0;border-left:.75em solid #000}.picker-header-content{width:calc(100% * 6 / 8);text-align:center}.picker-header-content .month{font-size:1.778rem;line-height:2.5rem;margin-right:.5rem;font-weight:700}.picker-header-content .year{font-style:italic;color:#999}.picker-calendar{width:100%}.picker-calendar .picker-calendar-row{display:flex;flex-wrap:wrap;width:100%;margin-bottom:.625rem}.picker-calendar .picker-weekday{font-weight:700;text-align:left;color:#999;width:calc(100% / 7)}.picker-calendar .picker-day,.picker-calendar .picker-month,.picker-calendar .picker-year{font-size:1.333rem;line-height:2.5rem;position:relative;height:2.5rem;text-align:center;cursor:pointer;width:calc(100% / 7)}.picker-calendar .picker-day:hover,.picker-calendar .picker-month:hover,.picker-calendar .picker-year:hover{background:#b1dcfb}.picker-calendar .out-focus{color:#ddd}.picker-calendar .out-focus:hover{color:#000}.picker-calendar .selected{background:#0089ec;color:#fff}.picker-calendar .selected:hover{background:#0089ec}.picker-calendar .today::before{content:' ';position:absolute;top:2px;right:2px;width:0;height:0;border-top:.5em solid #0059bc;border-left:.5em solid transparent}.picker-footer{cursor:pointer}.picker-footer .picker-action{text-align:center;width:calc(100% / 3)}.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-today::before{content:' ';position:relative;display:inline-block;height:0;width:0}.picker-footer .action-today::before{border-top:.66em solid #0059bc;border-left:.66em solid transparent}.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 DatePickerComponent implements OnInit {\n  public dayNames: Array<string>;\n\n  @Input() public initDate: any;\n  @Input() public locale = 'en';\n  @Input() public viewFormat = 'll';\n  @Input() public returnObject = 'js';\n  @Output() public onDatePickerCancel = new EventEmitter<boolean>();\n  @Output() public onSelectDate = new EventEmitter<any>();\n\n  public calendarDate: Moment;\n  public selectedDate: Moment;\n  public currentMonth: any;\n  public today: Moment;\n  public currentYear: number;\n  public onDisplayMonths = false;\n  public onDisplayYears = false;\n  public displayYearsIndex = 0;\n  public displayYearRange: Array<number>;\n  public fullYearRange: Array<any>;\n  public monthsShort: Array<string> = moment.monthsShort();\n  public calendarDays: Array<Moment>;\n\n  constructor() {}\n\n  public ngOnInit(): void {\n    this.initValue();\n    // default to current year range\n    _.each(this.fullYearRange, (v, i) => {\n      this.currentYear = this.calendarDate.clone().startOf('year').year();\n      if (v.indexOf(this.currentYear) !== -1) {\n        this.displayYearsIndex = i;\n      }\n    });\n    this.displayYearRange = this.fullYearRange[this.displayYearsIndex];\n    this.generateCalendar();\n  }\n\n  public prev(): void {\n    if (this.onDisplayYears) {\n      this.displayYearsIndex--;\n      if (this.displayYearsIndex < 0) {\n        this.displayYearsIndex = 0;\n      }\n      this.displayYearRange = this.fullYearRange[this.displayYearsIndex];\n    } else {\n      this.calendarDate = this.calendarDate.clone().subtract(1, 'M');\n    }\n    this.generateCalendar();\n  }\n\n  public showMonthSelection(): void {\n    this.onDisplayMonths = true;\n    this.onDisplayYears = false;\n  }\n\n  public showYearSelection(): void {\n    this.onDisplayYears = true;\n    this.onDisplayMonths = false;\n  }\n\n  public next(): void {\n    if (this.onDisplayYears) {\n      this.displayYearsIndex++;\n      if (this.displayYearsIndex >= this.fullYearRange.length) {\n        this.displayYearsIndex = this.fullYearRange.length - 1;\n      }\n      this.displayYearRange = this.fullYearRange[this.displayYearsIndex++];\n    } else {\n      this.calendarDate = this.calendarDate.clone().add(1, 'M');\n    }\n    this.generateCalendar();\n  }\n\n  public selectDay(day: Moment): void {\n    const daysDifference = day.diff(\n      this.calendarDate.clone().startOf('date'),\n      'days'\n    );\n    day = this.calendarDate.clone().add(daysDifference, 'd');\n    const selectedDay = this.parseToReturnObjectType(day);\n    this.onSelectDate.emit(selectedDay);\n    this.cancelDatePicker();\n    return;\n  }\n\n  public selectMonth(month: string) {\n    this.calendarDate = this.calendarDate.clone().month(month);\n    this.onDisplayMonths = false;\n    this.generateCalendar();\n  }\n\n  public selectYear(year: number) {\n    this.calendarDate = this.calendarDate.clone().year(year);\n    this.onDisplayYears = false;\n    this.generateCalendar();\n  }\n\n  public selectToday(): void {\n    const today = this.parseToReturnObjectType(moment());\n    this.onSelectDate.emit(today);\n    this.cancelDatePicker();\n    return;\n  }\n\n  public clearPickDate(): void {\n    this.onSelectDate.emit(null);\n    this.cancelDatePicker();\n    return;\n  }\n\n  public cancelDatePicker(): void {\n    this.onDatePickerCancel.emit(false);\n    return;\n  }\n\n  protected generateYears(): void {\n    const currentYear = moment().year();\n    const startYr = this.calendarDate.clone().subtract(100, 'y').year();\n    // const endYr = this.calendarDate.clone().add(10, 'y').year();\n    const years = [];\n    for (let year = startYr; year <= currentYear; year++) {\n      years.push(year);\n    }\n\n    this.fullYearRange = _.chunk(years, 14);\n  }\n\n  protected initValue() {\n    // set moment locale (default is en)\n    moment.locale(this.locale);\n    // set today value\n    this.today = moment().startOf('date');\n    this.currentMonth = this.monthsShort[moment().month()];\n    this.currentYear = moment().year();\n\n    // set week days name array\n    this.dayNames = moment.weekdaysShort(true);\n\n    // check if the input initDate has value\n    if (this.initDate) {\n      this.calendarDate =\n        this.returnObject === 'string'\n          ? moment(this.initDate, this.viewFormat)\n          : moment(this.initDate);\n      this.selectedDate = this.calendarDate.clone().startOf('date');\n    } else {\n      this.calendarDate = moment();\n    }\n    this.generateYears();\n  }\n\n  protected generateCalendar(): void {\n    this.calendarDays = [];\n    const start =\n      0 -\n      ((this.calendarDate.clone().startOf('month').day() +\n        (7 - moment.localeData().firstDayOfWeek())) %\n        7);\n    const end = 41 + start; // iterator ending point\n\n    for (let i = start; i <= end; i += 1) {\n      const day = this.calendarDate.clone().startOf('month').add(i, 'days');\n      this.calendarDays.push(day);\n    }\n  }\n\n  protected parseToReturnObjectType(day: Moment): any {\n    switch (this.returnObject) {\n      case 'js':\n        return day.toDate();\n\n      case 'string':\n        return day.format(this.viewFormat);\n\n      case 'moment':\n        return day;\n\n      case 'json':\n        return day.toJSON();\n\n      case 'array':\n        return day.toArray();\n\n      case 'iso':\n        return day.toISOString();\n\n      case 'object':\n        return day.toObject();\n\n      default:\n        return day;\n    }\n  }\n}\n"]}