@colijnit/corecomponents_v12 12.2.13 → 12.2.15

package/esm2015/colijnit-corecomponents_v12.js

@@ -5,16 +5,20 @@ export * from './public-api';
 export { BaseModule as ɵj } from './lib/components/base/base.module';
 export { CommitButtonsComponent as ɵt } from './lib/components/base/commit-buttons/commit-buttons.component';
 export { CommitButtonsModule as ɵs } from './lib/components/base/commit-buttons/commit-buttons.module';
+export { DialogBaseComponent as ɵbf } from './lib/components/base/dialog-base.component';
 export { CalendarTemplateComponent as ɵw } from './lib/components/calendar/calendar-template.component';
 export { CheckmarkOverlayComponent as ɵbj } from './lib/components/checkmark-overlay/checkmark-overlay.component';
+export { ConfirmationDialogComponent as ɵbe } from './lib/components/core-dialog/confirmation-dialog/confirmation-dialog.component';
+export { CoreDynamicComponentService as ɵbg } from './lib/components/core-dialog/core-dynamic-component.service';
+export { ScannerService as ɵbk } from './lib/components/input-scanner/scanner.service';
 export { ListOfValuesMultiselectPopupComponent as ɵbd } from './lib/components/list-of-values/list-of-values-multiselect-popup.component';
 export { PaginatePipe as ɵbb } from './lib/components/pagination/paginate.pipe';
 export { PaginationService as ɵba } from './lib/components/pagination/pagination.service';
 export { PopupShowerService as ɵx } from './lib/components/popup/service/popup-shower.service';
 export { BaseSimpleGridComponent as ɵy } from './lib/components/simple-grid/base-simple-grid.component';
 export { SimpleGridCellComponent as ɵbc } from './lib/components/simple-grid/simple-grid-cell.component';
-export { TooltipComponent as ɵbh } from './lib/components/tooltip/tooltip.component';
-export { TooltipModule as ɵbg } from './lib/components/tooltip/tooltip.module';
+export { TooltipComponent as ɵbm } from './lib/components/tooltip/tooltip.component';
+export { TooltipModule as ɵbl } from './lib/components/tooltip/tooltip.module';
 export { ValidationErrorComponent as ɵr } from './lib/components/validation-error/validation-error.component';
 export { ValidationErrorModule as ɵm } from './lib/components/validation-error/validation-error.module';
 export { InputBoolean as ɵa } from './lib/core/decorator/input-boolean.decorator';
@@ -30,11 +34,11 @@ export { CoScrollableDirective as ɵg } from './lib/directives/ripple/scrollable
 export { CoViewportRulerService as ɵe } from './lib/directives/ripple/viewport-ruler.service';
 export { StopClickDirective as ɵi } from './lib/directives/stopclick/stop-click.directive';
 export { StopClickModule as ɵh } from './lib/directives/stopclick/stop-click.module';
-export { TooltipDirective as ɵbi } from './lib/directives/tooltip/tooltip.directive';
+export { TooltipDirective as ɵbn } from './lib/directives/tooltip/tooltip.directive';
 export { AppendPipe as ɵl } from './lib/pipes/append.pipe';
 export { AppendPipeModule as ɵk } from './lib/pipes/append.pipe.module';
-export { PrependPipe as ɵbf } from './lib/pipes/prepend.pipe';
-export { PrependPipeModule as ɵbe } from './lib/pipes/prepend.pipe.module';
+export { PrependPipe as ɵbi } from './lib/pipes/prepend.pipe';
+export { PrependPipeModule as ɵbh } from './lib/pipes/prepend.pipe.module';
 export { CoreDictionaryService as ɵq } from './lib/translation/core-dictionary.service';
 export { CoreLocalizePipe as ɵp } from './lib/translation/core-localize.pipe';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"colijnit-corecomponents_v12.js","sourceRoot":"","sources":["../../../projects/corecomponents/src/colijnit-corecomponents_v12.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n\nexport {BaseModule as ɵj} from './lib/components/base/base.module';\nexport {CommitButtonsComponent as ɵt} from './lib/components/base/commit-buttons/commit-buttons.component';\nexport {CommitButtonsModule as ɵs} from './lib/components/base/commit-buttons/commit-buttons.module';\nexport {DialogBaseComponent as ɵbf} from './lib/components/base/dialog-base.component';\nexport {CalendarTemplateComponent as ɵw} from './lib/components/calendar/calendar-template.component';\nexport {CheckmarkOverlayComponent as ɵbj} from './lib/components/checkmark-overlay/checkmark-overlay.component';\nexport {ConfirmationDialogComponent as ɵbe} from './lib/components/core-dialog/confirmation-dialog/confirmation-dialog.component';\nexport {CoreDynamicComponentService as ɵbg} from './lib/components/core-dialog/core-dynamic-component.service';\nexport {ScannerService as ɵbk} from './lib/components/input-scanner/scanner.service';\nexport {ListOfValuesMultiselectPopupComponent as ɵbd} from './lib/components/list-of-values/list-of-values-multiselect-popup.component';\nexport {PaginatePipe as ɵbb} from './lib/components/pagination/paginate.pipe';\nexport {PaginationService as ɵba} from './lib/components/pagination/pagination.service';\nexport {PopupShowerService as ɵx} from './lib/components/popup/service/popup-shower.service';\nexport {BaseSimpleGridComponent as ɵy} from './lib/components/simple-grid/base-simple-grid.component';\nexport {SimpleGridCellComponent as ɵbc} from './lib/components/simple-grid/simple-grid-cell.component';\nexport {TooltipComponent as ɵbm} from './lib/components/tooltip/tooltip.component';\nexport {TooltipModule as ɵbl} from './lib/components/tooltip/tooltip.module';\nexport {ValidationErrorComponent as ɵr} from './lib/components/validation-error/validation-error.component';\nexport {ValidationErrorModule as ɵm} from './lib/components/validation-error/validation-error.module';\nexport {InputBoolean as ɵa} from './lib/core/decorator/input-boolean.decorator';\nexport {ClickOutsideMasterService as ɵv} from './lib/directives/clickoutside/click-outside-master.service';\nexport {ClickOutsideDirective as ɵu} from './lib/directives/clickoutside/click-outside.directive';\nexport {ObserveVisibilityDirective as ɵz} from './lib/directives/observe-visibility/observe-visibility.directive';\nexport {OverlayParentDirective as ɵo} from './lib/directives/overlay/overlay-parent.directive';\nexport {OverlayDirective as ɵn} from './lib/directives/overlay/overlay.directive';\nexport {CoRippleDirective as ɵd,MD_RIPPLE_GLOBAL_OPTIONS as ɵc} from './lib/directives/ripple/ripple.directive';\nexport {RippleModule as ɵb} from './lib/directives/ripple/ripple.module';\nexport {CoScrollDispatcherService as ɵf} from './lib/directives/ripple/scroll-dispatcher.service';\nexport {CoScrollableDirective as ɵg} from './lib/directives/ripple/scrollable.directive';\nexport {CoViewportRulerService as ɵe} from './lib/directives/ripple/viewport-ruler.service';\nexport {StopClickDirective as ɵi} from './lib/directives/stopclick/stop-click.directive';\nexport {StopClickModule as ɵh} from './lib/directives/stopclick/stop-click.module';\nexport {TooltipDirective as ɵbn} from './lib/directives/tooltip/tooltip.directive';\nexport {AppendPipe as ɵl} from './lib/pipes/append.pipe';\nexport {AppendPipeModule as ɵk} from './lib/pipes/append.pipe.module';\nexport {PrependPipe as ɵbi} from './lib/pipes/prepend.pipe';\nexport {PrependPipeModule as ɵbh} from './lib/pipes/prepend.pipe.module';\nexport {CoreDictionaryService as ɵq} from './lib/translation/core-dictionary.service';\nexport {CoreLocalizePipe as ɵp} from './lib/translation/core-localize.pipe';"]}

package/esm2015/lib/components/base/dialog-base.component.js

@@ -0,0 +1,6 @@
+export class DialogBaseComponent {
+    onClose(eventType, output, rememberChoice) {
+        return;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlhbG9nLWJhc2UuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvY29yZWNvbXBvbmVudHMvc3JjL2xpYi9jb21wb25lbnRzL2Jhc2UvZGlhbG9nLWJhc2UuY29tcG9uZW50LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBZ0IsbUJBQW1CO0lBRXZDLE9BQU8sQ0FBQyxTQUE2QixFQUFFLE1BQVksRUFBRSxjQUF3QjtRQUMzRSxPQUFPO0lBQ1QsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtBcHBQb3B1cEJ1dHRvblR5cGV9IGZyb20gJy4uLy4uL21vZGVsL2VudW0vYXBwLWJ1dHRvbi10eXBlLmVudW0nO1xyXG5cclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIERpYWxvZ0Jhc2VDb21wb25lbnQge1xyXG5cclxuICBvbkNsb3NlKGV2ZW50VHlwZTogQXBwUG9wdXBCdXR0b25UeXBlLCBvdXRwdXQ/OiBhbnksIHJlbWVtYmVyQ2hvaWNlPzogYm9vbGVhbik6IHZvaWQge1xyXG4gICAgcmV0dXJuO1xyXG4gIH1cclxufVxyXG4iXX0=

package/esm2015/lib/components/core-dialog/confirmation-dialog/confirmation-dialog.component.js

@@ -0,0 +1,79 @@
+import { Component, HostBinding, Input, ViewEncapsulation } from '@angular/core';
+import { IconCacheService } from '../../icon/icon-cache.service';
+import { CoreComponentsIcon } from '../../../core/enum/core-components-icon.enum';
+import { AppPopupType } from '../../../model/enum/app-popup-type.enum';
+import { AppPopupButtonType } from '../../../model/enum/app-button-type.enum';
+import { DialogBaseComponent } from '../../base/dialog-base.component';
+export class ConfirmationDialogComponent extends DialogBaseComponent {
+    constructor(iconCacheService) {
+        super();
+        this.iconCacheService = iconCacheService;
+        this.icons = CoreComponentsIcon;
+        this.ptype = AppPopupType;
+        this.showRememberCheckbox = false;
+        this.rememberChoice = false;
+    }
+    showClass() {
+        return true;
+    }
+    handleYesClick(event) {
+        this.onClose(AppPopupButtonType.Yes, undefined, this.rememberChoice);
+    }
+    handleNoClick(event) {
+        this.onClose(AppPopupButtonType.No, undefined, this.rememberChoice);
+    }
+    handleOkClick(event) {
+        this.onClose(AppPopupButtonType.Ok, undefined, this.rememberChoice);
+    }
+}
+ConfirmationDialogComponent.decorators = [
+    { type: Component, args: [{
+                selector: "co-confirmation-dialog",
+                template: `
+    <co-dialog [showCloseIcon]="false" [headerTemplate]="headerTemplate" [footerTemplate]="footerTemplate">
+      <div class="confirmation-dialog-wrapper">
+        <div class="text" [innerHTML]="text"></div>
+        <co-collapsible [headerTitle]="'DETAILS' | coreLocalize" [iconData]="iconCacheService.getIcon(icons.TriangleDown)" *ngIf="details">
+          <div class="dialog-details" [innerHTML]="details"></div>
+        </co-collapsible>
+      </div>
+    </co-dialog>
+    <ng-template #headerTemplate>
+      <div class="co-dialog-header-title" [textContent]="title"></div>
+    </ng-template>
+    <ng-template #footerTemplate>
+      <div class="co-dialog-footer-button-wrapper">
+        <ng-container *ngIf="type === ptype.Confirmation">
+          <co-button class="save-button"
+                     [label]="'YES' | coreLocalize"
+                     (click)="handleYesClick($event)"></co-button>
+          <co-button class="close-button"
+                     [label]="'NO' | coreLocalize"
+                     (click)="handleNoClick($event)"></co-button>
+        </ng-container>
+        <ng-container *ngIf="type === ptype.Information || type === ptype.Error || type === ptype.Warning">
+          <co-button class="save-button"
+                     [iconData]="iconCacheService.getIcon(icons.CheckDuotone)"
+                     (click)="handleYesClick($event)"></co-button>
+        </ng-container>
+      </div>
+      <ng-container *ngIf="showRememberCheckbox">
+        <co-input-checkbox [label]="'REMEMBER_CHOICE' | coreLocalize" [(model)]="rememberChoice"></co-input-checkbox>
+      </ng-container>
+    </ng-template>
+  `,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+ConfirmationDialogComponent.ctorParameters = () => [
+    { type: IconCacheService }
+];
+ConfirmationDialogComponent.propDecorators = {
+    title: [{ type: Input }],
+    text: [{ type: Input }],
+    details: [{ type: Input }],
+    type: [{ type: Input }],
+    showRememberCheckbox: [{ type: Input }],
+    showClass: [{ type: HostBinding, args: ["class.co-confirmation-dialog",] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dialog.module.js

@@ -0,0 +1,39 @@
+import { NgModule } from '@angular/core';
+import { CoreDialogService } from './core-dialog.service';
+import { ConfirmationDialogComponent } from './confirmation-dialog/confirmation-dialog.component';
+import { CoDialogModule } from '../co-dialog/co-dialog.module';
+import { CollapsibleModule } from '../collapsible/collapsible.module';
+import { CoreComponentsTranslationModule } from '../../translation/core-components-translation.module';
+import { ButtonModule } from '../button/button.module';
+import { InputCheckboxModule } from '../input-checkbox/input-checkbox.module';
+import { CommonModule } from '@angular/common';
+export class CoreDialogModule {
+    static forRoot() {
+        return {
+            ngModule: CoreDialogModule,
+            providers: [
+                CoreDialogService
+            ]
+        };
+    }
+}
+CoreDialogModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    CoDialogModule,
+                    CollapsibleModule,
+                    CoreComponentsTranslationModule,
+                    ButtonModule,
+                    InputCheckboxModule
+                ],
+                declarations: [
+                    ConfirmationDialogComponent
+                ],
+                providers: [
+                    CoreDialogService
+                ],
+                exports: []
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dialog.service.js

@@ -0,0 +1,67 @@
+import { __awaiter } from "tslib";
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from '@angular/core';
+import { CoreDynamicComponentService } from './core-dynamic-component.service';
+import { AppPopupType } from '../../model/enum/app-popup-type.enum';
+import { ConfirmationDialogComponent } from './confirmation-dialog/confirmation-dialog.component';
+import * as i0 from "@angular/core";
+import * as i1 from "./core-dynamic-component.service";
+export class CoreDialogService {
+    constructor(_compFactoryResolver, appRef, injector, dynamicComponentService) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this.dynamicComponentService = dynamicComponentService;
+        this._componentRefs = [];
+    }
+    showYesNo(title, text, showRememberChoice = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = {
+                title: title,
+                text: text,
+                type: AppPopupType.Confirmation,
+                showRememberCheckbox: showRememberChoice
+            };
+            return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+        });
+    }
+    showError(message, details) {
+        const data = {
+            title: 'ERROR',
+            text: message,
+            type: AppPopupType.Error
+        };
+        if (details) {
+            data.details = details;
+        }
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+    showInformation(message) {
+        const data = {
+            title: 'INFORMATION',
+            text: message,
+            type: AppPopupType.Information
+        };
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+    showWarning(message) {
+        const data = {
+            title: 'WARNING',
+            text: message,
+            type: AppPopupType.Warning
+        };
+        return this.dynamicComponentService.createComponent(ConfirmationDialogComponent, data);
+    }
+}
+CoreDialogService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CoreDialogService_Factory() { return new CoreDialogService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR), i0.ɵɵinject(i1.CoreDynamicComponentService)); }, token: CoreDialogService, providedIn: "root" });
+CoreDialogService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+CoreDialogService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Injector },
+    { type: CoreDynamicComponentService }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/core-dialog/core-dynamic-component.service.js

@@ -0,0 +1,93 @@
+import { ApplicationRef, ComponentFactoryResolver, Injectable, Injector } from "@angular/core";
+import * as i0 from "@angular/core";
+export class CoreDynamicComponentService {
+    constructor(_compFactoryResolver, appRef, injector) {
+        this._compFactoryResolver = _compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+        this._componentRefs = [];
+    }
+    getComponentRefs() {
+        return this._componentRefs;
+    }
+    createAndReturnComponentRef(componentClass, inputs) {
+        return new Promise((resolve) => {
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            resolve(componentRef);
+        });
+    }
+    createComponent(componentClass, inputs, outputs, providers) {
+        return new Promise((resolve) => {
+            if (providers) {
+                Injector.create(providers, this.injector);
+            }
+            const componentRef = this._compFactoryResolver
+                .resolveComponentFactory(componentClass)
+                .create(this.injector);
+            this._componentRefs.push(componentRef);
+            if (inputs) {
+                for (let property in inputs) {
+                    if (inputs.hasOwnProperty(property)) {
+                        componentRef.instance[property] = inputs[property];
+                    }
+                }
+            }
+            if (outputs) {
+                for (let event in outputs) {
+                    if (outputs.hasOwnProperty(event)) {
+                        componentRef.instance[event].subscribe(() => outputs[event]());
+                    }
+                }
+            }
+            this.appRef.attachView(componentRef.hostView);
+            const domElem = componentRef.hostView
+                .rootNodes[0];
+            document.body.appendChild(domElem);
+            componentRef.onDestroy(() => {
+                this.appRef.detachView(componentRef.hostView);
+            });
+            componentRef.instance.onClose = (button, output, rememberChoice) => {
+                const idx = this._componentRefs.indexOf(componentRef);
+                this.appRef.detachView(componentRef.hostView);
+                this._componentRefs[idx] = undefined;
+                this._componentRefs.splice(idx, 1);
+                if (outputs) {
+                    for (let event in outputs) {
+                        if (outputs.hasOwnProperty(event)) {
+                            componentRef.instance[event].unsubscribe();
+                        }
+                    }
+                }
+                resolve({ button: button, output: output ? output : undefined, rememberChoice: rememberChoice });
+            };
+        });
+    }
+}
+CoreDynamicComponentService.ɵprov = i0.ɵɵdefineInjectable({ factory: function CoreDynamicComponentService_Factory() { return new CoreDynamicComponentService(i0.ɵɵinject(i0.ComponentFactoryResolver), i0.ɵɵinject(i0.ApplicationRef), i0.ɵɵinject(i0.INJECTOR)); }, token: CoreDynamicComponentService, providedIn: "root" });
+CoreDynamicComponentService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: "root"
+            },] }
+];
+CoreDynamicComponentService.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: ApplicationRef },
+    { type: Injector }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"core-dynamic-component.service.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/core-dialog/core-dynamic-component.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,cAAc,EAAE,wBAAwB,EAAiC,UAAU,EAAE,QAAQ,EAAiB,MAAM,eAAe,CAAC;;AAM5I,MAAM,OAAO,2BAA2B;IAItC,YACU,oBAA8C,EAC9C,MAAsB,EACtB,QAAkB;QAFlB,yBAAoB,GAApB,oBAAoB,CAA0B;QAC9C,WAAM,GAAN,MAAM,CAAgB;QACtB,aAAQ,GAAR,QAAQ,CAAU;QALpB,mBAAc,GAAU,EAAE,CAAC;IAM/B,CAAC;IAEE,gBAAgB;QACrB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAEM,2BAA2B,CAAC,cAAmB,EAAE,MAAY;QAClE,OAAO,IAAI,OAAO,CAAC,CAAC,OAAiB,EAAE,EAAE;YACvC,MAAM,YAAY,GAAQ,IAAI,CAAC,oBAAoB;iBAChD,uBAAuB,CAAC,cAAc,CAAC;iBACvC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAEzB,IAAI,MAAM,EAAE;gBACV,KAAK,IAAI,QAAQ,IAAI,MAAM,EAAE;oBAC3B,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;wBACnC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;qBACpD;iBACF;aACF;YAED,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAE9C,MAAM,OAAO,GAAI,YAAY,CAAC,QAAiC;iBAC5D,SAAS,CAAC,CAAC,CAAgB,CAAC;YAE/B,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YACnC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;gBAC1B,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;YACH,OAAO,CAAC,YAAY,CAAC,CAAC;QACxB,CAAC,CAAC,CAAA;IACJ,CAAC;IAEM,eAAe,CAAC,cAAmB,EAAE,MAAY,EAAE,OAAa,EAAE,SAA4B;QACnG,OAAO,IAAI,OAAO,CAAC,CAAC,OAAiB,EAAE,EAAE;YACvC,IAAI,SAAS,EAAE;gBACb,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;aAC3C;YACD,MAAM,YAAY,GAAQ,IAAI,CAAC,oBAAoB;iBAChD,uBAAuB,CAAC,cAAc,CAAC;iBACvC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YAEvC,IAAI,MAAM,EAAE;gBACV,KAAK,IAAI,QAAQ,IAAI,MAAM,EAAE;oBAC3B,IAAI,MAAM,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE;wBACnC,YAAY,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;qBACpD;iBACF;aACF;YAED,IAAI,OAAO,EAAE;gBACX,KAAK,IAAI,KAAK,IAAI,OAAO,EAAE;oBACzB,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;wBACjC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;qBAChE;iBACF;aACF;YAED,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAE9C,MAAM,OAAO,GAAI,YAAY,CAAC,QAAiC;iBAC5D,SAAS,CAAC,CAAC,CAAgB,CAAC;YAE/B,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YACnC,YAAY,CAAC,SAAS,CAAC,GAAG,EAAE;gBAC1B,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;YAChD,CAAC,CAAC,CAAC;YAEH,YAAY,CAAC,QAAQ,CAAC,OAAO,GAAG,CAAC,MAAW,EAAE,MAAY,EAAE,cAAwB,EAAE,EAAE;gBACtF,MAAM,GAAG,GAAW,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;gBAC9D,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;gBAC9C,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;gBACrC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;gBAEnC,IAAI,OAAO,EAAE;oBACX,KAAK,IAAI,KAAK,IAAI,OAAO,EAAE;wBACzB,IAAI,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;4BACjC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC;yBAC5C;qBACF;iBACF;gBACD,OAAO,CAAC,EAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,EAAE,cAAc,EAAE,cAAc,EAAC,CAAC,CAAC;YACjG,CAAC,CAAA;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;;;;YAhGF,UAAU,SAAC;gBACV,UAAU,EAAE,MAAM;aACnB;;;YALuB,wBAAwB;YAAxC,cAAc;YAAuE,QAAQ","sourcesContent":["import {ApplicationRef, ComponentFactoryResolver, ComponentRef, EmbeddedViewRef, Injectable, Injector, StaticProvider} from \"@angular/core\";\r\nimport {DialogResponseInterface} from '../../interfaces/dialog-response.interface';\r\n\r\n@Injectable({\r\n  providedIn: \"root\"\r\n})\r\nexport class CoreDynamicComponentService {\r\n\r\n  private _componentRefs: any[] = [];\r\n\r\n  constructor(\r\n    private _compFactoryResolver: ComponentFactoryResolver,\r\n    private appRef: ApplicationRef,\r\n    private injector: Injector\r\n  ) { }\r\n\r\n  public getComponentRefs(): ComponentRef<any>[] {\r\n    return this._componentRefs;\r\n  }\r\n\r\n  public createAndReturnComponentRef(componentClass: any, inputs?: any): Promise<any> {\r\n    return new Promise((resolve: Function) => {\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n      resolve(componentRef);\r\n    })\r\n  }\r\n\r\n  public createComponent(componentClass: any, inputs?: any, outputs?: any, providers?: StaticProvider[]): Promise<DialogResponseInterface> {\r\n    return new Promise((resolve: Function) => {\r\n      if (providers) {\r\n        Injector.create(providers, this.injector);\r\n      }\r\n      const componentRef: any = this._compFactoryResolver\r\n        .resolveComponentFactory(componentClass)\r\n        .create(this.injector);\r\n      this._componentRefs.push(componentRef);\r\n\r\n      if (inputs) {\r\n        for (let property in inputs) {\r\n          if (inputs.hasOwnProperty(property)) {\r\n            componentRef.instance[property] = inputs[property];\r\n          }\r\n        }\r\n      }\r\n\r\n      if (outputs) {\r\n        for (let event in outputs) {\r\n          if (outputs.hasOwnProperty(event)) {\r\n            componentRef.instance[event].subscribe(() => outputs[event]());\r\n          }\r\n        }\r\n      }\r\n\r\n      this.appRef.attachView(componentRef.hostView);\r\n\r\n      const domElem = (componentRef.hostView as EmbeddedViewRef<any>)\r\n        .rootNodes[0] as HTMLElement;\r\n\r\n      document.body.appendChild(domElem);\r\n      componentRef.onDestroy(() => {\r\n        this.appRef.detachView(componentRef.hostView);\r\n      });\r\n\r\n      componentRef.instance.onClose = (button: any, output?: any, rememberChoice?: boolean) => {\r\n        const idx: number = this._componentRefs.indexOf(componentRef);\r\n        this.appRef.detachView(componentRef.hostView);\r\n        this._componentRefs[idx] = undefined;\r\n        this._componentRefs.splice(idx, 1);\r\n\r\n        if (outputs) {\r\n          for (let event in outputs) {\r\n            if (outputs.hasOwnProperty(event)) {\r\n              componentRef.instance[event].unsubscribe();\r\n            }\r\n          }\r\n        }\r\n        resolve({button: button, output: output ? output : undefined, rememberChoice: rememberChoice});\r\n      }\r\n    })\r\n  }\r\n}\r\n"]}

package/esm2015/lib/components/input-scanner/bar-code-scanner.js

@@ -0,0 +1,23 @@
+export class BarCodeScanner {
+    constructor() {
+        this._buffer = [];
+        this._keyPress = (event) => {
+            if (event.key === "Enter") {
+                document.dispatchEvent(this._createScanEvent());
+                this._buffer.length = 0;
+            }
+            else {
+                const str = event.key;
+                this._buffer.push(str);
+            }
+        };
+        document.addEventListener('keypress', this._keyPress);
+    }
+    close() {
+        document.removeEventListener('keypress', this._keyPress);
+    }
+    _createScanEvent() {
+        return new CustomEvent("barcodescanned", { detail: this._buffer.join("") });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/input-scanner/input-scanner.component.js

@@ -0,0 +1,69 @@
+import { Component, EventEmitter, HostBinding, Input, Output, ViewEncapsulation } from '@angular/core';
+import { ScannerService } from './scanner.service';
+import { OverlayService } from '../../service/overlay.service';
+export class InputScannerComponent {
+    constructor(_scannerService) {
+        this._scannerService = _scannerService;
+        this.centerLabel = false;
+        this.useLeftIcon = false;
+        this.useRightIcon = false;
+        this.modelChange = new EventEmitter();
+        this.leftIconClick = new EventEmitter();
+        this.rightIconClick = new EventEmitter();
+        this.search = new EventEmitter();
+        this.barCodeScanned = new EventEmitter();
+        this._scannerService.registerInput(this);
+    }
+    showClass() {
+        return true;
+    }
+    triggerCodeScanned(code) {
+        this.model = code;
+        this.barCodeScanned.next(this.model);
+    }
+}
+InputScannerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-input-scanner',
+                template: `
+      <co-input-search
+              [(model)]="model"
+              [customCssClass]="customCssClass"
+              [placeholder]="placeholder"
+              [centerLabel]="centerLabel"
+              [useLeftIcon]="useLeftIcon"
+              [leftIconData]="leftIconData"
+              [useRightIcon]="useRightIcon"
+              [rightIconData]="rightIconData"
+              (leftIconClick)="leftIconClick.emit($event)"
+              (rightIconClick)="rightIconClick.emit($event)"
+              (search)="search.emit($event)"
+      ></co-input-search>
+    `,
+                providers: [
+                    ScannerService,
+                    OverlayService
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+InputScannerComponent.ctorParameters = () => [
+    { type: ScannerService }
+];
+InputScannerComponent.propDecorators = {
+    model: [{ type: Input }],
+    placeholder: [{ type: Input }],
+    centerLabel: [{ type: Input }],
+    useLeftIcon: [{ type: Input }],
+    useRightIcon: [{ type: Input }],
+    leftIconData: [{ type: Input }],
+    rightIconData: [{ type: Input }],
+    customCssClass: [{ type: Input }],
+    modelChange: [{ type: Output }],
+    leftIconClick: [{ type: Output }],
+    rightIconClick: [{ type: Output }],
+    search: [{ type: Output }],
+    barCodeScanned: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-input-scanner',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/input-scanner/input-scanner.module.js

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { InputScannerComponent } from './input-scanner.component';
+import { InputSearchModule } from '../input-search/input-search.module';
+export class InputScannerModule {
+}
+InputScannerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    InputSearchModule
+                ],
+                declarations: [
+                    InputScannerComponent
+                ],
+                exports: [
+                    InputScannerComponent
+                ]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtc2Nhbm5lci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvaW5wdXQtc2Nhbm5lci9pbnB1dC1zY2FubmVyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMscUJBQXFCLEVBQUMsTUFBTSwyQkFBMkIsQ0FBQztBQUNoRSxPQUFPLEVBQUMsaUJBQWlCLEVBQUMsTUFBTSxxQ0FBcUMsQ0FBQztBQWN0RSxNQUFNLE9BQU8sa0JBQWtCOzs7WUFaOUIsUUFBUSxTQUFDO2dCQUNSLE9BQU8sRUFBRTtvQkFDUCxZQUFZO29CQUNaLGlCQUFpQjtpQkFDbEI7Z0JBQ0QsWUFBWSxFQUFFO29CQUNaLHFCQUFxQjtpQkFDdEI7Z0JBQ0QsT0FBTyxFQUFFO29CQUNQLHFCQUFxQjtpQkFDdEI7YUFDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcclxuaW1wb3J0IHtJbnB1dFNjYW5uZXJDb21wb25lbnR9IGZyb20gJy4vaW5wdXQtc2Nhbm5lci5jb21wb25lbnQnO1xyXG5pbXBvcnQge0lucHV0U2VhcmNoTW9kdWxlfSBmcm9tICcuLi9pbnB1dC1zZWFyY2gvaW5wdXQtc2VhcmNoLm1vZHVsZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtcclxuICAgIENvbW1vbk1vZHVsZSxcclxuICAgIElucHV0U2VhcmNoTW9kdWxlXHJcbiAgXSxcclxuICBkZWNsYXJhdGlvbnM6IFtcclxuICAgIElucHV0U2Nhbm5lckNvbXBvbmVudFxyXG4gIF0sXHJcbiAgZXhwb3J0czogW1xyXG4gICAgSW5wdXRTY2FubmVyQ29tcG9uZW50XHJcbiAgXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgSW5wdXRTY2FubmVyTW9kdWxlIHtcclxufVxyXG4iXX0=

package/esm2015/lib/components/input-scanner/scanner.service.js

@@ -0,0 +1,28 @@
+import { Injectable, NgZone } from '@angular/core';
+import { BarCodeScanner } from './bar-code-scanner';
+export class ScannerService {
+    constructor(_ngZone) {
+        this._ngZone = _ngZone;
+        this.barCodeScanner = new BarCodeScanner();
+        this._barCodeScanned = (event) => {
+            if (this._activeInput) {
+                this._activeInput.triggerCodeScanned(event.detail);
+            }
+        };
+        document.addEventListener("barcodescanned", this._barCodeScanned);
+    }
+    ngOnDestroy() {
+        document.removeEventListener("barcodescanned", this._barCodeScanned);
+        this.barCodeScanner.close();
+    }
+    registerInput(input) {
+        this._activeInput = input;
+    }
+}
+ScannerService.decorators = [
+    { type: Injectable }
+];
+ScannerService.ctorParameters = () => [
+    { type: NgZone }
+];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/input-search/input-search.component.js

@@ -45,6 +45,7 @@ InputSearchComponent.decorators = [
       (modelChange)="modelChange.emit($event)"
       (leftIconClick)="leftIconClick.emit($event)"
       (rightIconClick)="rightIconClick.emit($event)"
+      (keyup)="keyUp.emit($event)"
     ></co-input-text>
   `,
                 providers: [
@@ -72,4 +73,4 @@ __decorate([
 __decorate([
     InputBoolean()
 ], InputSearchComponent.prototype, "useRightIcon", void 0);
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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