@openmrs/ngx-formentry 3.0.1-pre.8

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

@@ -0,0 +1,114 @@
+/**
+ * time-picker.component
+ */
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+import moment from 'moment';
+// 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.onSelectTime = new EventEmitter();
+        this.onTimePickerCancel = 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.onSelectTime.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    }
+    selectNow() {
+        const selectTime = this.parseToReturnObjectType(moment());
+        this.onSelectTime.emit(selectTime);
+        this.cancelTimePicker();
+        return;
+    }
+    clearTime() {
+        this.onSelectTime.emit(null);
+        this.cancelTimePicker();
+        return;
+    }
+    cancelTimePicker() {
+        this.onTimePickerCancel.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.decorators = [
+    { type: Component, args: [{
+                selector: 'time-picker',
+                template: "<picker-modal (onOverlayClick)=\"cancelTimePicker()\">\n  <div class=\"picker-wrap\">\n    <div class=\"picker-box\">\n      <div class=\"picker-header\">Time Picker</div>\n      <div class=\"picker-table\">\n        <ul class=\"picker-table-time\">\n          <li class=\"picker-table-number hour\">\n            <span class=\"arrow up\" (click)=\"increaseHour()\"></span>\n            {{ time | moment: hourFormat }}\n            <span class=\"arrow down\" (click)=\"decreaseHour()\"></span>\n          </li>\n          <li class=\"picker-table-separator\">:</li>\n          <li class=\"picker-table-number minute\">\n            <span class=\"arrow up\" (click)=\"increaseMinute()\"></span>\n            {{ time | moment: 'mm' }}\n            <span class=\"arrow down\" (click)=\"decreaseMinute()\"></span>\n          </li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-separator\">:</li>\n          <li *ngIf=\"showSecond\" class=\"picker-table-number second\">\n            <span class=\"arrow up\" (click)=\"increaseSecond()\"></span>\n            {{ time | moment: 'ss' }}\n            <span class=\"arrow down\" (click)=\"decreaseSecond()\"></span>\n          </li>\n          <li *ngIf=\"use12Hour\" class=\"picker-table-meridiem meridiem\">\n            {{ time | moment: 'A' }}\n          </li>\n        </ul>\n      </div>\n      <div class=\"picker-footer\">\n        <div class=\"picker-action action-now\" (click)=\"selectNow()\">\n          <span class=\"text\">Now</span>\n        </div>\n        <div class=\"picker-action action-confirm\" (click)=\"selectTime()\">\n          <span class=\"text\">Confirm</span>\n        </div>\n        <div class=\"picker-action action-clear\" (click)=\"clearTime()\">\n          <span class=\"text\">Clear</span>\n        </div>\n        <div class=\"picker-action action-close\" (click)=\"cancelTimePicker()\">\n          <span class=\"text\">Close</span>\n        </div>\n      </div>\n    </div>\n  </div>\n</picker-modal>\n",
+                styles: ["*,:after,:before{box-sizing:border-box}.picker-wrap{width:95vw;max-width:40rem;font-family:Open Sans}.picker-box{width:100%;padding:.625rem 1rem;-webkit-user-select:none;-moz-user-select:none;user-select:none}.picker-footer,.picker-header{font-size:1.333rem;line-height:2.5rem;height:2.5rem;width:100%}.picker-header{text-align:center}.picker-table{width:100%;margin:2.5rem 0}.picker-table-time{font-size:2.37rem;line-height:2.5rem;list-style:none;margin:0;padding:0;display:flex;justify-content:center;width:100%;-webkit-user-select:none;-moz-user-select:none;user-select:none}.picker-table-meridiem,.picker-table-number,.picker-table-separator{text-align:center}.picker-table-meridiem,.picker-table-number{position:relative;width:20%}.arrow{position:absolute;left:50%;border:solid #777;border-width:0 .2rem .2rem 0;display:inline-block;padding:.25rem;cursor:pointer}.arrow.up{top:-1rem;transform:translateX(-50%) rotate(-135deg)}.arrow.down{bottom:-1rem;transform:translateX(-50%) rotate(45deg)}.arrow:hover{border-color:#1975d2}.picker-table-separator{width:calc(20% / 3)}.picker-footer{display:flex;justify-content:center;width:100%;cursor:pointer}.picker-footer .picker-action{width:25%;text-align:center}.picker-footer .picker-action:hover{background-color:#b1dcfb}.picker-footer .picker-action .text{padding-left:.8rem}.picker-footer .action-clear:before,.picker-footer .action-close:before,.picker-footer .action-confirm:before,.picker-footer .action-now:before{content:\" \";position:relative;display:inline-block;height:0;width:0}.picker-footer .action-now:before{border-top:.66em solid #0059bc;border-left:.66em solid transparent}.picker-footer .action-confirm:before{width:1rem;height:1rem;border-radius:100%;background-color:#00b5ad}.picker-footer .action-clear:before{top:-.5rem;width:1rem;border-top:3px solid #e20}.picker-footer .action-close:before{width:1rem;height:1rem;background:linear-gradient(180deg,transparent 35%,#777 0,#777 65%,transparent 0),linear-gradient(90deg,transparent 35%,#777 0,#777 65%,transparent 0);transform:rotate(45deg)}"]
+            },] }
+];
+TimePickerComponent.ctorParameters = () => [];
+TimePickerComponent.propDecorators = {
+    initTime: [{ type: Input }],
+    showSecond: [{ type: Input }],
+    viewFormat: [{ type: Input }],
+    use12Hour: [{ type: Input }],
+    returnObject: [{ type: Input }],
+    onSelectTime: [{ type: Output }],
+    onTimePickerCancel: [{ type: Output }]
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,110 @@
+import { Component, Input, forwardRef, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+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.decorators = [
+    { type: Component, args: [{
+                selector: 'app-file-upload',
+                template: "<lib-file-uploader\n  [srcUrl]=\"pdfUrl\"\n  [formEntry]=\"formEntryMode\"\n  [(ngModel)]=\"fileUuid\"\n  (_onClear)=\"clearValue()\"\n  (uploadData)=\"onFileChange($event)\"\n>\n</lib-file-uploader>\n<div *ngIf=\"fileUuid\">\n  <img\n    *ngIf=\"!pdfUploaded\"\n    class=\"img-responsive\"\n    [src]=\"fileUuid | secure: this.dataSource.fetchFile\"\n    alt=\"\"\n  />\n</div>\n",
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => FileUploadComponent),
+                        multi: true
+                    }
+                ],
+                styles: [`
+      img {
+        margin-left: auto;
+        margin-right: auto;
+        display: block;
+      }
+    `]
+            },] }
+];
+FileUploadComponent.ctorParameters = () => [
+    { type: Renderer2 }
+];
+FileUploadComponent.propDecorators = {
+    dataSource: [{ type: Input }]
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+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';
+export class RemoteFileUploadModule {
+}
+RemoteFileUploadModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    SharedModule,
+                    WebcamModule,
+                    NgxFileUploaderModule
+                ],
+                exports: [FileUploadComponent],
+                declarations: [FileUploadComponent],
+                providers: []
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmlsZS11cGxvYWQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWZvcm1lbnRyeS9zcmMvY29tcG9uZW50cy9maWxlLXVwbG9hZC9maWxlLXVwbG9hZC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFFL0MsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBRTdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUM5RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBQzFDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBYzFELE1BQU0sT0FBTyxzQkFBc0I7OztZQVpsQyxRQUFRLFNBQUM7Z0JBQ1IsT0FBTyxFQUFFO29CQUNQLFlBQVk7b0JBQ1osV0FBVztvQkFDWCxZQUFZO29CQUNaLFlBQVk7b0JBQ1oscUJBQXFCO2lCQUN0QjtnQkFDRCxPQUFPLEVBQUUsQ0FBQyxtQkFBbUIsQ0FBQztnQkFDOUIsWUFBWSxFQUFFLENBQUMsbUJBQW1CLENBQUM7Z0JBQ25DLFNBQVMsRUFBRSxFQUFFO2FBQ2QiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOZ01vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XG5cbmltcG9ydCB7IFNoYXJlZE1vZHVsZSB9IGZyb20gJy4uLy4uL3NoYXJlZC5tb2R1bGUnO1xuaW1wb3J0IHsgRmlsZVVwbG9hZENvbXBvbmVudCB9IGZyb20gJy4vZmlsZS11cGxvYWQuY29tcG9uZW50JztcbmltcG9ydCB7IFdlYmNhbU1vZHVsZSB9IGZyb20gJ25neC13ZWJjYW0nO1xuaW1wb3J0IHsgTmd4RmlsZVVwbG9hZGVyTW9kdWxlIH0gZnJvbSAnbmd4LWZpbGUtdXBsb2FkZXInO1xuXG5ATmdNb2R1bGUoe1xuICBpbXBvcnRzOiBbXG4gICAgQ29tbW9uTW9kdWxlLFxuICAgIEZvcm1zTW9kdWxlLFxuICAgIFNoYXJlZE1vZHVsZSxcbiAgICBXZWJjYW1Nb2R1bGUsXG4gICAgTmd4RmlsZVVwbG9hZGVyTW9kdWxlXG4gIF0sXG4gIGV4cG9ydHM6IFtGaWxlVXBsb2FkQ29tcG9uZW50XSxcbiAgZGVjbGFyYXRpb25zOiBbRmlsZVVwbG9hZENvbXBvbmVudF0sXG4gIHByb3ZpZGVyczogW11cbn0pXG5leHBvcnQgY2xhc3MgUmVtb3RlRmlsZVVwbG9hZE1vZHVsZSB7fVxuIl19

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

@@ -0,0 +1,102 @@
+/* eslint-disable @angular-eslint/component-class-suffix */
+import { Pipe, WrappedValue, ChangeDetectorRef } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { DomSanitizer } from '@angular/platform-browser';
+// Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.
+// eslint-disable-next-line @angular-eslint/use-pipe-transform-interface
+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.decorators = [
+    { type: Pipe, args: [{
+                name: 'secure',
+                pure: false
+            },] }
+];
+SecurePipe.ctorParameters = () => [
+    { type: ChangeDetectorRef },
+    { type: DomSanitizer }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"secure.pipe.js","sourceRoot":"","sources":["../../../../../projects/ngx-formentry/src/components/file-upload/secure.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @angular-eslint/component-class-suffix */\nimport {\n  Pipe,\n  PipeTransform,\n  OnDestroy,\n  WrappedValue,\n  ChangeDetectorRef\n} from '@angular/core';\nimport { Subscription, Observable, BehaviorSubject } from 'rxjs';\n\nimport { DomSanitizer } from '@angular/platform-browser';\n\n// Using similarity from AsyncPipe to avoid having to pipe |secure|async in HTML.\n// eslint-disable-next-line @angular-eslint/use-pipe-transform-interface\n@Pipe({\n  name: 'secure',\n  pure: false\n})\nexport class SecurePipe implements PipeTransform, OnDestroy {\n  private _latestValue: any = null;\n  private _latestReturnedValue: any = null;\n  private _subscription: Subscription = null;\n  private _obj: Observable<any> = null;\n  private getfile;\n  private previousUrl: string;\n  private _result: BehaviorSubject<any> = new BehaviorSubject(null);\n  private result: Observable<any> = this._result.asObservable();\n  private _internalSubscription: Subscription = null;\n\n  constructor(\n    private _ref: ChangeDetectorRef,\n    private sanitizer: DomSanitizer\n  ) {}\n\n  ngOnDestroy(): void {\n    if (this._subscription) {\n      this._dispose();\n    }\n  }\n\n  transform(url: string, getfile): any {\n    this.getfile = getfile;\n    const obj = this.internalTransform(url);\n    return this.asyncTrasnform(obj);\n  }\n\n  private internalTransform(url: string): Observable<any> {\n    if (!url) {\n      return this.result;\n    }\n\n    if (this.previousUrl !== url) {\n      this.previousUrl = url;\n      this._internalSubscription = this.getfile(url).subscribe((m) => {\n        const sanitized = this.sanitizer.bypassSecurityTrustUrl(m);\n        this._result.next(sanitized);\n      });\n    }\n\n    return this.result;\n  }\n\n  private asyncTrasnform(obj: Observable<any>): any {\n    if (!this._obj) {\n      if (obj) {\n        this._subscribe(obj);\n      }\n      this._latestReturnedValue = this._latestValue;\n      return this._latestValue;\n    }\n    if (obj !== this._obj) {\n      this._dispose();\n      return this.asyncTrasnform(obj);\n    }\n    if (this._latestValue === this._latestReturnedValue) {\n      return this._latestReturnedValue;\n    }\n    this._latestReturnedValue = this._latestValue;\n    return WrappedValue.wrap(this._latestValue);\n  }\n\n  private _subscribe(obj: Observable<any>) {\n    const _this = this;\n    this._obj = obj;\n\n    this._subscription = obj.subscribe({\n      next: function (value) {\n        return _this._updateLatestValue(obj, value);\n      },\n      error: (e: any) => {\n        throw e;\n      }\n    });\n  }\n\n  private _dispose() {\n    if (this._subscription) {\n      this._subscription.unsubscribe();\n    }\n    if (this._internalSubscription) {\n      this._internalSubscription.unsubscribe();\n    }\n\n    this._internalSubscription = null;\n    this._latestValue = null;\n    this._latestReturnedValue = null;\n    this._subscription = null;\n    this._obj = null;\n  }\n\n  private _updateLatestValue(async: any, value: Object) {\n    if (async === this._obj) {\n      this._latestValue = value;\n      this._ref.markForCheck();\n    }\n  }\n}\n"]}

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

@@ -0,0 +1,55 @@
+/* eslint-disable @angular-eslint/component-class-suffix, @angular-eslint/directive-class-suffix */
+import { Directive, HostBinding, Input } from '@angular/core';
+/**
+ * A directive for applying styling to an input element.
+ *
+ * Example:
+ *
+ * ```html
+ * <input ibmText/>
+ * ```
+ *
+ * See the [vanilla carbon docs](http://www.carbondesignsystem.com/components/text-input/code) for more detail.
+ */
+export class TextInput {
+    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';
+    }
+}
+TextInput.decorators = [
+    { type: Directive, args: [{
+                selector: '[ibmText]'
+            },] }
+];
+TextInput.propDecorators = {
+    theme: [{ type: Input }],
+    size: [{ type: Input }],
+    inputClass: [{ type: HostBinding, args: ['class.bx--text-input',] }],
+    isSizeXl: [{ type: HostBinding, args: ['class.bx--text-input--xl',] }],
+    isSizeSm: [{ type: HostBinding, args: ['class.bx--text-input--sm',] }],
+    invalid: [{ type: HostBinding, args: ['class.bx--text-input--invalid',] }, { type: Input }],
+    warn: [{ type: HostBinding, args: ['class.bx--text-input__field-wrapper--warning',] }, { type: Input }],
+    skeleton: [{ type: HostBinding, args: ['class.bx--skeleton',] }, { type: Input }],
+    isLightTheme: [{ type: HostBinding, args: ['class.bx--text-input--light',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,18 @@
+// modules
+import { NgModule } from '@angular/core';
+import { FormsModule } from '@angular/forms';
+import { CommonModule } from '@angular/common';
+// imports
+import { Label } from './label.component';
+import { TextInput } from './input.directive';
+import { TextArea } from './text-area.directive';
+export class InputModule {
+}
+InputModule.decorators = [
+    { type: NgModule, args: [{
+                declarations: [Label, TextInput, TextArea],
+                exports: [Label, TextInput, TextArea],
+                imports: [CommonModule, FormsModule]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbmd4LWZvcm1lbnRyeS9zcmMvY29tcG9uZW50cy9pbnB1dC9pbnB1dC5tb2R1bGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsVUFBVTtBQUNWLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLGdCQUFnQixDQUFDO0FBQzdDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUUvQyxVQUFVO0FBQ1YsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQzFDLE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUM5QyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFPakQsTUFBTSxPQUFPLFdBQVc7OztZQUx2QixRQUFRLFNBQUM7Z0JBQ1IsWUFBWSxFQUFFLENBQUMsS0FBSyxFQUFFLFNBQVMsRUFBRSxRQUFRLENBQUM7Z0JBQzFDLE9BQU8sRUFBRSxDQUFDLEtBQUssRUFBRSxTQUFTLEVBQUUsUUFBUSxDQUFDO2dCQUNyQyxPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsV0FBVyxDQUFDO2FBQ3JDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gbW9kdWxlc1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcblxuLy8gaW1wb3J0c1xuaW1wb3J0IHsgTGFiZWwgfSBmcm9tICcuL2xhYmVsLmNvbXBvbmVudCc7XG5pbXBvcnQgeyBUZXh0SW5wdXQgfSBmcm9tICcuL2lucHV0LmRpcmVjdGl2ZSc7XG5pbXBvcnQgeyBUZXh0QXJlYSB9IGZyb20gJy4vdGV4dC1hcmVhLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW0xhYmVsLCBUZXh0SW5wdXQsIFRleHRBcmVhXSxcbiAgZXhwb3J0czogW0xhYmVsLCBUZXh0SW5wdXQsIFRleHRBcmVhXSxcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgRm9ybXNNb2R1bGVdXG59KVxuZXhwb3J0IGNsYXNzIElucHV0TW9kdWxlIHt9XG4iXX0=