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

package/esm2015/components/select/select.component.style.js

@@ -0,0 +1,102 @@
+export const STYLE = `
+ng-select {
+  display: inline-block;
+  margin: 0;
+  position: relative;
+  vertical-align: middle;
+  width: 100%;
+}
+ng-select * {
+  box-sizing: border-box;
+  font-family: Sans-Serif;
+}
+ng-select > div {
+  border: 1px solid #ddd;
+  box-sizing: border-box;
+  cursor: pointer;
+  user-select: none;
+  width: 100%;
+}
+ng-select > div.disabled {
+  background-color: #eee;
+  color: #aaa;
+  cursor: default;
+  pointer-events: none;
+}
+ng-select > div > div.single {
+  display: flex;
+  height: 30px;
+  width: 100%;
+}
+ng-select > div > div.single > div.value,
+ng-select > div > div.single > div.placeholder {
+  flex: 1;
+  line-height: 30px;
+  overflow: hidden;
+  padding: 0 10px;
+  white-space: nowrap;
+}
+ng-select > div > div.single > div.placeholder {
+  color: #a9a9a9;
+}
+ng-select > div > div.single > div.clear,
+ng-select > div > div.single > div.toggle {
+  color: #aaa;
+  line-height: 30px;
+  text-align: center;
+  width: 30px;
+}
+ng-select > div > div.single > div.clear:hover,
+ng-select > div > div.single > div.toggle:hover {
+  background-color: #ececec;
+}
+ng-select > div > div.single > div.clear {
+  font-size: 18px;
+}
+ng-select > div > div.single > div.toggle {
+  font-size: 14px;
+}
+ng-select > div > div.multiple {
+  display: flex;
+  flex-flow: row wrap;
+  height: 100%;
+  min-height: 30px;
+  padding: 0 10px;
+  width: 100%;
+}
+ng-select > div > div.multiple > div.option {
+  background-color: #eee;
+  border: 1px solid #aaa;
+  border-radius: 4px;
+  color: #333;
+  cursor: default;
+  display: inline-block;
+  flex-shrink: 0;
+  font-size: 14px;
+  line-height: 22px;
+  margin: 3px 5px 3px 0;
+  padding: 0 4px;
+}
+ng-select > div > div.multiple > div.option span.deselect-option {
+  color: #aaa;
+  cursor: pointer;
+  font-size: 14px;
+  height: 20px;
+  line-height: 20px;
+}
+ng-select > div > div.multiple > div.option span.deselect-option:hover {
+  color: #555;
+}
+ng-select > div > div.multiple input {
+  background-color: transparent;
+  border: none;
+  height: 30px;
+  line-height: 30px;
+  padding: 0;
+}
+ng-select > div > div.multiple input:focus {
+  outline: none;
+}
+`;
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/select/select.module.js

@@ -1,29 +1,16 @@
-// modules
-import { NgModule } from "@angular/core";
-import { FormsModule } from "@angular/forms";
-import { CommonModule } from "@angular/common";
-// imports
-import { Select } from "./select.component";
-import { Option } from "./option.directive";
-import { OptGroup } from "./optgroup.directive";
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { SelectComponent } from './select.component';
+import { SelectDropdownComponent } from './select-dropdown.component';
 export class SelectModule {
 }
 SelectModule.decorators = [
     { type: NgModule, args: [{
-                declarations: [
-                    Select,
-                    Option,
-                    OptGroup
-                ],
-                exports: [
-                    Select,
-                    Option,
-                    OptGroup
-                ],
-                imports: [
-                    CommonModule,
-                    FormsModule
-                ]
-            },] }
+                declarations: [SelectComponent, SelectDropdownComponent],
+                exports: [SelectComponent],
+                imports: [CommonModule, FormsModule]
+            },] },
 ];
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL25neC1mb3JtZW50cnkvc3JjL2NvbXBvbmVudHMvc2VsZWN0L3NlbGVjdC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxVQUFVO0FBQ1YsT0FBTyxFQUFFLE1BQU0sRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQzVDLE9BQU8sRUFBRSxNQUFNLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUM1QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFrQmhELE1BQU0sT0FBTyxZQUFZOzs7WUFoQnhCLFFBQVEsU0FBQztnQkFDTixZQUFZLEVBQUU7b0JBQ1YsTUFBTTtvQkFDTixNQUFNO29CQUNOLFFBQVE7aUJBQ1g7Z0JBQ0QsT0FBTyxFQUFFO29CQUNMLE1BQU07b0JBQ04sTUFBTTtvQkFDTixRQUFRO2lCQUNYO2dCQUNELE9BQU8sRUFBRTtvQkFDTCxZQUFZO29CQUNaLFdBQVc7aUJBQ2Q7YUFDSiIsInNvdXJjZXNDb250ZW50IjpbIi8vIG1vZHVsZXNcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tIFwiQGFuZ3VsYXIvY29tbW9uXCI7XG5cbi8vIGltcG9ydHNcbmltcG9ydCB7IFNlbGVjdCB9IGZyb20gXCIuL3NlbGVjdC5jb21wb25lbnRcIjtcbmltcG9ydCB7IE9wdGlvbiB9IGZyb20gXCIuL29wdGlvbi5kaXJlY3RpdmVcIjtcbmltcG9ydCB7IE9wdEdyb3VwIH0gZnJvbSBcIi4vb3B0Z3JvdXAuZGlyZWN0aXZlXCI7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbXG4gICAgICAgIFNlbGVjdCxcbiAgICAgICAgT3B0aW9uLFxuICAgICAgICBPcHRHcm91cFxuICAgIF0sXG4gICAgZXhwb3J0czogW1xuICAgICAgICBTZWxlY3QsXG4gICAgICAgIE9wdGlvbixcbiAgICAgICAgT3B0R3JvdXBcbiAgICBdLFxuICAgIGltcG9ydHM6IFtcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxuICAgICAgICBGb3Jtc01vZHVsZVxuICAgIF1cbn0pXG5leHBvcnQgY2xhc3MgU2VsZWN0TW9kdWxlIHsgfVxuIl19
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0Lm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiJuZzovL0BhbXBhdGgta2VueWEvbmd4LW9wZW5tcnMtZm9ybWVudHJ5LyIsInNvdXJjZXMiOlsiY29tcG9uZW50cy9zZWxlY3Qvc2VsZWN0Lm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFN0MsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3JELE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBT3RFLE1BQU07OztZQUxMLFFBQVEsU0FBQztnQkFDUixZQUFZLEVBQUUsQ0FBQyxlQUFlLEVBQUUsdUJBQXVCLENBQUM7Z0JBQ3hELE9BQU8sRUFBRSxDQUFDLGVBQWUsQ0FBQztnQkFDMUIsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQzthQUNyQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmltcG9ydCB7IFNlbGVjdENvbXBvbmVudCB9IGZyb20gJy4vc2VsZWN0LmNvbXBvbmVudCc7XG5pbXBvcnQgeyBTZWxlY3REcm9wZG93bkNvbXBvbmVudCB9IGZyb20gJy4vc2VsZWN0LWRyb3Bkb3duLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1NlbGVjdENvbXBvbmVudCwgU2VsZWN0RHJvcGRvd25Db21wb25lbnRdLFxuICBleHBvcnRzOiBbU2VsZWN0Q29tcG9uZW50XSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgRm9ybXNNb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIFNlbGVjdE1vZHVsZSB7fVxuIl19

package/esm2015/encounter-viewer/display-controls/file-preview.component.js

@@ -0,0 +1,111 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { EncounterViewerService } from '../encounter-viewer.service';
+const noop = () => { };
+const ɵ0 = noop;
+export class FilePreviewComponent {
+    constructor(encounterService) {
+        this.encounterService = encounterService;
+        this.fileUuid = null;
+        this.resultsIsPdf = false;
+        // Placeholders for the callbacks which are later providesd
+        // by the Control Value Accessor
+        this.onTouchedCallback = noop;
+        this.onChangeCallback = noop;
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    ngOnInit() { }
+    // get accessor
+    get value() {
+        return this.fileUuid;
+    }
+    // set accessor including call the onchange callback
+    set value(v) {
+        if (v !== this.fileUuid) {
+            this.fileUuid = v;
+        }
+    }
+    // Current time string.
+    writeValue(v) {
+        if (v !== this.fileUuid) {
+            this.fileUuid = v;
+            this.checkFileType();
+        }
+    }
+    checkFileType() {
+        const re = /pdf/gi;
+        if (this.fileUuid.search(re) !== -1) {
+            this.resultsIsPdf = true;
+        }
+    }
+    // From ControlValueAccessor interface
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    // From ControlValueAccessor interface
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    onBlur() {
+        this.onTouchedCallback();
+    }
+    onChange(event) {
+        // const files = event.srcElement.files;
+        // const fileToLoad = files[0];
+        // const fileReader = new FileReader();
+        // fileReader.onload = (fileLoadedEvent) => {
+        //   const data = fileReader.result;
+        //   const fileType = data.substring('data:image/'.length, data.indexOf(';base64'));
+        //   const payload = {
+        //     data,
+        //     extension: fileType
+        //   };
+        // };
+        // fileReader.readAsDataURL(fileToLoad);
+    }
+    getUrl() {
+        this.dataSource.fetchFile(this.fileUuid, 'pdf').subscribe((file) => {
+            window.open(file.changingThisBreaksApplicationSecurity, '_blank');
+        });
+    }
+}
+FilePreviewComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'file-preview',
+                styles: [``],
+                template: `<div *ngIf="fileUuid">
+      <img
+        *ngIf="!resultsIsPdf"
+        class="img-responsive"
+        [src]="fileUuid | secure: this._dataSource.fetchFile"
+        alt="image"
+      />
+    </div>
+    <a *ngIf="resultsIsPdf" (click)="getUrl()" style="cursor: pointer"
+      ><u>Open PDF</u></a
+    > `,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => FilePreviewComponent),
+                        multi: true
+                    }
+                ]
+            },] },
+];
+/** @nocollapse */
+FilePreviewComponent.ctorParameters = () => [
+    { type: EncounterViewerService }
+];
+FilePreviewComponent.propDecorators = {
+    source: [{ type: Input }],
+    dataSource: [{ type: Input }]
+};
+export { ɵ0 };
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/encounter-viewer/display-controls/question-control.component.js

@@ -0,0 +1,94 @@
+import { Component, Input } from '@angular/core';
+import * as _ from 'lodash';
+export class QuestionControlComponent {
+    constructor() {
+        // The internal data model
+        this.innerValue = '';
+    }
+    set schema(schema) {
+        this._schema = schema;
+    }
+    set value(value) {
+        this._value = value;
+    }
+    set dataSource(dataSource) {
+        this._dataSource = dataSource;
+    }
+    ngOnInit() {
+        this.writeValue(this._value);
+    }
+    isUuid(value) {
+        if (value.length === 36 &&
+            value.indexOf(' ') === -1 &&
+            value.indexOf('.') === -1) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    // Current time string.
+    writeValue(v, arrayElement) {
+        if (v !== this.innerValue) {
+            if (this.isUuid(v)) {
+                if (!arrayElement) {
+                    const val = this._dataSource.resolveSelectedValueFromSchema(v, this._schema);
+                    if (val) {
+                        this.innerValue = val.toUpperCase();
+                    }
+                    else {
+                        this.innerValue = v;
+                    }
+                }
+                else {
+                    return this._dataSource.resolveSelectedValueFromSchema(v, this._schema);
+                }
+            }
+            else if (_.isArray(v)) {
+                const arr = [];
+                _.forEach(v, (el) => {
+                    arr.push(this.writeValue(el, true));
+                });
+                this.innerValue = arr;
+            }
+            else if (this.isDate(v)) {
+                if (!arrayElement) {
+                    this.innerValue = this._dataSource.convertTime(v);
+                }
+                else {
+                    return this._dataSource.convertTime(v);
+                }
+            }
+            else {
+                if (!arrayElement) {
+                    this.innerValue = v;
+                }
+                else {
+                    return v;
+                }
+            }
+        }
+    }
+    isDate(str) {
+        return this._dataSource.isDate(str) && !_.isNumber(str);
+    }
+}
+QuestionControlComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'question-control',
+                styles: [`input{border:none;box-shadow:none;color:#000;background:#fff!important;padding-top:23px;display:block;position:relative}`],
+                template: `<div>
+  {{ innerValue }}
+</div>
+`
+            },] },
+];
+/** @nocollapse */
+QuestionControlComponent.ctorParameters = () => [];
+QuestionControlComponent.propDecorators = {
+    schema: [{ type: Input }],
+    value: [{ type: Input }],
+    dataSource: [{ type: Input }]
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/encounter-viewer/display-controls/remote-answer.component.js

@@ -0,0 +1,81 @@
+import { Component, Input, forwardRef } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+const noop = () => { };
+const ɵ0 = noop;
+export class RemoteAnswerComponent {
+    constructor() {
+        this.innerValue = null;
+        // Placeholders for the callbacks which are later providesd
+        // by the Control Value Accessor
+        this.onTouchedCallback = noop;
+        this.onChangeCallback = noop;
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    // get accessor
+    get value() {
+        return this.innerValue;
+    }
+    // set accessor including call the onchange callback
+    set value(v) {
+        if (v !== this.innerValue) {
+            this.innerValue = v;
+        }
+    }
+    // Current time string.
+    writeValue(v) {
+        if (v !== this.innerValue) {
+            if (this._dataSource) {
+                this._dataSource.resolveSelectedValue(v).subscribe((ans) => {
+                    this.innerValue = ans.label;
+                });
+            }
+            else {
+                this.innerValue = v;
+            }
+        }
+    }
+    // From ControlValueAccessor interface
+    registerOnChange(fn) {
+        this.onChangeCallback = fn;
+    }
+    // From ControlValueAccessor interface
+    registerOnTouched(fn) {
+        this.onTouchedCallback = fn;
+    }
+    onBlur() {
+        this.onTouchedCallback();
+    }
+    onChange(event) { }
+}
+RemoteAnswerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'remote-answer',
+                styles: [],
+                template: `
+    <div *ngIf="innerValue">
+      {{ innerValue }}
+    </div>
+  `,
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => RemoteAnswerComponent),
+                        multi: true
+                    }
+                ]
+            },] },
+];
+/** @nocollapse */
+RemoteAnswerComponent.ctorParameters = () => [];
+RemoteAnswerComponent.propDecorators = {
+    source: [{ type: Input }],
+    dataSource: [{ type: Input }]
+};
+export { ɵ0 };
+
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/encounter-viewer/encounter-container/encounter-container.component.js

@@ -0,0 +1,50 @@
+import { Component, Input } from '@angular/core';
+import { EncounterAdapter } from '../../form-entry/value-adapters/encounter.adapter';
+import { EncounterPdfViewerService } from '../encounter-pdf-viewer.service';
+export class EncounterContainerComponent {
+    constructor(encAdapter, encounterPdfViewerService) {
+        this.encAdapter = encAdapter;
+        this.encounterPdfViewerService = encounterPdfViewerService;
+    }
+    set form(form) {
+        this.$form = form;
+    }
+    set encounter(enc) {
+        this.$enc = enc;
+    }
+    ngOnInit() { }
+    displayPdf() {
+        this.encounterPdfViewerService.displayPdf(this.$form);
+    }
+}
+EncounterContainerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'encounter-renderer',
+                template: `<a
+  type="button"
+  style="display: block; font-size: 28px; cursor: pointer"
+  class="text-right"
+  (click)="displayPdf()"
+>
+  <span class="glyphicon text-primary glyphicon-print"></span>
+</a>
+<encounter-viewer
+  class="card"
+  [form]="$form"
+  [encounter]="$enc"
+></encounter-viewer>
+`,
+                styles: [`.card{box-shadow:0 2px 5px 0 rgba(0,0,0,.16),0 2px 10px 0 rgba(0,0,0,.12)}`]
+            },] },
+];
+/** @nocollapse */
+EncounterContainerComponent.ctorParameters = () => [
+    { type: EncounterAdapter },
+    { type: EncounterPdfViewerService }
+];
+EncounterContainerComponent.propDecorators = {
+    form: [{ type: Input }],
+    encounter: [{ type: Input }]
+};
+
+//# sourceMappingURL=data:application/json;base64,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