@openmrs/ngx-formentry 3.0.0

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

@@ -0,0 +1,125 @@
+/**
+ * time-picker.component
+ */
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import moment from 'moment';
+import * as i0 from "@angular/core";
+import * as i1 from "../picker-modal/modal.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../pipes/moment.pipe";
+// const myDpStyles: string = require('./time-picker.component.css');
+// const myDpTpl: string = require('./time-picker.component.html');
+// webpack2_
+export class TimePickerComponent {
+    constructor() {
+        this.showSecond = true;
+        this.viewFormat = 'hh:mm A';
+        this.use12Hour = false;
+        this.returnObject = 'js';
+        this.timeSelect = new EventEmitter();
+        this.timePickerCancel = new EventEmitter();
+        this.hourFormat = 'HH';
+    }
+    ngOnInit() {
+        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();
+        }
+    }
+    increaseHour() {
+        this.time = this.time.clone().add(1, 'h');
+    }
+    decreaseHour() {
+        this.time = this.time.clone().subtract(1, 'h');
+    }
+    increaseMinute() {
+        this.time = this.time.clone().add(1, 'm');
+    }
+    decreaseMinute() {
+        this.time = this.time.clone().subtract(1, 'm');
+    }
+    increaseSecond() {
+        this.time = this.time.clone().add(1, 's');
+    }
+    decreaseSecond() {
+        this.time = this.time.clone().subtract(1, 's');
+    }
+    selectTime() {
+        const selectTime = this.parseToReturnObjectType(this.time);
+        this.timeSelect.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    }
+    selectNow() {
+        const selectTime = this.parseToReturnObjectType(moment());
+        this.timeSelect.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    }
+    clearTime() {
+        this.timeSelect.emit(null);
+        this.cancelTimePicker();
+        return;
+    }
+    cancelTimePicker() {
+        this.timePickerCancel.emit(false);
+        return;
+    }
+    parseToReturnObjectType(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.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TimePickerComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+TimePickerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: TimePickerComponent, selector: "ofe-time-picker", inputs: { initTime: "initTime", showSecond: "showSecond", viewFormat: "viewFormat", use12Hour: "use12Hour", returnObject: "returnObject" }, outputs: { timeSelect: "timeSelect", timePickerCancel: "timePickerCancel" }, ngImport: i0, template: "<ofe-picker-modal (overlayClick)=\"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</ofe-picker-modal>\n", styles: ["*,*:before,*:after{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;user-select:none}.picker-header,.picker-footer{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;user-select:none}.picker-table-number,.picker-table-meridiem,.picker-table-separator{text-align:center}.picker-table-number,.picker-table-meridiem{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;transform:translate(-50%) rotate(-135deg)}.arrow.down{bottom:-1rem;transform:translate(-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-now:before,.picker-footer .action-confirm:before,.picker-footer .action-clear:before,.picker-footer .action-close: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%);transform:rotate(45deg)}\n"], components: [{ type: i1.ModalComponent, selector: "ofe-picker-modal", outputs: ["overlayClick"] }], directives: [{ type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "moment": i3.MomentPipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TimePickerComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-time-picker',
+                    templateUrl: './time-picker.component.html',
+                    styleUrls: ['./time-picker.component.css']
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { initTime: [{
+                type: Input
+            }], showSecond: [{
+                type: Input
+            }], viewFormat: [{
+                type: Input
+            }], use12Hour: [{
+                type: Input
+            }], returnObject: [{
+                type: Input
+            }], timeSelect: [{
+                type: Output
+            }], timePickerCancel: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/ngx-formentry/src/components/date-time-picker/time-picker/time-picker.component.ts","../../../../../../projects/ngx-formentry/src/components/date-time-picker/time-picker/time-picker.component.html"],"names":[],"mappings":"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","sourcesContent":["/**\n * time-picker.component\n */\n\nimport { Component, OnInit, Input, Output, EventEmitter } from '@angular/core';\nimport moment, { Moment } from '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: 'ofe-time-picker',\n  templateUrl: './time-picker.component.html',\n  styleUrls: ['./time-picker.component.css']\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() timeSelect = new EventEmitter<any>();\n  @Output() timePickerCancel = 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.timeSelect.emit(selectTime);\n    this.cancelTimePicker();\n    return;\n  }\n\n  selectNow(): void {\n    const selectTime = this.parseToReturnObjectType(moment());\n    this.timeSelect.emit(selectTime);\n    this.cancelTimePicker();\n    return;\n  }\n\n  clearTime(): void {\n    this.timeSelect.emit(null);\n    this.cancelTimePicker();\n    return;\n  }\n\n  cancelTimePicker(): void {\n    this.timePickerCancel.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","<ofe-picker-modal (overlayClick)=\"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</ofe-picker-modal>\n"]}

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

@@ -0,0 +1,122 @@
+import { Component, Input, forwardRef, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "ngx-file-uploader-openmrs";
+import * as i2 from "@angular/forms";
+import * as i3 from "@angular/common";
+import * as i4 from "./secure.pipe";
+export class FileUploadComponent {
+    constructor(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 = (_) => { };
+    }
+    get dataSource() {
+        return this._dataSource;
+    }
+    set dataSource(v) {
+        this._dataSource = v;
+    }
+    ngOnInit() {
+        if (this.fileUuid) {
+            this.checkFileType();
+        }
+    }
+    onFileChange(fileList) {
+        for (const file of fileList) {
+            this.upload(file);
+        }
+    }
+    upload(data) {
+        if (this.dataSource) {
+            this.uploading = true;
+            this.dataSource.fileUpload(data).subscribe((result) => {
+                this.fileUuid = result.image;
+                this.checkFileType();
+                this.propagateChange(this.fileUuid);
+                this.uploading = false;
+            }, (error) => {
+                this.uploading = false;
+            });
+        }
+    }
+    // this is the initial value set to the component
+    writeValue(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
+    registerOnChange(fn) {
+        this.propagateChange = fn;
+    }
+    // not used, used for touch input
+    registerOnTouched() { }
+    // change events from the textarea
+    onChange(event) {
+        this.propagateChange(event.id);
+        // .....
+        // update the form
+        // this.propagateChange(this.data);
+    }
+    clearValue() {
+        this.fileUuid = null;
+        this.pdfUploaded = false;
+        this.pdfUrl = null;
+        this.propagateChange(this.fileUuid);
+    }
+    getPdfUrl(fileUuid) {
+        this.dataSource.fetchFile(fileUuid, 'pdf').subscribe((file) => {
+            this.pdfUploaded = true;
+            this.pdfUrl = file.changingThisBreaksApplicationSecurity;
+        });
+    }
+    checkFileType() {
+        const re = /pdf/gi;
+        if (this.fileUuid.search(re) !== -1) {
+            this.getPdfUrl(this.fileUuid);
+        }
+    }
+}
+FileUploadComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FileUploadComponent, deps: [{ token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Component });
+FileUploadComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.16", type: FileUploadComponent, selector: "ofe-file-upload", inputs: { dataSource: "dataSource" }, providers: [
+        {
+            provide: NG_VALUE_ACCESSOR,
+            useExisting: forwardRef(() => FileUploadComponent),
+            multi: true
+        }
+    ], ngImport: i0, template: "<lib-ngx-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-ngx-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", styles: ["\n      img {\n        margin-left: auto;\n        margin-right: auto;\n        display: block;\n      }\n    "], components: [{ type: i1.NgxFileUploaderComponent, selector: "lib-ngx-file-uploader", inputs: ["singleFile", "formEntry", "srcUrl", "source"], outputs: ["fileChanged", "uploadData", "_onClear"] }], directives: [{ type: i2.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { type: i2.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "secure": i4.SecurePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: FileUploadComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'ofe-file-upload',
+                    templateUrl: 'file-upload.component.html',
+                    providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => FileUploadComponent),
+                            multi: true
+                        }
+                    ],
+                    styles: [
+                        `
+      img {
+        margin-left: auto;
+        margin-right: auto;
+        display: block;
+      }
+    `
+                    ]
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }]; }, propDecorators: { dataSource: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-upload.component.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/components/file-upload/file-upload.component.ts","../../../../../projects/ngx-formentry/src/components/file-upload/file-upload.component.html"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnInit, Input, forwardRef, Renderer2 } from '@angular/core';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\nimport { DataSource } from '../../form-entry/question-models/interfaces/data-source';\n\n@Component({\n  selector: 'ofe-file-upload',\n  templateUrl: 'file-upload.component.html',\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\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  private _dataSource: DataSource;\n\n  constructor(private renderer: Renderer2) {}\n\n  ngOnInit() {\n    if (this.fileUuid) {\n      this.checkFileType();\n    }\n  }\n\n  public onFileChange(fileList) {\n    for (const file of fileList) {\n      this.upload(file);\n    }\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","<lib-ngx-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-ngx-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"]}

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

@@ -0,0 +1,39 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { SharedModule } from '../../shared.module';
+import { FileUploadComponent } from './file-upload.component';
+import { WebcamModule } from 'ngx-webcam';
+import { NgxFileUploaderModule } from 'ngx-file-uploader-openmrs';
+import * as i0 from "@angular/core";
+export class RemoteFileUploadModule {
+}
+RemoteFileUploadModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteFileUploadModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RemoteFileUploadModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteFileUploadModule, declarations: [FileUploadComponent], imports: [CommonModule,
+        FormsModule,
+        SharedModule,
+        WebcamModule,
+        NgxFileUploaderModule], exports: [FileUploadComponent] });
+RemoteFileUploadModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteFileUploadModule, providers: [], imports: [[
+            CommonModule,
+            FormsModule,
+            SharedModule,
+            WebcamModule,
+            NgxFileUploaderModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: RemoteFileUploadModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        SharedModule,
+                        WebcamModule,
+                        NgxFileUploaderModule
+                    ],
+                    exports: [FileUploadComponent],
+                    declarations: [FileUploadComponent],
+                    providers: []
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/file-upload/secure.pipe.js

@@ -0,0 +1,101 @@
+import { Pipe, WrappedValue, ChangeDetectorRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+// Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.
+export class SecurePipe {
+    constructor(_ref, sanitizer) {
+        this._ref = _ref;
+        this.sanitizer = sanitizer;
+        this._latestValue = null;
+        this._latestReturnedValue = null;
+        this._subscription = null;
+        this._obj = null;
+        this._result = new BehaviorSubject(null);
+        this.result = this._result.asObservable();
+        this._internalSubscription = null;
+    }
+    ngOnDestroy() {
+        if (this._subscription) {
+            this._dispose();
+        }
+    }
+    transform(url, getfile) {
+        this.getfile = getfile;
+        const obj = this.internalTransform(url);
+        return this.asyncTrasnform(obj);
+    }
+    internalTransform(url) {
+        if (!url) {
+            return this.result;
+        }
+        if (this.previousUrl !== url) {
+            this.previousUrl = url;
+            this._internalSubscription = this.getfile(url).subscribe((m) => {
+                const sanitized = this.sanitizer.bypassSecurityTrustUrl(m);
+                this._result.next(sanitized);
+            });
+        }
+        return this.result;
+    }
+    asyncTrasnform(obj) {
+        if (!this._obj) {
+            if (obj) {
+                this._subscribe(obj);
+            }
+            this._latestReturnedValue = this._latestValue;
+            return this._latestValue;
+        }
+        if (obj !== this._obj) {
+            this._dispose();
+            return this.asyncTrasnform(obj);
+        }
+        if (this._latestValue === this._latestReturnedValue) {
+            return this._latestReturnedValue;
+        }
+        this._latestReturnedValue = this._latestValue;
+        return WrappedValue.wrap(this._latestValue);
+    }
+    _subscribe(obj) {
+        const _this = this;
+        this._obj = obj;
+        this._subscription = obj.subscribe({
+            next: function (value) {
+                return _this._updateLatestValue(obj, value);
+            },
+            error: (e) => {
+                throw e;
+            }
+        });
+    }
+    _dispose() {
+        if (this._subscription) {
+            this._subscription.unsubscribe();
+        }
+        if (this._internalSubscription) {
+            this._internalSubscription.unsubscribe();
+        }
+        this._internalSubscription = null;
+        this._latestValue = null;
+        this._latestReturnedValue = null;
+        this._subscription = null;
+        this._obj = null;
+    }
+    _updateLatestValue(async, value) {
+        if (async === this._obj) {
+            this._latestValue = value;
+            this._ref.markForCheck();
+        }
+    }
+}
+SecurePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.DomSanitizer }], target: i0.ɵɵFactoryTarget.Pipe });
+SecurePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, name: "secure", pure: false });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: SecurePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: 'secure',
+                    pure: false
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.DomSanitizer }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjdXJlLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uZ3gtZm9ybWVudHJ5L3NyYy9jb21wb25lbnRzL2ZpbGUtdXBsb2FkL3NlY3VyZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxJQUFJLEVBR0osWUFBWSxFQUNaLGlCQUFpQixFQUNsQixNQUFNLGVBQWUsQ0FBQztBQUN2QixPQUFPLEVBQTRCLGVBQWUsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUVqRSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7OztBQUV6RCxpRkFBaUY7QUFLakYsTUFBTSxPQUFPLFVBQVU7SUFXckIsWUFDVSxJQUF1QixFQUN2QixTQUF1QjtRQUR2QixTQUFJLEdBQUosSUFBSSxDQUFtQjtRQUN2QixjQUFTLEdBQVQsU0FBUyxDQUFjO1FBWnpCLGlCQUFZLEdBQVEsSUFBSSxDQUFDO1FBQ3pCLHlCQUFvQixHQUFRLElBQUksQ0FBQztRQUNqQyxrQkFBYSxHQUFpQixJQUFJLENBQUM7UUFDbkMsU0FBSSxHQUFvQixJQUFJLENBQUM7UUFHN0IsWUFBTyxHQUF5QixJQUFJLGVBQWUsQ0FBQyxJQUFJLENBQUMsQ0FBQztRQUMxRCxXQUFNLEdBQW9CLElBQUksQ0FBQyxPQUFPLENBQUMsWUFBWSxFQUFFLENBQUM7UUFDdEQsMEJBQXFCLEdBQWlCLElBQUksQ0FBQztJQUtoRCxDQUFDO0lBRUosV0FBVztRQUNULElBQUksSUFBSSxDQUFDLGFBQWEsRUFBRTtZQUN0QixJQUFJLENBQUMsUUFBUSxFQUFFLENBQUM7U0FDakI7SUFDSCxDQUFDO0lBRUQsU0FBUyxDQUFDLEdBQVcsRUFBRSxPQUFPO1FBQzVCLElBQUksQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO1FBQ3ZCLE1BQU0sR0FBRyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsQ0FBQztRQUN4QyxPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVPLGlCQUFpQixDQUFDLEdBQVc7UUFDbkMsSUFBSSxDQUFDLEdBQUcsRUFBRTtZQUNSLE9BQU8sSUFBSSxDQUFDLE1BQU0sQ0FBQztTQUNwQjtRQUVELElBQUksSUFBSSxDQUFDLFdBQVcsS0FBSyxHQUFHLEVBQUU7WUFDNUIsSUFBSSxDQUFDLFdBQVcsR0FBRyxHQUFHLENBQUM7WUFDdkIsSUFBSSxDQUFDLHFCQUFxQixHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7Z0JBQzdELE1BQU0sU0FBUyxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsc0JBQXNCLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQzNELElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBQy9CLENBQUMsQ0FBQyxDQUFDO1NBQ0o7UUFFRCxPQUFPLElBQUksQ0FBQyxNQUFNLENBQUM7SUFDckIsQ0FBQztJQUVPLGNBQWMsQ0FBQyxHQUFvQjtRQUN6QyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksRUFBRTtZQUNkLElBQUksR0FBRyxFQUFFO2dCQUNQLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLENBQUM7YUFDdEI7WUFDRCxJQUFJLENBQUMsb0JBQW9CLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQztZQUM5QyxPQUFPLElBQUksQ0FBQyxZQUFZLENBQUM7U0FDMUI7UUFDRCxJQUFJLEdBQUcsS0FBSyxJQUFJLENBQUMsSUFBSSxFQUFFO1lBQ3JCLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztZQUNoQixPQUFPLElBQUksQ0FBQyxjQUFjLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDakM7UUFDRCxJQUFJLElBQUksQ0FBQyxZQUFZLEtBQUssSUFBSSxDQUFDLG9CQUFvQixFQUFFO1lBQ25ELE9BQU8sSUFBSSxDQUFDLG9CQUFvQixDQUFDO1NBQ2xDO1FBQ0QsSUFBSSxDQUFDLG9CQUFvQixHQUFHLElBQUksQ0FBQyxZQUFZLENBQUM7UUFDOUMsT0FBTyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxZQUFZLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRU8sVUFBVSxDQUFDLEdBQW9CO1FBQ3JDLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQztRQUNuQixJQUFJLENBQUMsSUFBSSxHQUFHLEdBQUcsQ0FBQztRQUVoQixJQUFJLENBQUMsYUFBYSxHQUFHLEdBQUcsQ0FBQyxTQUFTLENBQUM7WUFDakMsSUFBSSxFQUFFLFVBQVUsS0FBSztnQkFDbkIsT0FBTyxLQUFLLENBQUMsa0JBQWtCLENBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDO1lBQzlDLENBQUM7WUFDRCxLQUFLLEVBQUUsQ0FBQyxDQUFNLEVBQUUsRUFBRTtnQkFDaEIsTUFBTSxDQUFDLENBQUM7WUFDVixDQUFDO1NBQ0YsQ0FBQyxDQUFDO0lBQ0wsQ0FBQztJQUVPLFFBQVE7UUFDZCxJQUFJLElBQUksQ0FBQyxhQUFhLEVBQUU7WUFDdEIsSUFBSSxDQUFDLGFBQWEsQ0FBQyxXQUFXLEVBQUUsQ0FBQztTQUNsQztRQUNELElBQUksSUFBSSxDQUFDLHFCQUFxQixFQUFFO1lBQzlCLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxXQUFXLEVBQUUsQ0FBQztTQUMxQztRQUVELElBQUksQ0FBQyxxQkFBcUIsR0FBRyxJQUFJLENBQUM7UUFDbEMsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDekIsSUFBSSxDQUFDLG9CQUFvQixHQUFHLElBQUksQ0FBQztRQUNqQyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQztRQUMxQixJQUFJLENBQUMsSUFBSSxHQUFHLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRU8sa0JBQWtCLENBQUMsS0FBVSxFQUFFLEtBQWE7UUFDbEQsSUFBSSxLQUFLLEtBQUssSUFBSSxDQUFDLElBQUksRUFBRTtZQUN2QixJQUFJLENBQUMsWUFBWSxHQUFHLEtBQUssQ0FBQztZQUMxQixJQUFJLENBQUMsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1NBQzFCO0lBQ0gsQ0FBQzs7d0dBakdVLFVBQVU7c0dBQVYsVUFBVTs0RkFBVixVQUFVO2tCQUp0QixJQUFJO21CQUFDO29CQUNKLElBQUksRUFBRSxRQUFRO29CQUNkLElBQUksRUFBRSxLQUFLO2lCQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgUGlwZSxcbiAgUGlwZVRyYW5zZm9ybSxcbiAgT25EZXN0cm95LFxuICBXcmFwcGVkVmFsdWUsXG4gIENoYW5nZURldGVjdG9yUmVmXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgU3Vic2NyaXB0aW9uLCBPYnNlcnZhYmxlLCBCZWhhdmlvclN1YmplY3QgfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHsgRG9tU2FuaXRpemVyIH0gZnJvbSAnQGFuZ3VsYXIvcGxhdGZvcm0tYnJvd3Nlcic7XG5cbi8vIFVzaW5nIHNpbWlsYXJpdHkgZnJvbSBBc3luY1BpcGUgdG8gYXZvaWQgaGF2aW5nIHRvIHBpcGUgfHNlY3VyZXxhc3luYyBpbiBIVE1MLlxuQFBpcGUoe1xuICBuYW1lOiAnc2VjdXJlJyxcbiAgcHVyZTogZmFsc2Vcbn0pXG5leHBvcnQgY2xhc3MgU2VjdXJlUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0sIE9uRGVzdHJveSB7XG4gIHByaXZhdGUgX2xhdGVzdFZhbHVlOiBhbnkgPSBudWxsO1xuICBwcml2YXRlIF9sYXRlc3RSZXR1cm5lZFZhbHVlOiBhbnkgPSBudWxsO1xuICBwcml2YXRlIF9zdWJzY3JpcHRpb246IFN1YnNjcmlwdGlvbiA9IG51bGw7XG4gIHByaXZhdGUgX29iajogT2JzZXJ2YWJsZTxhbnk+ID0gbnVsbDtcbiAgcHJpdmF0ZSBnZXRmaWxlO1xuICBwcml2YXRlIHByZXZpb3VzVXJsOiBzdHJpbmc7XG4gIHByaXZhdGUgX3Jlc3VsdDogQmVoYXZpb3JTdWJqZWN0PGFueT4gPSBuZXcgQmVoYXZpb3JTdWJqZWN0KG51bGwpO1xuICBwcml2YXRlIHJlc3VsdDogT2JzZXJ2YWJsZTxhbnk+ID0gdGhpcy5fcmVzdWx0LmFzT2JzZXJ2YWJsZSgpO1xuICBwcml2YXRlIF9pbnRlcm5hbFN1YnNjcmlwdGlvbjogU3Vic2NyaXB0aW9uID0gbnVsbDtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwcml2YXRlIF9yZWY6IENoYW5nZURldGVjdG9yUmVmLFxuICAgIHByaXZhdGUgc2FuaXRpemVyOiBEb21TYW5pdGl6ZXJcbiAgKSB7fVxuXG4gIG5nT25EZXN0cm95KCk6IHZvaWQge1xuICAgIGlmICh0aGlzLl9zdWJzY3JpcHRpb24pIHtcbiAgICAgIHRoaXMuX2Rpc3Bvc2UoKTtcbiAgICB9XG4gIH1cblxuICB0cmFuc2Zvcm0odXJsOiBzdHJpbmcsIGdldGZpbGUpOiBhbnkge1xuICAgIHRoaXMuZ2V0ZmlsZSA9IGdldGZpbGU7XG4gICAgY29uc3Qgb2JqID0gdGhpcy5pbnRlcm5hbFRyYW5zZm9ybSh1cmwpO1xuICAgIHJldHVybiB0aGlzLmFzeW5jVHJhc25mb3JtKG9iaik7XG4gIH1cblxuICBwcml2YXRlIGludGVybmFsVHJhbnNmb3JtKHVybDogc3RyaW5nKTogT2JzZXJ2YWJsZTxhbnk+IHtcbiAgICBpZiAoIXVybCkge1xuICAgICAgcmV0dXJuIHRoaXMucmVzdWx0O1xuICAgIH1cblxuICAgIGlmICh0aGlzLnByZXZpb3VzVXJsICE9PSB1cmwpIHtcbiAgICAgIHRoaXMucHJldmlvdXNVcmwgPSB1cmw7XG4gICAgICB0aGlzLl9pbnRlcm5hbFN1YnNjcmlwdGlvbiA9IHRoaXMuZ2V0ZmlsZSh1cmwpLnN1YnNjcmliZSgobSkgPT4ge1xuICAgICAgICBjb25zdCBzYW5pdGl6ZWQgPSB0aGlzLnNhbml0aXplci5ieXBhc3NTZWN1cml0eVRydXN0VXJsKG0pO1xuICAgICAgICB0aGlzLl9yZXN1bHQubmV4dChzYW5pdGl6ZWQpO1xuICAgICAgfSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIHRoaXMucmVzdWx0O1xuICB9XG5cbiAgcHJpdmF0ZSBhc3luY1RyYXNuZm9ybShvYmo6IE9ic2VydmFibGU8YW55Pik6IGFueSB7XG4gICAgaWYgKCF0aGlzLl9vYmopIHtcbiAgICAgIGlmIChvYmopIHtcbiAgICAgICAgdGhpcy5fc3Vic2NyaWJlKG9iaik7XG4gICAgICB9XG4gICAgICB0aGlzLl9sYXRlc3RSZXR1cm5lZFZhbHVlID0gdGhpcy5fbGF0ZXN0VmFsdWU7XG4gICAgICByZXR1cm4gdGhpcy5fbGF0ZXN0VmFsdWU7XG4gICAgfVxuICAgIGlmIChvYmogIT09IHRoaXMuX29iaikge1xuICAgICAgdGhpcy5fZGlzcG9zZSgpO1xuICAgICAgcmV0dXJuIHRoaXMuYXN5bmNUcmFzbmZvcm0ob2JqKTtcbiAgICB9XG4gICAgaWYgKHRoaXMuX2xhdGVzdFZhbHVlID09PSB0aGlzLl9sYXRlc3RSZXR1cm5lZFZhbHVlKSB7XG4gICAgICByZXR1cm4gdGhpcy5fbGF0ZXN0UmV0dXJuZWRWYWx1ZTtcbiAgICB9XG4gICAgdGhpcy5fbGF0ZXN0UmV0dXJuZWRWYWx1ZSA9IHRoaXMuX2xhdGVzdFZhbHVlO1xuICAgIHJldHVybiBXcmFwcGVkVmFsdWUud3JhcCh0aGlzLl9sYXRlc3RWYWx1ZSk7XG4gIH1cblxuICBwcml2YXRlIF9zdWJzY3JpYmUob2JqOiBPYnNlcnZhYmxlPGFueT4pIHtcbiAgICBjb25zdCBfdGhpcyA9IHRoaXM7XG4gICAgdGhpcy5fb2JqID0gb2JqO1xuXG4gICAgdGhpcy5fc3Vic2NyaXB0aW9uID0gb2JqLnN1YnNjcmliZSh7XG4gICAgICBuZXh0OiBmdW5jdGlvbiAodmFsdWUpIHtcbiAgICAgICAgcmV0dXJuIF90aGlzLl91cGRhdGVMYXRlc3RWYWx1ZShvYmosIHZhbHVlKTtcbiAgICAgIH0sXG4gICAgICBlcnJvcjogKGU6IGFueSkgPT4ge1xuICAgICAgICB0aHJvdyBlO1xuICAgICAgfVxuICAgIH0pO1xuICB9XG5cbiAgcHJpdmF0ZSBfZGlzcG9zZSgpIHtcbiAgICBpZiAodGhpcy5fc3Vic2NyaXB0aW9uKSB7XG4gICAgICB0aGlzLl9zdWJzY3JpcHRpb24udW5zdWJzY3JpYmUoKTtcbiAgICB9XG4gICAgaWYgKHRoaXMuX2ludGVybmFsU3Vic2NyaXB0aW9uKSB7XG4gICAgICB0aGlzLl9pbnRlcm5hbFN1YnNjcmlwdGlvbi51bnN1YnNjcmliZSgpO1xuICAgIH1cblxuICAgIHRoaXMuX2ludGVybmFsU3Vic2NyaXB0aW9uID0gbnVsbDtcbiAgICB0aGlzLl9sYXRlc3RWYWx1ZSA9IG51bGw7XG4gICAgdGhpcy5fbGF0ZXN0UmV0dXJuZWRWYWx1ZSA9IG51bGw7XG4gICAgdGhpcy5fc3Vic2NyaXB0aW9uID0gbnVsbDtcbiAgICB0aGlzLl9vYmogPSBudWxsO1xuICB9XG5cbiAgcHJpdmF0ZSBfdXBkYXRlTGF0ZXN0VmFsdWUoYXN5bmM6IGFueSwgdmFsdWU6IE9iamVjdCkge1xuICAgIGlmIChhc3luYyA9PT0gdGhpcy5fb2JqKSB7XG4gICAgICB0aGlzLl9sYXRlc3RWYWx1ZSA9IHZhbHVlO1xuICAgICAgdGhpcy5fcmVmLm1hcmtGb3JDaGVjaygpO1xuICAgIH1cbiAgfVxufVxuIl19

package/esm2015/components/input/input.directive.js

@@ -0,0 +1,78 @@
+import { Directive, HostBinding, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * A directive for applying styling to an input element.
+ *
+ * Example:
+ *
+ * ```html
+ * <input ofeTextInput/>
+ * ```
+ *
+ * See the [vanilla carbon docs](http://www.carbondesignsystem.com/components/text-input/code) for more detail.
+ */
+export class TextInputDirective {
+    constructor() {
+        /**
+         * `light` or `dark` input theme
+         */
+        this.theme = 'dark';
+        /**
+         * Input field render size
+         */
+        this.size = 'md';
+        this.inputClass = true;
+        this.invalid = false;
+        this.warn = false;
+        this.skeleton = false;
+    }
+    get isSizeXl() {
+        return this.size === 'xl';
+    }
+    get isSizeSm() {
+        return this.size === 'sm';
+    }
+    get isLightTheme() {
+        return this.theme === 'light';
+    }
+}
+TextInputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TextInputDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+TextInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "12.2.16", type: TextInputDirective, selector: "[ofeTextInput]", inputs: { theme: "theme", size: "size", invalid: "invalid", warn: "warn", skeleton: "skeleton" }, host: { properties: { "class.cds--text-input": "this.inputClass", "class.cds--text-input--xl": "this.isSizeXl", "class.cds--text-input--sm": "this.isSizeSm", "class.cds--text-input--invalid": "this.invalid", "class.cds--text-input__field-wrapper--warning": "this.warn", "class.cds--skeleton": "this.skeleton", "class.cds--text-input--light": "this.isLightTheme" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: TextInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ofeTextInput]'
+                }]
+        }], propDecorators: { theme: [{
+                type: Input
+            }], size: [{
+                type: Input
+            }], inputClass: [{
+                type: HostBinding,
+                args: ['class.cds--text-input']
+            }], isSizeXl: [{
+                type: HostBinding,
+                args: ['class.cds--text-input--xl']
+            }], isSizeSm: [{
+                type: HostBinding,
+                args: ['class.cds--text-input--sm']
+            }], invalid: [{
+                type: HostBinding,
+                args: ['class.cds--text-input--invalid']
+            }, {
+                type: Input
+            }], warn: [{
+                type: HostBinding,
+                args: ['class.cds--text-input__field-wrapper--warning']
+            }, {
+                type: Input
+            }], skeleton: [{
+                type: HostBinding,
+                args: ['class.cds--skeleton']
+            }, {
+                type: Input
+            }], isLightTheme: [{
+                type: HostBinding,
+                args: ['class.cds--text-input--light']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/components/input/input.module.js

@@ -0,0 +1,23 @@
+// modules
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+// imports
+import { LabelComponent } from './label.component';
+import { TextInputDirective } from './input.directive';
+import { TextAreaDirective } from './text-area.directive';
+import * as i0 from "@angular/core";
+export class InputModule {
+}
+InputModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+InputModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InputModule, declarations: [LabelComponent, TextInputDirective, TextAreaDirective], imports: [CommonModule, FormsModule], exports: [LabelComponent, TextInputDirective, TextAreaDirective] });
+InputModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InputModule, imports: [[CommonModule, FormsModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.16", ngImport: i0, type: InputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [LabelComponent, TextInputDirective, TextAreaDirective],
+                    exports: [LabelComponent, TextInputDirective, TextAreaDirective],
+                    imports: [CommonModule, FormsModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWZvcm1lbnRyeS9zcmMvY29tcG9uZW50cy9pbnB1dC9pbnB1dC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxVQUFVO0FBQ1YsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ25ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ3ZELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQU8xRCxNQUFNLE9BQU8sV0FBVzs7eUdBQVgsV0FBVzswR0FBWCxXQUFXLGlCQUpQLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxpQkFBaUIsYUFFMUQsWUFBWSxFQUFFLFdBQVcsYUFEekIsY0FBYyxFQUFFLGtCQUFrQixFQUFFLGlCQUFpQjswR0FHcEQsV0FBVyxZQUZiLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQzs0RkFFekIsV0FBVztrQkFMdkIsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxjQUFjLEVBQUUsa0JBQWtCLEVBQUUsaUJBQWlCLENBQUM7b0JBQ3JFLE9BQU8sRUFBRSxDQUFDLGNBQWMsRUFBRSxrQkFBa0IsRUFBRSxpQkFBaUIsQ0FBQztvQkFDaEUsT0FBTyxFQUFFLENBQUMsWUFBWSxFQUFFLFdBQVcsQ0FBQztpQkFDckMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBtb2R1bGVzXG5pbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5pbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuXG4vLyBpbXBvcnRzXG5pbXBvcnQgeyBMYWJlbENvbXBvbmVudCB9IGZyb20gJy4vbGFiZWwuY29tcG9uZW50JztcbmltcG9ydCB7IFRleHRJbnB1dERpcmVjdGl2ZSB9IGZyb20gJy4vaW5wdXQuZGlyZWN0aXZlJztcbmltcG9ydCB7IFRleHRBcmVhRGlyZWN0aXZlIH0gZnJvbSAnLi90ZXh0LWFyZWEuZGlyZWN0aXZlJztcblxuQE5nTW9kdWxlKHtcbiAgZGVjbGFyYXRpb25zOiBbTGFiZWxDb21wb25lbnQsIFRleHRJbnB1dERpcmVjdGl2ZSwgVGV4dEFyZWFEaXJlY3RpdmVdLFxuICBleHBvcnRzOiBbTGFiZWxDb21wb25lbnQsIFRleHRJbnB1dERpcmVjdGl2ZSwgVGV4dEFyZWFEaXJlY3RpdmVdLFxuICBpbXBvcnRzOiBbQ29tbW9uTW9kdWxlLCBGb3Jtc01vZHVsZV1cbn0pXG5leHBvcnQgY2xhc3MgSW5wdXRNb2R1bGUge31cbiJdfQ==