@colijnit/corecomponents_v12 12.2.26 → 12.2.28

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

@@ -1,242 +1,242 @@
-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',
+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>
@@ -265,50 +265,50 @@ InputNumberPickerComponent.decorators = [
                        (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);
+    `,
+                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"]}