@colijnit/corecomponents_v12 12.2.25 → 12.2.27

package/esm2015/lib/components/input-number-picker/input-number-picker.component.js

@@ -0,0 +1,314 @@
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ComponentFactoryResolver, ElementRef, EventEmitter, forwardRef, HostBinding, Inject, Input, NgZone, Optional, Output, ViewEncapsulation } from '@angular/core';
+import { BaseInputComponent } from '../base/base-input.component';
+import { InputBoolean } from '../../core/decorator/input-boolean.decorator';
+import { BoundsConstrainedNumberValue } from '../../core/model/bounds-constrained-number-value';
+import { NUMBER_INPUTS_KEY_DOWN_WHITE_LIST } from '../../core/constant/number-inputs-key-down-white-list';
+import { FormInputUserModelChangeListenerService } from '../../core/service/form-input-user-change-listener.service';
+import { InputNumberPickerButtonShowMode } from '../../core/enum/input-number-picker-show-mode.enum';
+import { IconCacheService } from '../icon/icon-cache.service';
+import { CoreComponentsIcon } from '../../core/enum/core-components-icon.enum';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '../../interfaces/screen-config-adapter-component-interface-name';
+import { FormComponent } from '../form/form.component';
+import { OverlayService } from '../../service/overlay.service';
+import { NgZoneWrapperService } from '../../core/service/ng-zone-wrapper.service';
+// A component that lets users pick a number by increasing and decreasing it with buttons, or by typing.
+export class InputNumberPickerComponent extends BaseInputComponent {
+    constructor(formComponent, iconCacheService, overlayService, _ngZone, componentFactoryResolver, changeDetector, formUserChangeListener, ngZoneWrapper, elementRef) {
+        super(changeDetector, componentFactoryResolver, overlayService, formUserChangeListener, ngZoneWrapper, elementRef);
+        this.formComponent = formComponent;
+        this.iconCacheService = iconCacheService;
+        this.overlayService = overlayService;
+        this._ngZone = _ngZone;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.ngZoneWrapper = ngZoneWrapper;
+        this.elementRef = elementRef;
+        this.modelChangeOnEnter = true;
+        this.minusIcon = CoreComponentsIcon.MinusSimple;
+        this.plusIcon = CoreComponentsIcon.PlusSimple;
+        // Whether to show buttons 'always', 'onFocusOnly', or 'never'
+        this.buttonShowMode = InputNumberPickerButtonShowMode.Always;
+        // @override Default true for us.
+        this.noValidation = true;
+        // @override
+        this.modelChange = new EventEmitter();
+        this.iconClick = new EventEmitter();
+        this.myKeyDownWhiteList = NUMBER_INPUTS_KEY_DOWN_WHITE_LIST;
+        this.numberLogic = new BoundsConstrainedNumberValue();
+        this.minSelected = false;
+        this.plusSelected = false;
+        this._numberInputHasFocus = false;
+        this._changeFromButton = false;
+        this._delayBeforeStartAutoCountMs = 666;
+        // the 'speed gears' for auto counting
+        this._stepFactors = [1, 10, 20];
+        // increase step size timing
+        this._msChangeStepFactor = 1000;
+        // step speed
+        this._msDoStep = 5;
+        // hold the mouse down and this increases for a faster auto increment
+        this._stepFactor = this._stepFactors[0];
+        this._mayAutoCount = false;
+        this._numberLogicValueChangeSub = this.numberLogic.valueChange.subscribe((value) => {
+            if (!this._mayAutoCount) {
+                this.model = value;
+                if (!this.modelChangeOnEnter || this._changeFromButton) {
+                    this.modelChange.emit(value);
+                }
+                // custom form user chagne listener .next because we don't user super.updateModel() which normally does that for us
+                if (this._markedAsUserTouched) {
+                    this.formUserChangeListener.userModelChange.next(value);
+                    this.userModelChange.next(value);
+                }
+            }
+        });
+    }
+    // @override
+    set model(model) {
+        this.setValue(model, true);
+        super.model = model;
+    }
+    get model() {
+        return super.model;
+    }
+    set min(min) {
+        this.numberLogic.min = min;
+    }
+    set step(step) {
+        this.numberLogic.step = step;
+    }
+    set max(max) {
+        this.numberLogic.max = max;
+    }
+    set decimals(decimals) {
+        this.numberLogic.decimals = decimals;
+    }
+    get showButtonsOnFocusOnly() {
+        return this.buttonShowMode === InputNumberPickerButtonShowMode.OnFocusOnly;
+    }
+    get hasLabel() {
+        return !!this.label;
+    }
+    showClass() {
+        return true;
+    }
+    ngOnInit() {
+        // this.numberLogic.setValue(this.model, true);
+        // this.numberLogic.init(true);
+        this._updateButtonsShowState();
+    }
+    ngOnDestroy() {
+        this._numberLogicValueChangeSub.unsubscribe();
+        clearTimeout(this._autoCountTimeout);
+        clearTimeout(this._stepIncrementTimeout);
+        clearTimeout(this._startAutocountTimeout);
+    }
+    // Note: recursive through setTimeout().
+    doIncrementAuto() {
+        this._mayAutoCount = true;
+        this.increment(this._stepFactor);
+        this._ngZone.runOutsideAngular(() => {
+            this._autoCountTimeout = window.setTimeout(() => {
+                if (this._mayAutoCount) {
+                    this.doIncrementAuto();
+                    this.changeDetector.detectChanges();
+                }
+            }, this._msDoStep);
+        });
+    }
+    handleInputKeyDown(event) {
+        // event.preventDefault();
+        if (event.code === 'Enter' || event.code === 'NumpadEnter') {
+            this.modelChange.next(this.model);
+            return false;
+        }
+        if (this.myKeyDownWhiteList.find((k) => k === event.keyCode) === undefined) {
+            return false;
+        }
+    }
+    handleBlur() {
+        this.modelChange.next(this.model);
+    }
+    handleChangeModel(value) {
+        this._changeFromButton = false;
+        this.numberLogic.setValue(value);
+    }
+    // Note: recursive through setTimeout().
+    doDecrementAuto() {
+        this._mayAutoCount = true;
+        this.decrement(this._stepFactor);
+        this._ngZone.runOutsideAngular(() => {
+            this._autoCountTimeout = window.setTimeout(() => {
+                if (this._mayAutoCount) {
+                    this.doDecrementAuto();
+                    this.changeDetector.detectChanges();
+                }
+            }, this._msDoStep);
+        });
+    }
+    stopAutoCounting() {
+        this.minSelected = false;
+        this.plusSelected = false;
+        this._mayAutoCount = false;
+        this._stepFactor = this._stepFactors[0];
+    }
+    // Sets the current number value with given newValue, optionally silent (no valueChange event fired).
+    setValue(newValue, silent = false) {
+        this.numberLogic.setValue(newValue, silent);
+    }
+    increment(steps = 1) {
+        this._changeFromButton = true;
+        this.numberLogic.increment(steps);
+    }
+    decrement(steps = 1) {
+        this._changeFromButton = true;
+        this.numberLogic.decrement(steps);
+    }
+    onPlusMouseDown(event) {
+        if (this.readonly) {
+            event.preventDefault();
+            return;
+        }
+        this.plusSelected = true;
+        this._markedAsUserTouched = true;
+        // keeps focus on input text instead of button
+        event.preventDefault();
+        this.increment();
+        this._mayAutoCount = true;
+        clearTimeout(this._startAutocountTimeout);
+        this._startAutocountTimeout = window.setTimeout(() => {
+            if (this._mayAutoCount) {
+                this.doIncrementAuto();
+                this._doIncreaseStepFactor();
+            }
+        }, this._delayBeforeStartAutoCountMs);
+    }
+    onMinusMouseDown(event) {
+        if (this.readonly) {
+            event.preventDefault();
+            return;
+        }
+        this.minSelected = true;
+        this._markedAsUserTouched = true;
+        // keeps focus on input text instead of button
+        event.preventDefault();
+        this.decrement();
+        this._mayAutoCount = true;
+        clearTimeout(this._startAutocountTimeout);
+        this._startAutocountTimeout = window.setTimeout(() => {
+            if (this._mayAutoCount) {
+                this.doDecrementAuto();
+                this._doIncreaseStepFactor();
+            }
+        }, this._delayBeforeStartAutoCountMs);
+    }
+    // Note: recursive.
+    _doIncreaseStepFactor() {
+        this._stepIncrementTimeout = window.setTimeout(() => {
+            if (this._mayAutoCount) {
+                this._stepFactor = this._getNextStepFactorMouseDown();
+                this._doIncreaseStepFactor();
+            }
+        }, this._msChangeStepFactor);
+    }
+    _getNextStepFactorMouseDown() {
+        const curIdx = this._stepFactors.indexOf(this._stepFactor);
+        if (curIdx < this._stepFactors.length - 1) {
+            return this._stepFactors[curIdx + 1];
+        }
+        return this._stepFactor;
+    }
+    // Show or hide + and - buttons. Might hide buttons if number input lost focus and button show mode is on focus only.
+    _updateButtonsShowState() {
+        switch (this.buttonShowMode) {
+            case InputNumberPickerButtonShowMode.Always:
+            default:
+                this.showButtons = true;
+                break;
+            case InputNumberPickerButtonShowMode.OnFocusOnly:
+                this.showButtons = this._numberInputHasFocus;
+                break;
+            case InputNumberPickerButtonShowMode.Never:
+                this.showButtons = false;
+                break;
+        }
+    }
+}
+InputNumberPickerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-input-number-picker',
+                template: `
+        <div class="icon-wrapper" *ngIf="leftIconData">
+            <co-icon class="input-number-picker-icon" [iconData]="leftIconData" (click)="iconClick.emit($event)"></co-icon>
+            <div class="spacer"></div>
+        </div>
+        <div class="button-wrapper">
+            <co-button *ngIf="showButtons" class="minus-operator" [class.select]="minSelected" tabindex="-1"
+                       [disabled]="readonly"
+                       [iconData]="iconCacheService.getIcon(minusIcon)"
+                       (mousedown)="onMinusMouseDown($event)"
+                       (mouseup)="stopAutoCounting()" (mouseleave)="stopAutoCounting()"></co-button>
+        </div>
+        <input type="text"
+               [tabIndex]="readonly ? -1 : 0"
+               [ngModel]="model"
+               [readonly]="readonly"
+               [disabled]="disabled"
+               [required]="required"
+               (ngModelChange)="handleChangeModel($event)"
+               (keydown)="handleInputKeyDown($event)"
+               (blur)="handleBlur()"/>
+        <div class="button-wrapper">
+            <co-button *ngIf="showButtons" class="plus-operator" [class.select]="plusSelected" tabindex="-1"
+                       [disabled]="readonly"
+                       [iconData]="iconCacheService.getIcon(plusIcon)"
+                       (mousedown)="onPlusMouseDown($event)"
+                       (mouseup)="stopAutoCounting()" (mouseleave)="stopAutoCounting()"></co-button>
+        </div>
+    `,
+                providers: [
+                    OverlayService, {
+                        provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME, useExisting: forwardRef(() => InputNumberPickerComponent)
+                    }, {
+                        provide: BaseInputComponent,
+                        useExisting: InputNumberPickerComponent
+                    }
+                ],
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+InputNumberPickerComponent.ctorParameters = () => [
+    { type: FormComponent, decorators: [{ type: Optional }] },
+    { type: IconCacheService, decorators: [{ type: Inject, args: [IconCacheService,] }] },
+    { type: OverlayService },
+    { type: NgZone },
+    { type: ComponentFactoryResolver },
+    { type: ChangeDetectorRef },
+    { type: FormInputUserModelChangeListenerService },
+    { type: NgZoneWrapperService },
+    { type: ElementRef }
+];
+InputNumberPickerComponent.propDecorators = {
+    model: [{ type: Input }],
+    modelChangeOnEnter: [{ type: Input }],
+    leftIconData: [{ type: HostBinding, args: ['class.has-icon',] }, { type: Input }],
+    min: [{ type: Input }],
+    step: [{ type: Input }],
+    max: [{ type: Input }],
+    ngModelOptions: [{ type: Input }],
+    minusIcon: [{ type: Input }],
+    plusIcon: [{ type: Input }],
+    buttonShowMode: [{ type: Input }],
+    noValidation: [{ type: Input }],
+    decimals: [{ type: Input }],
+    modelChange: [{ type: Output }],
+    iconClick: [{ type: Output }],
+    showButtonsOnFocusOnly: [{ type: HostBinding, args: ['class.show-buttons-on-focus-only',] }],
+    hasLabel: [{ type: HostBinding, args: ['class.has-label',] }],
+    showClass: [{ type: HostBinding, args: ['class.co-input-number-picker',] }]
+};
+__decorate([
+    InputBoolean()
+], InputNumberPickerComponent.prototype, "noValidation", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"input-number-picker.component.js","sourceRoot":"","sources":["../../../../../../projects/corecomponents/src/lib/components/input-number-picker/input-number-picker.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    ChangeDetectorRef,\n    Component,\n    ComponentFactoryResolver, ElementRef,\n    EventEmitter,\n    forwardRef,\n    HostBinding,\n    Inject,\n    Input,\n    NgZone,\n    OnDestroy,\n    OnInit,\n    Optional,\n    Output,\n    ViewChild,\n    ViewEncapsulation\n} from '@angular/core';\nimport {BaseInputComponent} from '../base/base-input.component';\nimport {InputBoolean} from '../../core/decorator/input-boolean.decorator';\nimport {Subscription} from 'rxjs';\nimport {BoundsConstrainedNumberValue} from '../../core/model/bounds-constrained-number-value';\nimport {NUMBER_INPUTS_KEY_DOWN_WHITE_LIST} from '../../core/constant/number-inputs-key-down-white-list';\nimport {KeyboardCode} from '../../core/enum/keyboard-code.enum';\nimport {InputTextComponent} from '../input-text/input-text.component';\nimport {FormInputUserModelChangeListenerService} from '../../core/service/form-input-user-change-listener.service';\nimport {InputNumberPickerButtonShowMode} from '../../core/enum/input-number-picker-show-mode.enum';\nimport {IconCacheService} from '../icon/icon-cache.service';\nimport {CoreComponentsIcon} from '../../core/enum/core-components-icon.enum';\nimport {SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME} from '../../interfaces/screen-config-adapter-component-interface-name';\nimport {FormComponent} from '../form/form.component';\nimport {OverlayService} from '../../service/overlay.service';\nimport {SafeHtml} from '@angular/platform-browser';\nimport {NgZoneWrapperService} from '../../core/service/ng-zone-wrapper.service';\n\n@Component({\n    selector: 'co-input-number-picker',\n    template: `\n        <div class=\"icon-wrapper\" *ngIf=\"leftIconData\">\n            <co-icon class=\"input-number-picker-icon\" [iconData]=\"leftIconData\" (click)=\"iconClick.emit($event)\"></co-icon>\n            <div class=\"spacer\"></div>\n        </div>\n        <div class=\"button-wrapper\">\n            <co-button *ngIf=\"showButtons\" class=\"minus-operator\" [class.select]=\"minSelected\" tabindex=\"-1\"\n                       [disabled]=\"readonly\"\n                       [iconData]=\"iconCacheService.getIcon(minusIcon)\"\n                       (mousedown)=\"onMinusMouseDown($event)\"\n                       (mouseup)=\"stopAutoCounting()\" (mouseleave)=\"stopAutoCounting()\"></co-button>\n        </div>\n        <input type=\"text\"\n               [tabIndex]=\"readonly ? -1 : 0\"\n               [ngModel]=\"model\"\n               [readonly]=\"readonly\"\n               [disabled]=\"disabled\"\n               [required]=\"required\"\n               (ngModelChange)=\"handleChangeModel($event)\"\n               (keydown)=\"handleInputKeyDown($event)\"\n               (blur)=\"handleBlur()\"/>\n        <div class=\"button-wrapper\">\n            <co-button *ngIf=\"showButtons\" class=\"plus-operator\" [class.select]=\"plusSelected\" tabindex=\"-1\"\n                       [disabled]=\"readonly\"\n                       [iconData]=\"iconCacheService.getIcon(plusIcon)\"\n                       (mousedown)=\"onPlusMouseDown($event)\"\n                       (mouseup)=\"stopAutoCounting()\" (mouseleave)=\"stopAutoCounting()\"></co-button>\n        </div>\n    `,\n    providers: [\n        OverlayService, {\n            provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME, useExisting: forwardRef(() => InputNumberPickerComponent)\n        }, {\n            provide: BaseInputComponent,\n            useExisting: InputNumberPickerComponent\n        }],\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    encapsulation: ViewEncapsulation.None,\n})\n// A component that lets users pick a number by increasing and decreasing it with buttons, or by typing.\nexport class InputNumberPickerComponent extends BaseInputComponent<number> implements OnInit, OnDestroy {\n\n    // @override\n    @Input()\n    public set model(model: number) {\n        this.setValue(model, true);\n        super.model = model;\n    }\n\n    public get model(): number {\n        return super.model;\n    }\n\n    @Input()\n    public modelChangeOnEnter: boolean = true;\n\n    @HostBinding('class.has-icon')\n    @Input()\n    public leftIconData: SafeHtml | undefined;\n\n    @Input()\n    public set min(min: number) {\n        this.numberLogic.min = min;\n    }\n\n    @Input()\n    public set step(step: number) {\n        this.numberLogic.step = step;\n    }\n\n    @Input()\n    public set max(max: number) {\n        this.numberLogic.max = max;\n    }\n\n    @Input()\n    public ngModelOptions: any;\n\n    @Input()\n    public minusIcon: CoreComponentsIcon = CoreComponentsIcon.MinusSimple;\n\n    @Input()\n    public plusIcon: CoreComponentsIcon = CoreComponentsIcon.PlusSimple;\n\n    // Whether to show buttons 'always', 'onFocusOnly', or 'never'\n    @Input()\n    public buttonShowMode: InputNumberPickerButtonShowMode = InputNumberPickerButtonShowMode.Always;\n\n    // @override Default true for us.\n    @Input() @InputBoolean()\n    public noValidation: boolean = true;\n\n    @Input()\n    public set decimals(decimals: number) {\n        this.numberLogic.decimals = decimals;\n    }\n\n    // @override\n    @Output()\n    public readonly modelChange: EventEmitter<number> = new EventEmitter<number>();\n\n    @Output()\n    public readonly iconClick: EventEmitter<MouseEvent> = new EventEmitter<MouseEvent>();\n\n    @HostBinding('class.show-buttons-on-focus-only')\n    public get showButtonsOnFocusOnly(): boolean {\n        return this.buttonShowMode === InputNumberPickerButtonShowMode.OnFocusOnly;\n    }\n\n    @HostBinding('class.has-label')\n    public get hasLabel(): boolean {\n        return !!this.label;\n    }\n\n    @HostBinding('class.co-input-number-picker')\n    public showClass(): boolean {\n        return true;\n    }\n\n    public showButtons: boolean;\n\n    public readonly myKeyDownWhiteList: KeyboardCode[] = NUMBER_INPUTS_KEY_DOWN_WHITE_LIST;\n\n    public readonly numberLogic: BoundsConstrainedNumberValue = new BoundsConstrainedNumberValue();\n\n    public minSelected: boolean = false;\n    public plusSelected: boolean = false;\n\n    private _numberInputHasFocus: boolean = false;\n    private _changeFromButton: boolean = false;\n\n    private _numberLogicValueChangeSub: Subscription;\n    private readonly _delayBeforeStartAutoCountMs: number = 666;\n    // the 'speed gears' for auto counting\n    private readonly _stepFactors: number[] = [1, 10, 20];\n    // increase step size timing\n    private readonly _msChangeStepFactor: number = 1000;\n    // step speed\n    private readonly _msDoStep: number = 5;\n    // hold the mouse down and this increases for a faster auto increment\n    private _stepFactor: number = this._stepFactors[0];\n    private _mayAutoCount: boolean = false;\n\n    private _autoCountTimeout: number;\n    private _stepIncrementTimeout: number;\n    private _startAutocountTimeout: number;\n\n    constructor(\n        @Optional() public formComponent: FormComponent,\n        @Inject(IconCacheService) public iconCacheService: IconCacheService,\n        protected overlayService: OverlayService,\n        private _ngZone: NgZone,\n        protected componentFactoryResolver: ComponentFactoryResolver,\n        changeDetector: ChangeDetectorRef,\n        formUserChangeListener: FormInputUserModelChangeListenerService,\n        protected ngZoneWrapper?: NgZoneWrapperService,\n        public elementRef?: ElementRef,\n    ) {\n        super(changeDetector, componentFactoryResolver, overlayService, formUserChangeListener, ngZoneWrapper, elementRef);\n\n        this._numberLogicValueChangeSub = this.numberLogic.valueChange.subscribe((value: number) => {\n            if (!this._mayAutoCount) {\n                this.model = value;\n                if (!this.modelChangeOnEnter || this._changeFromButton) {\n                    this.modelChange.emit(value);\n                }\n                // custom form user chagne listener .next because we don't user super.updateModel() which normally does that for us\n                if (this._markedAsUserTouched) {\n                    this.formUserChangeListener.userModelChange.next(value);\n                    this.userModelChange.next(value);\n                }\n            }\n        });\n    }\n\n    ngOnInit(): void {\n        // this.numberLogic.setValue(this.model, true);\n        // this.numberLogic.init(true);\n        this._updateButtonsShowState();\n    }\n\n    ngOnDestroy(): void {\n        this._numberLogicValueChangeSub.unsubscribe();\n        clearTimeout(this._autoCountTimeout);\n        clearTimeout(this._stepIncrementTimeout);\n        clearTimeout(this._startAutocountTimeout);\n    }\n\n    // Note: recursive through setTimeout().\n    public doIncrementAuto(): void {\n        this._mayAutoCount = true;\n\n        this.increment(this._stepFactor);\n\n        this._ngZone.runOutsideAngular(() => {\n            this._autoCountTimeout = window.setTimeout(() => {\n                if (this._mayAutoCount) {\n                    this.doIncrementAuto();\n                    this.changeDetector.detectChanges();\n                }\n            }, this._msDoStep);\n        });\n    }\n\n    public handleInputKeyDown(event: KeyboardEvent): boolean {\n        // event.preventDefault();\n        if (event.code === 'Enter' || event.code === 'NumpadEnter') {\n            this.modelChange.next(this.model);\n            return false;\n        }\n        if (this.myKeyDownWhiteList.find((k) => k === event.keyCode) === undefined) {\n            return false;\n        }\n    }\n\n    public handleBlur(): void {\n        this.modelChange.next(this.model);\n    }\n\n    public handleChangeModel(value: number): void {\n        this._changeFromButton = false;\n        this.numberLogic.setValue(value);\n    }\n\n    // Note: recursive through setTimeout().\n    public doDecrementAuto(): void {\n        this._mayAutoCount = true;\n\n        this.decrement(this._stepFactor);\n\n        this._ngZone.runOutsideAngular(() => {\n            this._autoCountTimeout = window.setTimeout(() => {\n                if (this._mayAutoCount) {\n                    this.doDecrementAuto();\n                    this.changeDetector.detectChanges();\n                }\n            }, this._msDoStep);\n        });\n    }\n\n    public stopAutoCounting(): void {\n        this.minSelected = false;\n        this.plusSelected = false;\n        this._mayAutoCount = false;\n        this._stepFactor = this._stepFactors[0];\n    }\n\n    // Sets the current number value with given newValue, optionally silent (no valueChange event fired).\n    public setValue(newValue: number, silent: boolean = false): void {\n        this.numberLogic.setValue(newValue, silent);\n    }\n\n    public increment(steps: number = 1): void {\n        this._changeFromButton = true;\n        this.numberLogic.increment(steps);\n    }\n\n    public decrement(steps: number = 1): void {\n        this._changeFromButton = true;\n        this.numberLogic.decrement(steps);\n    }\n\n    public onPlusMouseDown(event: Event): void {\n        if (this.readonly) {\n            event.preventDefault();\n            return;\n        }\n        this.plusSelected = true;\n        this._markedAsUserTouched = true;\n\n        // keeps focus on input text instead of button\n        event.preventDefault();\n\n        this.increment();\n        this._mayAutoCount = true;\n\n        clearTimeout(this._startAutocountTimeout);\n        this._startAutocountTimeout = window.setTimeout(() => {\n            if (this._mayAutoCount) {\n                this.doIncrementAuto();\n                this._doIncreaseStepFactor();\n            }\n        }, this._delayBeforeStartAutoCountMs);\n    }\n\n    public onMinusMouseDown(event: Event): void {\n        if (this.readonly) {\n            event.preventDefault();\n            return;\n        }\n        this.minSelected = true;\n        this._markedAsUserTouched = true;\n        // keeps focus on input text instead of button\n        event.preventDefault();\n\n        this.decrement();\n        this._mayAutoCount = true;\n\n        clearTimeout(this._startAutocountTimeout);\n        this._startAutocountTimeout = window.setTimeout(() => {\n            if (this._mayAutoCount) {\n                this.doDecrementAuto();\n                this._doIncreaseStepFactor();\n            }\n        }, this._delayBeforeStartAutoCountMs);\n    }\n\n    // Note: recursive.\n    private _doIncreaseStepFactor(): void {\n        this._stepIncrementTimeout = window.setTimeout(() => {\n            if (this._mayAutoCount) {\n                this._stepFactor = this._getNextStepFactorMouseDown();\n                this._doIncreaseStepFactor();\n            }\n        }, this._msChangeStepFactor);\n    }\n\n    private _getNextStepFactorMouseDown(): number {\n        const curIdx: number = this._stepFactors.indexOf(this._stepFactor);\n        if (curIdx < this._stepFactors.length - 1) {\n            return this._stepFactors[curIdx + 1];\n        }\n        return this._stepFactor;\n    }\n\n    // Show or hide + and - buttons. Might hide buttons if number input lost focus and button show mode is on focus only.\n    private _updateButtonsShowState(): void {\n        switch (this.buttonShowMode) {\n            case InputNumberPickerButtonShowMode.Always:\n            default:\n                this.showButtons = true;\n                break;\n            case InputNumberPickerButtonShowMode.OnFocusOnly:\n                this.showButtons = this._numberInputHasFocus;\n                break;\n            case InputNumberPickerButtonShowMode.Never:\n                this.showButtons = false;\n                break;\n        }\n    }\n}\n"]}

package/esm2015/lib/components/input-number-picker/input-number-picker.module.js

@@ -0,0 +1,23 @@
+import { NgModule } from "@angular/core";
+import { CommonModule } from "@angular/common";
+import { InputNumberPickerComponent } from "./input-number-picker.component";
+import { ButtonModule } from "../button/button.module";
+import { InputTextModule } from "../input-text/input-text.module";
+import { FormsModule } from "@angular/forms";
+import { IconModule } from '../icon/icon.module';
+export class InputNumberPickerModule {
+}
+InputNumberPickerModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    CommonModule,
+                    FormsModule,
+                    ButtonModule,
+                    InputTextModule,
+                    IconModule
+                ],
+                declarations: [InputNumberPickerComponent],
+                exports: [InputNumberPickerComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtbnVtYmVyLXBpY2tlci5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9jb3JlY29tcG9uZW50cy9zcmMvbGliL2NvbXBvbmVudHMvaW5wdXQtbnVtYmVyLXBpY2tlci9pbnB1dC1udW1iZXItcGlja2VyLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsUUFBUSxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZDLE9BQU8sRUFBQyxZQUFZLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQztBQUM3QyxPQUFPLEVBQUMsMEJBQTBCLEVBQUMsTUFBTSxpQ0FBaUMsQ0FBQztBQUMzRSxPQUFPLEVBQUMsWUFBWSxFQUFDLE1BQU0seUJBQXlCLENBQUM7QUFDckQsT0FBTyxFQUFDLGVBQWUsRUFBQyxNQUFNLGlDQUFpQyxDQUFDO0FBQ2hFLE9BQU8sRUFBQyxXQUFXLEVBQUMsTUFBTSxnQkFBZ0IsQ0FBQztBQUMzQyxPQUFPLEVBQUMsVUFBVSxFQUFDLE1BQU0scUJBQXFCLENBQUM7QUFhL0MsTUFBTSxPQUFPLHVCQUF1Qjs7O1lBWG5DLFFBQVEsU0FBQztnQkFDTixPQUFPLEVBQUU7b0JBQ0wsWUFBWTtvQkFDWixXQUFXO29CQUNYLFlBQVk7b0JBQ1osZUFBZTtvQkFDZixVQUFVO2lCQUNiO2dCQUNILFlBQVksRUFBRSxDQUFDLDBCQUEwQixDQUFDO2dCQUMxQyxPQUFPLEVBQUUsQ0FBQywwQkFBMEIsQ0FBQzthQUN0QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TmdNb2R1bGV9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XG5pbXBvcnQge0NvbW1vbk1vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2NvbW1vblwiO1xuaW1wb3J0IHtJbnB1dE51bWJlclBpY2tlckNvbXBvbmVudH0gZnJvbSBcIi4vaW5wdXQtbnVtYmVyLXBpY2tlci5jb21wb25lbnRcIjtcbmltcG9ydCB7QnV0dG9uTW9kdWxlfSBmcm9tIFwiLi4vYnV0dG9uL2J1dHRvbi5tb2R1bGVcIjtcbmltcG9ydCB7SW5wdXRUZXh0TW9kdWxlfSBmcm9tIFwiLi4vaW5wdXQtdGV4dC9pbnB1dC10ZXh0Lm1vZHVsZVwiO1xuaW1wb3J0IHtGb3Jtc01vZHVsZX0gZnJvbSBcIkBhbmd1bGFyL2Zvcm1zXCI7XG5pbXBvcnQge0ljb25Nb2R1bGV9IGZyb20gJy4uL2ljb24vaWNvbi5tb2R1bGUnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGltcG9ydHM6IFtcbiAgICAgICAgQ29tbW9uTW9kdWxlLFxuICAgICAgICBGb3Jtc01vZHVsZSxcbiAgICAgICAgQnV0dG9uTW9kdWxlLFxuICAgICAgICBJbnB1dFRleHRNb2R1bGUsXG4gICAgICAgIEljb25Nb2R1bGVcbiAgICBdLFxuICBkZWNsYXJhdGlvbnM6IFtJbnB1dE51bWJlclBpY2tlckNvbXBvbmVudF0sXG4gIGV4cG9ydHM6IFtJbnB1dE51bWJlclBpY2tlckNvbXBvbmVudF1cbn0pXG5leHBvcnQgY2xhc3MgSW5wdXROdW1iZXJQaWNrZXJNb2R1bGUgeyB9XG4iXX0=

package/esm2015/lib/components/input-radio-button/input-radio-button.component.js

@@ -0,0 +1,84 @@
+import { ChangeDetectorRef, Component, ComponentFactoryResolver, ElementRef, forwardRef, HostBinding, HostListener, Optional, ViewEncapsulation } from '@angular/core';
+import { BaseInputComponent } from '../base/base-input.component';
+import { FormComponent } from '../form/form.component';
+import { FormInputUserModelChangeListenerService } from '../../core/service/form-input-user-change-listener.service';
+import { NgZoneWrapperService } from '../../core/service/ng-zone-wrapper.service';
+import { SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME } from '../../interfaces/screen-config-adapter-component-interface-name';
+import { animate, state, style, transition, trigger } from '@angular/animations';
+import { OverlayService } from '../../service/overlay.service';
+export class InputRadioButtonComponent extends BaseInputComponent {
+    constructor(formComponent, changeDetector, overlayService, componentFactoryResolver, formUserChangeListener, ngZoneWrapper, elementRef) {
+        super(changeDetector, componentFactoryResolver, overlayService, formUserChangeListener, ngZoneWrapper, elementRef);
+        this.formComponent = formComponent;
+        this.changeDetector = changeDetector;
+        this.overlayService = overlayService;
+        this.componentFactoryResolver = componentFactoryResolver;
+        this.formUserChangeListener = formUserChangeListener;
+        this.ngZoneWrapper = ngZoneWrapper;
+        this.elementRef = elementRef;
+        super._markAsOnPush();
+    }
+    get isModelSelected() {
+        return this.model;
+    }
+    showClass() {
+        return true;
+    }
+    handleClick(event) {
+        event.preventDefault();
+        event.stopPropagation();
+        if (!this.readonly) {
+            this.model = true;
+            this.modelChange.next(this.model);
+            if (this.control) {
+                this.control.markAsDirty({ onlySelf: true });
+            }
+            if (this.formComponent) {
+                this.formComponent.formGroup.markAsDirty({ onlySelf: true });
+            }
+        }
+    }
+}
+InputRadioButtonComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'co-input-radio-button',
+                template: `
+        <div class="outer-circle" [class.selected]="model">
+            <div class="inner-circle" *ngIf="model" @showSelected></div>
+        </div>
+        <div class="label" *ngIf="label" [textContent]="label"></div>
+        <input #input [ngModel]="model" type="hidden">
+    `,
+                providers: [
+                    OverlayService, {
+                        provide: SCREEN_CONFIG_ADAPTER_COMPONENT_INTERFACE_NAME, useExisting: forwardRef(() => InputRadioButtonComponent)
+                    }, {
+                        provide: BaseInputComponent,
+                        useExisting: InputRadioButtonComponent
+                    }
+                ],
+                animations: [
+                    trigger('showSelected', [
+                        state('void', style({ transform: 'scale(0)' })),
+                        state('*', style({ transform: 'scale(1)' })),
+                        transition('void <=> *', animate('200ms ease-in-out')),
+                    ])
+                ],
+                encapsulation: ViewEncapsulation.None
+            },] }
+];
+InputRadioButtonComponent.ctorParameters = () => [
+    { type: FormComponent, decorators: [{ type: Optional }] },
+    { type: ChangeDetectorRef },
+    { type: OverlayService },
+    { type: ComponentFactoryResolver },
+    { type: FormInputUserModelChangeListenerService },
+    { type: NgZoneWrapperService },
+    { type: ElementRef }
+];
+InputRadioButtonComponent.propDecorators = {
+    isModelSelected: [{ type: HostBinding, args: ['class.selected',] }],
+    showClass: [{ type: HostBinding, args: ['class.co-radio-button',] }],
+    handleClick: [{ type: HostListener, args: ['click', ['$event'],] }]
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/lib/components/input-radio-button/input-radio-button.module.js

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { FormsModule } from '@angular/forms';
+import { BaseModule } from '../base/base.module';
+import { InputRadioButtonComponent } from './input-radio-button.component';
+export class InputRadioButtonModule {
+}
+InputRadioButtonModule.decorators = [
+    { type: NgModule, args: [{
+                imports: [
+                    BaseModule,
+                    CommonModule,
+                    FormsModule
+                ],
+                declarations: [InputRadioButtonComponent],
+                exports: [InputRadioButtonComponent]
+            },] }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5wdXQtcmFkaW8tYnV0dG9uLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2NvcmVjb21wb25lbnRzL3NyYy9saWIvY29tcG9uZW50cy9pbnB1dC1yYWRpby1idXR0b24vaW5wdXQtcmFkaW8tYnV0dG9uLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFDN0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ2pELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBVzNFLE1BQU0sT0FBTyxzQkFBc0I7OztZQVRsQyxRQUFRLFNBQUM7Z0JBQ04sT0FBTyxFQUFFO29CQUNMLFVBQVU7b0JBQ1YsWUFBWTtvQkFDWixXQUFXO2lCQUNkO2dCQUNELFlBQVksRUFBRSxDQUFDLHlCQUF5QixDQUFDO2dCQUN6QyxPQUFPLEVBQUUsQ0FBQyx5QkFBeUIsQ0FBQzthQUN2QyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IEZvcm1zTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvZm9ybXMnO1xyXG5pbXBvcnQgeyBCYXNlTW9kdWxlIH0gZnJvbSAnLi4vYmFzZS9iYXNlLm1vZHVsZSc7XHJcbmltcG9ydCB7IElucHV0UmFkaW9CdXR0b25Db21wb25lbnQgfSBmcm9tICcuL2lucHV0LXJhZGlvLWJ1dHRvbi5jb21wb25lbnQnO1xyXG5cclxuQE5nTW9kdWxlKHtcclxuICAgIGltcG9ydHM6IFtcclxuICAgICAgICBCYXNlTW9kdWxlLFxyXG4gICAgICAgIENvbW1vbk1vZHVsZSxcclxuICAgICAgICBGb3Jtc01vZHVsZVxyXG4gICAgXSxcclxuICAgIGRlY2xhcmF0aW9uczogW0lucHV0UmFkaW9CdXR0b25Db21wb25lbnRdLFxyXG4gICAgZXhwb3J0czogW0lucHV0UmFkaW9CdXR0b25Db21wb25lbnRdXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBJbnB1dFJhZGlvQnV0dG9uTW9kdWxlIHtcclxufVxyXG4iXX0=

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,72 @@
+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.isFocused = 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)"
+              (isFocused)="isFocused.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 }],
+    isFocused: [{ type: Output }],
+    barCodeScanned: [{ type: Output }],
+    showClass: [{ type: HostBinding, args: ['class.co-input-scanner',] }]
+};
+//# sourceMappingURL=data:application/json;base64,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