@quadrel-enterprise-ui/framework 1.0.0 → 18.19.1

package/esm2022/lib/forms/pin-code/pin-code-service/pin-code.service.mjs

@@ -0,0 +1,90 @@
+// @ts-strict-ignore
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class QdPinCodeService {
+    _values;
+    _currentIndex = 0;
+    _filledTill = -1;
+    _codeLength;
+    set currentIndex(index) {
+        this._currentIndex = index;
+    }
+    get currentIndex() {
+        return this._currentIndex;
+    }
+    set filledTill(index) {
+        this._filledTill = index;
+    }
+    get filledTill() {
+        return this._filledTill;
+    }
+    set codeLength(length) {
+        this._values = Array(length).fill('');
+        this._codeLength = length;
+    }
+    get codeLength() {
+        return this._codeLength;
+    }
+    get firstEmpty() {
+        if (this.lastIndex === this._filledTill) {
+            return -1;
+        }
+        return this._filledTill + 1;
+    }
+    get lastIndex() {
+        return this._codeLength - 1;
+    }
+    get allEmpty() {
+        return this._filledTill === -1;
+    }
+    get allFilled() {
+        return this.lastIndex === this._filledTill;
+    }
+    set values(values) {
+        this._values = values;
+    }
+    get values() {
+        return this._values;
+    }
+    get joinedValues() {
+        return this._values.join('').toUpperCase();
+    }
+    addValue(value) {
+        this._values[this._currentIndex] = value.toUpperCase();
+    }
+    addValues(values) {
+        const valuesList = values.toUpperCase().split('').slice(0, this._codeLength);
+        this._values = Array(this._codeLength).fill('');
+        this._values.splice(0, valuesList.length, ...valuesList);
+        this._currentIndex = valuesList.length < this._codeLength ? valuesList.length : valuesList.length - 1;
+        this._filledTill = valuesList.length - 1;
+    }
+    stepPrevious() {
+        if (this._currentIndex === 0 && this._filledTill === -1)
+            return;
+        if (this._currentIndex === 0) {
+            this.addValue('');
+            this._filledTill--;
+            return;
+        }
+        this.addValue('');
+        this._filledTill--;
+        this._currentIndex--;
+    }
+    stepNext() {
+        if (this._currentIndex + 1 === this._codeLength) {
+            return;
+        }
+        this._currentIndex++;
+    }
+    reset() {
+        this._currentIndex = 0;
+        this._filledTill = -1;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPinCodeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPinCodeService });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPinCodeService, decorators: [{
+            type: Injectable
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/forms/pin-code/pin-code.component.mjs

@@ -0,0 +1,454 @@
+// @ts-strict-ignore
+import { ChangeDetectorRef, Component, EventEmitter, Host, HostBinding, HostListener, Input, Optional, Output, QueryList, SkipSelf, ViewChildren } from '@angular/core';
+import { ControlContainer, NG_VALUE_ACCESSOR } from '@angular/forms';
+import { Subscription } from 'rxjs';
+import { getCodeHidden, getCodeLength, getDigitsOnly, getDisabled, getFocusOnInit, getHint, getHintAction, getLabel, getReadonly, getReadonlyAction, getViewonly, getViewonlyAction } from '../shared/helpers/forms.helpers';
+import { hasValidationKey } from '../shared/helpers/has-validators.helpers';
+import { QdFormsActionEmitterService } from '../shared/services/action-emitter.service';
+import { QdPinCodeService } from './pin-code-service/pin-code.service';
+import { QdEventBrokerService } from '../../core/services/event-broker.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./pin-code-service/pin-code.service";
+import * as i2 from "../shared/services/action-emitter.service";
+import * as i3 from "@angular/forms";
+import * as i4 from "../../core/services/event-broker.service";
+import * as i5 from "@angular/common";
+import * as i6 from "../shared/components/form-hint/form-hint.component";
+import * as i7 from "../shared/components/form-label/form-label.component";
+import * as i8 from "../shared/components/form-readonly/form-readonly.component";
+import * as i9 from "../shared/components/form-viewonly/form-viewonly.component";
+/**
+ * **QdPinCode** component provides a FormElement.
+ * The **QdPinCode** is a component that provides a form element for entering a PIN code.<br />
+ * It allows users to input a PIN code by typing individual digits or letters into separate input fields. It can be used with Quadrel Reactive Forms or with model binding.
+ *
+ * ####**Usage with Reactive Forms**
+ *
+ * ```ts
+ * form = new QdFormGroup({
+ *   pinCode: new QdFormControl()
+ * });
+ * ```
+ * ```html
+ * <form [formGroup]="form">
+ *   <qd-pin-code [formControlName]="pinCode" [config]="config"></qd-pin-code>
+ * </form>
+ * ```
+ *
+ * ####**Usage with Model Binding**
+ * ```ts
+ * value;
+ * ```
+ * ```html
+ * <qd-pin-code [(value)]="value" [config]="config"></qd-pin-code>
+ * ```
+ */
+export class QdPinCodeComponent {
+    pinCodeService;
+    changeDetectorRef;
+    actionEmitterService;
+    controlContainer;
+    eventBrokerService;
+    /**
+     * The form control name can be assigned here if you want to use Reactive Forms.
+     */
+    formControlName;
+    /**
+     * The current form item value, if you are working with Model Binding.
+     *
+     * @example
+     * <qd-pin-code [(value)]="value" [config]="config" (completed)="completed($event)"></qd-pin-code>
+     */
+    value;
+    /**
+     * The configuration for this form item
+     *
+     * @example
+     * {
+     *   label: { i18n: 'label' },
+     *   hint: { i18n: 'hint' },
+     *   codeLength: 6
+     * };
+     */
+    config;
+    /**
+     * A static test ID for integration tests can be set. <br />
+     * The value for the HTML attribute [data-test-id].
+     */
+    testId = 'pin-code';
+    /**
+     * Emits event when the input was successfully completed. Return value matches the current value.
+     */
+    completed = new EventEmitter();
+    /**
+     * Emits event when the value has changed. Return value matches the current value.
+     */
+    valueChange = new EventEmitter();
+    /**
+     * Emits event when the hint is clicked/tapped. `hintAction` must be set to `true` for this.
+     */
+    clickHint = new EventEmitter();
+    /**
+     * Emits event when the readonly value is clicked/tapped. `readonlyAction ` must be set to `true` for this.
+     */
+    clickReadonly = new EventEmitter();
+    /**
+     * Emits event when the viewonly value is clicked/tapped. `viewonlyAction ` must be set to `true` for this.
+     */
+    clickViewonly = new EventEmitter();
+    inputsList;
+    readonly;
+    readonlyAction;
+    viewonly;
+    viewonlyAction;
+    hintAction = false;
+    disabled;
+    get hasError() {
+        return this.control ? this.control.touched && this.control.invalid && this.blurCurrent : false;
+    }
+    onPaste($event) {
+        this.handlePaste($event);
+    }
+    label;
+    hint;
+    digitsOnly;
+    codeLength;
+    focusOnInit;
+    codeHidden;
+    iterable = Array;
+    blurCurrent;
+    control;
+    _actionEmitterServiceSubscription = new Subscription();
+    _inputs = [];
+    _subs = new Subscription();
+    _onChange = () => { };
+    _onTouch = () => { };
+    get errors() {
+        return this.control ? this.control.errors : [];
+    }
+    get required() {
+        if (!this.control)
+            return false;
+        return hasValidationKey(this.control, 'required');
+    }
+    constructor(pinCodeService, changeDetectorRef, actionEmitterService, controlContainer, eventBrokerService) {
+        this.pinCodeService = pinCodeService;
+        this.changeDetectorRef = changeDetectorRef;
+        this.actionEmitterService = actionEmitterService;
+        this.controlContainer = controlContainer;
+        this.eventBrokerService = eventBrokerService;
+    }
+    ngOnInit() {
+        this.updateConfiguration();
+        this.pinCodeService.codeLength = this.codeLength;
+        this.pinCodeService.values = (this.value ?? this.config?.value)?.split('') ?? [];
+        if (this.controlContainer) {
+            if (this.formControlName) {
+                this.control = this.controlContainer.control.get(this.formControlName);
+            }
+            else {
+                console.warn('QD-UI | QdPinCodeComponent - Missing FormControlName directive from host element of the component');
+            }
+        }
+        this._subs.add(this.actionEmitterService.hintEventEmitter$.subscribe(() => this.clickHint.emit()));
+        this._subs.add(this.actionEmitterService.readonlyEventEmitter$.subscribe(() => this.clickReadonly.emit()));
+        this._subs.add(this.actionEmitterService.viewonlyEventEmitter$.subscribe(() => this.clickViewonly.emit()));
+        this._subs.add(this.initOpModeSubscription());
+    }
+    ngAfterViewInit() {
+        this.getInputs();
+        this.fillInputs(this.pinCodeService.values);
+        this.focusFirstOnInit();
+    }
+    ngOnChanges(changes) {
+        if (changes['config']) {
+            this.updateConfiguration();
+            if (this.hasFocusOnInitChanged(changes['config']))
+                this.focusFirstOnInit();
+            if (this.hasCodeLengthChanged(changes['config'])) {
+                this.handleCodeLengthChange();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this._actionEmitterServiceSubscription?.unsubscribe();
+    }
+    registerOnChange(fn) {
+        this._onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this._onTouch = fn;
+    }
+    writeValue(values) {
+        if (!values)
+            return;
+        if (this.digitsOnly && !this.isInitialTextNumeric(values))
+            return;
+        if (!this.isNumericOrLatin(values))
+            return;
+        this.pinCodeService.addValues(values);
+    }
+    setDisabledState(disabled) {
+        this.disabled = disabled;
+    }
+    handleCLick($event) {
+        $event.preventDefault();
+        if (!this.pinCodeService.allFilled) {
+            this.focusFirstEmpty();
+            return;
+        }
+        this.focusFirstEmpty();
+    }
+    handleDelete($event) {
+        $event.preventDefault();
+        this._inputs[this.pinCodeService.currentIndex].value = '';
+        this.handlePrevious();
+        this._onChange(this.pinCodeService.joinedValues);
+        this._onTouch(this.pinCodeService.joinedValues);
+        this.valueChange.emit(this.pinCodeService.joinedValues);
+    }
+    handleInput($event) {
+        $event.preventDefault();
+        if (this.isEnter($event.key))
+            return;
+        const value = $event.key.toUpperCase();
+        if (this.digitsOnly && !this.isNumeric(value)) {
+            this.setErrorDigitsOnly();
+            return;
+        }
+        if (!this.isNumericOrLatin(value))
+            return;
+        this._inputs[this.pinCodeService.currentIndex].value = value;
+        this.pinCodeService.filledTill = this.pinCodeService.currentIndex;
+        this.pinCodeService.addValue(value);
+        this.handleNext();
+        this._onChange(this.pinCodeService.joinedValues);
+        this._onTouch(this.pinCodeService.joinedValues);
+        this.valueChange.emit(this.pinCodeService.joinedValues);
+    }
+    handleBlur(index) {
+        this.blurCurrent = false;
+        if (this.pinCodeService.currentIndex === index) {
+            this.blurCurrent = true;
+            this.checkError();
+        }
+    }
+    handleComplete() {
+        if (this.pinCodeService.allFilled) {
+            this.completed.emit(this.pinCodeService.joinedValues);
+            this.blurAll();
+            return;
+        }
+        this.triggerValidation();
+    }
+    updateConfiguration() {
+        this.label = getLabel(this.config);
+        this.hint = getHint(this.config);
+        this.readonly = getReadonly(this.config);
+        this.readonlyAction = getReadonlyAction(this.config);
+        this.viewonly = getViewonly(this.config);
+        this.viewonlyAction = getViewonlyAction(this.config);
+        this.disabled = getDisabled(this.config) || !!this.control?.disabled;
+        this.hintAction = getHintAction(this.config);
+        this.digitsOnly = getDigitsOnly(this.config);
+        this.codeLength = getCodeLength(this.config);
+        this.focusOnInit = getFocusOnInit(this.config);
+        this.codeHidden = getCodeHidden(this.config);
+    }
+    hasFocusOnInitChanged(config) {
+        return config.previousValue?.focusOnInit !== config.currentValue?.focusOnInit;
+    }
+    hasCodeLengthChanged(config) {
+        return config.previousValue?.codeLength !== config.currentValue?.codeLength;
+    }
+    handleCodeLengthChange() {
+        this.inputsList?.changes.subscribe(() => {
+            this.control?.markAsPristine();
+            this.emptyAll();
+            this.pinCodeService.reset();
+            this.controlContainer?.reset();
+            this.pinCodeService.codeLength = this.codeLength;
+            this.getInputs();
+            this.focusFirstOnInit();
+        });
+    }
+    getInputs() {
+        this._inputs = this.inputsList.map(input => input.nativeElement);
+    }
+    emptyAll() {
+        this._inputs.forEach(input => (input.value = ''));
+    }
+    focusFirst() {
+        this._inputs[0]?.focus();
+    }
+    focusCurrent() {
+        this._inputs[this.pinCodeService.currentIndex].focus();
+    }
+    focusFirstEmpty() {
+        if (this.pinCodeService.firstEmpty === -1)
+            return;
+        this._inputs[this.pinCodeService.firstEmpty]?.focus();
+        this.pinCodeService.currentIndex = this.pinCodeService.firstEmpty;
+    }
+    focusFirstOnInit() {
+        if (this.focusOnInit)
+            this.focusFirst();
+    }
+    blurAll() {
+        this._inputs.forEach(input => input.blur());
+    }
+    triggerValidation() {
+        this.blurAll();
+        this.focusCurrent();
+    }
+    checkError() {
+        this.control?.markAllAsTouched();
+    }
+    handlePaste($event) {
+        $event.preventDefault();
+        if (!this.matchPastedTextPattern($event)) {
+            this.setErrorDigitsOnly();
+            return;
+        }
+        this.emptyAll();
+        this.focusFirst();
+        this.handleInputsWhenPaste(this.getClipboardText($event).toUpperCase().split(''));
+        this.pinCodeService.addValues(this.getClipboardText($event));
+        this.focusFirstEmpty();
+        this.handleComplete();
+        this._onChange(this.pinCodeService.joinedValues);
+        this._onTouch(this.pinCodeService.joinedValues);
+        this.valueChange.emit(this.pinCodeService.joinedValues);
+    }
+    matchPastedTextPattern($event) {
+        return this.getClipboardText($event)
+            .split('')
+            .every(item => (this.digitsOnly && this.isNumeric(item)) || (!this.digitsOnly && this.isNumericOrLatin(item)));
+    }
+    isInitialTextNumeric(text) {
+        return text.split('').every(element => this.isNumeric(element));
+    }
+    getClipboardText($event) {
+        return $event.clipboardData.getData('text');
+    }
+    handleInputsWhenPaste(codeList) {
+        this.fillInputs(codeList);
+        this.pinCodeService.filledTill =
+            this._inputs.length < codeList.length ? this._inputs.length - 1 : codeList.length - 1;
+    }
+    fillInputs(codeList) {
+        this._inputs.forEach((input, i) => (input.value = codeList[i] || ''));
+    }
+    isNumeric(value) {
+        return !!value.match(/\d/giu);
+    }
+    isNumericOrLatin(value) {
+        return !!value.match(/[A-Z\d]/giu);
+    }
+    isEnter(key) {
+        return key === 'Enter';
+    }
+    handlePrevious() {
+        this.pinCodeService.stepPrevious();
+        this.focusCurrent();
+    }
+    handleNext() {
+        this.pinCodeService.stepNext();
+        this.focusCurrent();
+    }
+    setErrorDigitsOnly() {
+        // TODO: Use FormControl, when Angular Update is done!
+        this.control?.setErrors({ digitsOnly: 'i18n.qd.form.error.digitsOnly' });
+        if (this.control)
+            this.triggerValidation();
+    }
+    initOpModeSubscription() {
+        if (!this.eventBrokerService)
+            return;
+        return this.eventBrokerService.consume('operation_mode_changed').subscribe(topic => {
+            if (typeof this.config.viewonly === 'boolean')
+                return;
+            this.viewonly = getViewonly(this.config, topic.payload.isViewonly);
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPinCodeComponent, deps: [{ token: i1.QdPinCodeService }, { token: i0.ChangeDetectorRef }, { token: i2.QdFormsActionEmitterService }, { token: i3.ControlContainer, host: true, optional: true, skipSelf: true }, { token: i4.QdEventBrokerService, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.9", type: QdPinCodeComponent, selector: "qd-pin-code", inputs: { formControlName: "formControlName", value: "value", config: "config", testId: ["data-test-id", "testId"] }, outputs: { completed: "completed", valueChange: "valueChange", clickHint: "clickHint", clickReadonly: "clickReadonly", clickViewonly: "clickViewonly" }, host: { listeners: { "paste": "onPaste($event)" }, properties: { "class.qd-pin-code--readonly": "this.readonly", "class.qd-pin-code--viewonly": "this.viewonly", "class.qd-form-hint-action": "this.hintAction", "class.qd-pin-code--hint-action": "this.hintAction", "class.qd-form-disabled": "this.disabled", "class.qd-pin-code--disabled": "this.disabled", "class.qd-form-error": "this.hasError", "class.qd-pin-code--error": "this.hasError" }, classAttribute: "qd-pin-code" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: QdPinCodeComponent,
+                multi: true
+            },
+            QdPinCodeService,
+            QdFormsActionEmitterService
+        ], viewQueries: [{ propertyName: "inputsList", predicate: ["input"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "<qd-form-label\n  [label]=\"label\"\n  [readonly]=\"readonly\"\n  [viewonly]=\"viewonly\"\n  [control]=\"control\"\n  [tooltip]=\"config?.tooltip\"\n  [data-test-id]=\"testId\"\n></qd-form-label>\n\n<ng-container *ngFor=\"let i of iterable(codeLength); let index = index; let last = last\">\n  <input\n    #input\n    *ngIf=\"!readonly && !viewonly\"\n    [ngClass]=\"'qd-pin-code__input qd-pin-code--input-' + index + (last ? ' qd-pin-code__input--last' : '')\"\n    [attr.data-test-id]=\"testId + '-input-' + index\"\n    [type]=\"codeHidden ? 'password' : 'tel'\"\n    [tabindex]=\"pinCodeService.firstEmpty === index ? 0 : -1\"\n    (click)=\"handleCLick($event)\"\n    (keydown.backspace)=\"handleDelete($event)\"\n    (keydown.delete)=\"handleDelete($event)\"\n    (keydown.enter)=\"handleComplete()\"\n    (keypress)=\"handleInput($event)\"\n    (blur)=\"handleBlur(index)\"\n    [disabled]=\"disabled\"\n  />\n</ng-container>\n\n<ng-container *ngIf=\"!readonly && !viewonly\">\n  <qd-form-hint\n    [hint]=\"hint\"\n    [control]=\"control\"\n    [hasError]=\"hasError\"\n    [hintAction]=\"hintAction\"\n    [data-test-id]=\"testId\"\n  ></qd-form-hint>\n</ng-container>\n\n<qd-form-readonly\n  *ngIf=\"readonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [readonlyAction]=\"readonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-readonly>\n\n<qd-form-viewonly\n  *ngIf=\"viewonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [viewonlyAction]=\"viewonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-viewonly>\n", styles: [":host{display:block;height:4.5rem;margin-bottom:.75rem}:host .qd-pin-code__input{width:1.875rem;height:2.25rem;border:.0625rem solid rgb(180,180,180);margin-right:.75rem;margin-bottom:.375rem;caret-color:#fff0;cursor:default;font-size:1.5rem;font-weight:500;text-align:center}:host .qd-pin-code__input--last{margin-right:0}:host .qd-pin-code__input:focus{border-width:.125rem;border-color:#069}:host .qd-pin-code__input:active{border-width:.0625rem;border-color:#b4b4b4}:host .qd-pin-code__input:focus-visible{outline:none}:host.qd-pin-code--error .qd-pin-code__input{border-color:#c70023}:host.qd-pin-code--error .qd-pin-code__input:focus{border-width:.125rem}:host.qd-pin-code--error .qd-pin-code__input:active{border-width:.0625rem}\n"], dependencies: [{ kind: "directive", type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.QdFormHintComponent, selector: "qd-form-hint", inputs: ["hint", "control", "hasError", "hintAction", "data-test-id"] }, { kind: "component", type: i7.QdFormLabelComponent, selector: "qd-form-label", inputs: ["label", "isDisabled", "readonly", "viewonly", "control", "tooltip", "data-test-id"] }, { kind: "component", type: i8.QdFormReadonlyComponent, selector: "qd-form-readonly", inputs: ["values", "readonlyAction", "data-test-id"] }, { kind: "component", type: i9.QdFormViewonlyComponent, selector: "qd-form-viewonly", inputs: ["values", "viewonlyAction", "data-test-id"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.9", ngImport: i0, type: QdPinCodeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'qd-pin-code', providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: QdPinCodeComponent,
+                            multi: true
+                        },
+                        QdPinCodeService,
+                        QdFormsActionEmitterService
+                    ], host: { class: 'qd-pin-code' }, template: "<qd-form-label\n  [label]=\"label\"\n  [readonly]=\"readonly\"\n  [viewonly]=\"viewonly\"\n  [control]=\"control\"\n  [tooltip]=\"config?.tooltip\"\n  [data-test-id]=\"testId\"\n></qd-form-label>\n\n<ng-container *ngFor=\"let i of iterable(codeLength); let index = index; let last = last\">\n  <input\n    #input\n    *ngIf=\"!readonly && !viewonly\"\n    [ngClass]=\"'qd-pin-code__input qd-pin-code--input-' + index + (last ? ' qd-pin-code__input--last' : '')\"\n    [attr.data-test-id]=\"testId + '-input-' + index\"\n    [type]=\"codeHidden ? 'password' : 'tel'\"\n    [tabindex]=\"pinCodeService.firstEmpty === index ? 0 : -1\"\n    (click)=\"handleCLick($event)\"\n    (keydown.backspace)=\"handleDelete($event)\"\n    (keydown.delete)=\"handleDelete($event)\"\n    (keydown.enter)=\"handleComplete()\"\n    (keypress)=\"handleInput($event)\"\n    (blur)=\"handleBlur(index)\"\n    [disabled]=\"disabled\"\n  />\n</ng-container>\n\n<ng-container *ngIf=\"!readonly && !viewonly\">\n  <qd-form-hint\n    [hint]=\"hint\"\n    [control]=\"control\"\n    [hasError]=\"hasError\"\n    [hintAction]=\"hintAction\"\n    [data-test-id]=\"testId\"\n  ></qd-form-hint>\n</ng-container>\n\n<qd-form-readonly\n  *ngIf=\"readonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [readonlyAction]=\"readonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-readonly>\n\n<qd-form-viewonly\n  *ngIf=\"viewonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [viewonlyAction]=\"viewonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-viewonly>\n", styles: [":host{display:block;height:4.5rem;margin-bottom:.75rem}:host .qd-pin-code__input{width:1.875rem;height:2.25rem;border:.0625rem solid rgb(180,180,180);margin-right:.75rem;margin-bottom:.375rem;caret-color:#fff0;cursor:default;font-size:1.5rem;font-weight:500;text-align:center}:host .qd-pin-code__input--last{margin-right:0}:host .qd-pin-code__input:focus{border-width:.125rem;border-color:#069}:host .qd-pin-code__input:active{border-width:.0625rem;border-color:#b4b4b4}:host .qd-pin-code__input:focus-visible{outline:none}:host.qd-pin-code--error .qd-pin-code__input{border-color:#c70023}:host.qd-pin-code--error .qd-pin-code__input:focus{border-width:.125rem}:host.qd-pin-code--error .qd-pin-code__input:active{border-width:.0625rem}\n"] }]
+        }], ctorParameters: () => [{ type: i1.QdPinCodeService }, { type: i0.ChangeDetectorRef }, { type: i2.QdFormsActionEmitterService }, { type: i3.ControlContainer, decorators: [{
+                    type: Optional
+                }, {
+                    type: Host
+                }, {
+                    type: SkipSelf
+                }] }, { type: i4.QdEventBrokerService, decorators: [{
+                    type: Optional
+                }] }], propDecorators: { formControlName: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], testId: [{
+                type: Input,
+                args: ['data-test-id']
+            }], completed: [{
+                type: Output
+            }], valueChange: [{
+                type: Output
+            }], clickHint: [{
+                type: Output
+            }], clickReadonly: [{
+                type: Output
+            }], clickViewonly: [{
+                type: Output
+            }], inputsList: [{
+                type: ViewChildren,
+                args: ['input']
+            }], readonly: [{
+                type: HostBinding,
+                args: ['class.qd-pin-code--readonly']
+            }], viewonly: [{
+                type: HostBinding,
+                args: ['class.qd-pin-code--viewonly']
+            }], hintAction: [{
+                type: HostBinding,
+                args: ['class.qd-form-hint-action']
+            }, {
+                type: HostBinding,
+                args: ['class.qd-pin-code--hint-action']
+            }], disabled: [{
+                type: HostBinding,
+                args: ['class.qd-form-disabled']
+            }, {
+                type: HostBinding,
+                args: ['class.qd-pin-code--disabled']
+            }], hasError: [{
+                type: HostBinding,
+                args: ['class.qd-form-error']
+            }, {
+                type: HostBinding,
+                args: ['class.qd-pin-code--error']
+            }], onPaste: [{
+                type: HostListener,
+                args: ['paste', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pin-code.component.js","sourceRoot":"","sources":["../../../../../../libs/qd-ui/src/lib/forms/pin-code/pin-code.component.ts","../../../../../../libs/qd-ui/src/lib/forms/pin-code/pin-code.component.html"],"names":[],"mappings":"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","sourcesContent":["// @ts-strict-ignore\nimport {\n  AfterViewInit,\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Host,\n  HostBinding,\n  HostListener,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  QueryList,\n  SimpleChange,\n  SimpleChanges,\n  SkipSelf,\n  ViewChildren\n} from '@angular/core';\nimport {\n  AbstractControl,\n  ControlContainer,\n  ControlValueAccessor,\n  NG_VALUE_ACCESSOR,\n  ValidationErrors\n} from '@angular/forms';\nimport { Subscription } from 'rxjs';\n\nimport { QdFormPinCodeConfiguration } from '../model/forms.interface';\nimport {\n  getCodeHidden,\n  getCodeLength,\n  getDigitsOnly,\n  getDisabled,\n  getFocusOnInit,\n  getHint,\n  getHintAction,\n  getLabel,\n  getReadonly,\n  getReadonlyAction,\n  getViewonly,\n  getViewonlyAction\n} from '../shared/helpers/forms.helpers';\nimport { hasValidationKey } from '../shared/helpers/has-validators.helpers';\nimport { QdFormsActionEmitterService } from '../shared/services/action-emitter.service';\nimport { QdPinCodeService } from './pin-code-service/pin-code.service';\nimport { QdEventBrokerService } from '../../core/services/event-broker.service';\n\n/**\n * **QdPinCode** component provides a FormElement.\n * The **QdPinCode** is a component that provides a form element for entering a PIN code.<br />\n * It allows users to input a PIN code by typing individual digits or letters into separate input fields. It can be used with Quadrel Reactive Forms or with model binding.\n *\n * ####**Usage with Reactive Forms**\n *\n * ```ts\n * form = new QdFormGroup({\n *   pinCode: new QdFormControl()\n * });\n * ```\n * ```html\n * <form [formGroup]=\"form\">\n *   <qd-pin-code [formControlName]=\"pinCode\" [config]=\"config\"></qd-pin-code>\n * </form>\n * ```\n *\n * ####**Usage with Model Binding**\n * ```ts\n * value;\n * ```\n * ```html\n * <qd-pin-code [(value)]=\"value\" [config]=\"config\"></qd-pin-code>\n * ```\n */\n@Component({\n  selector: 'qd-pin-code',\n  templateUrl: './pin-code.component.html',\n  styleUrls: ['./pin-code.component.scss'],\n  providers: [\n    {\n      provide: NG_VALUE_ACCESSOR,\n      useExisting: QdPinCodeComponent,\n      multi: true\n    },\n    QdPinCodeService,\n    QdFormsActionEmitterService\n  ],\n  host: { class: 'qd-pin-code' }\n})\nexport class QdPinCodeComponent implements OnInit, OnChanges, AfterViewInit, OnDestroy, ControlValueAccessor {\n  /**\n   * The form control name can be assigned here if you want to use Reactive Forms.\n   */\n  @Input() formControlName: string;\n\n  /**\n   * The current form item value, if you are working with Model Binding.\n   *\n   * @example\n   * <qd-pin-code [(value)]=\"value\" [config]=\"config\" (completed)=\"completed($event)\"></qd-pin-code>\n   */\n  @Input() value;\n\n  /**\n   * The configuration for this form item\n   *\n   * @example\n   * {\n   *   label: { i18n: 'label' },\n   *   hint: { i18n: 'hint' },\n   *   codeLength: 6\n   * };\n   */\n  @Input() config: QdFormPinCodeConfiguration;\n\n  /**\n   * A static test ID for integration tests can be set. <br />\n   * The value for the HTML attribute [data-test-id].\n   */\n  @Input('data-test-id') testId = 'pin-code';\n\n  /**\n   * Emits event when the input was successfully completed. Return value matches the current value.\n   */\n  @Output() readonly completed = new EventEmitter<string>();\n\n  /**\n   * Emits event when the value has changed. Return value matches the current value.\n   */\n  @Output() readonly valueChange = new EventEmitter<string>();\n\n  /**\n   * Emits event when the hint is clicked/tapped. `hintAction` must be set to `true` for this.\n   */\n  @Output() readonly clickHint = new EventEmitter();\n\n  /**\n   * Emits event when the readonly value is clicked/tapped. `readonlyAction ` must be set to `true` for this.\n   */\n  @Output() readonly clickReadonly = new EventEmitter();\n\n  /**\n   * Emits event when the viewonly value is clicked/tapped. `viewonlyAction ` must be set to `true` for this.\n   */\n  @Output() readonly clickViewonly = new EventEmitter();\n\n  @ViewChildren('input') inputsList!: QueryList<ElementRef>;\n\n  @HostBinding('class.qd-pin-code--readonly')\n  readonly: boolean;\n  readonlyAction: boolean;\n\n  @HostBinding('class.qd-pin-code--viewonly')\n  viewonly: boolean;\n  viewonlyAction: boolean;\n\n  @HostBinding('class.qd-form-hint-action')\n  @HostBinding('class.qd-pin-code--hint-action')\n  hintAction = false;\n\n  @HostBinding('class.qd-form-disabled')\n  @HostBinding('class.qd-pin-code--disabled')\n  disabled: boolean;\n\n  @HostBinding('class.qd-form-error')\n  @HostBinding('class.qd-pin-code--error')\n  get hasError(): boolean {\n    return this.control ? this.control.touched && this.control.invalid && this.blurCurrent : false;\n  }\n\n  @HostListener('paste', ['$event']) onPaste($event): void {\n    this.handlePaste($event);\n  }\n\n  label: string;\n  hint: string;\n  digitsOnly: boolean;\n  codeLength: number;\n  focusOnInit: boolean;\n  codeHidden: boolean;\n  iterable: ArrayConstructor = Array;\n  blurCurrent: boolean;\n  control: AbstractControl;\n\n  private _actionEmitterServiceSubscription = new Subscription();\n  private _inputs: HTMLInputElement[] = [];\n  private _subs = new Subscription();\n\n  private _onChange: any = () => {};\n  private _onTouch: any = () => {};\n\n  get errors(): ValidationErrors {\n    return this.control ? this.control.errors : [];\n  }\n\n  get required(): boolean {\n    if (!this.control) return false;\n\n    return hasValidationKey(this.control, 'required');\n  }\n\n  constructor(\n    public readonly pinCodeService: QdPinCodeService,\n    private readonly changeDetectorRef: ChangeDetectorRef,\n    private readonly actionEmitterService: QdFormsActionEmitterService,\n    @Optional() @Host() @SkipSelf() private readonly controlContainer: ControlContainer,\n    @Optional() private readonly eventBrokerService: QdEventBrokerService\n  ) {}\n\n  ngOnInit(): void {\n    this.updateConfiguration();\n\n    this.pinCodeService.codeLength = this.codeLength;\n    this.pinCodeService.values = (this.value ?? this.config?.value)?.split('') ?? [];\n\n    if (this.controlContainer) {\n      if (this.formControlName) {\n        this.control = this.controlContainer.control.get(this.formControlName);\n      } else {\n        console.warn(\n          'QD-UI | QdPinCodeComponent - Missing FormControlName directive from host element of the component'\n        );\n      }\n    }\n\n    this._subs.add(this.actionEmitterService.hintEventEmitter$.subscribe(() => this.clickHint.emit()));\n    this._subs.add(this.actionEmitterService.readonlyEventEmitter$.subscribe(() => this.clickReadonly.emit()));\n    this._subs.add(this.actionEmitterService.viewonlyEventEmitter$.subscribe(() => this.clickViewonly.emit()));\n    this._subs.add(this.initOpModeSubscription());\n  }\n\n  ngAfterViewInit(): void {\n    this.getInputs();\n    this.fillInputs(this.pinCodeService.values);\n    this.focusFirstOnInit();\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['config']) {\n      this.updateConfiguration();\n\n      if (this.hasFocusOnInitChanged(changes['config'])) this.focusFirstOnInit();\n\n      if (this.hasCodeLengthChanged(changes['config'])) {\n        this.handleCodeLengthChange();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._actionEmitterServiceSubscription?.unsubscribe();\n  }\n\n  registerOnChange(fn: (_: string) => void): void {\n    this._onChange = fn;\n  }\n\n  registerOnTouched(fn: string): void {\n    this._onTouch = fn;\n  }\n\n  writeValue(values): void {\n    if (!values) return;\n\n    if (this.digitsOnly && !this.isInitialTextNumeric(values)) return;\n    if (!this.isNumericOrLatin(values)) return;\n\n    this.pinCodeService.addValues(values);\n  }\n\n  setDisabledState(disabled: boolean): void {\n    this.disabled = disabled;\n  }\n\n  handleCLick($event): void {\n    $event.preventDefault();\n\n    if (!this.pinCodeService.allFilled) {\n      this.focusFirstEmpty();\n\n      return;\n    }\n\n    this.focusFirstEmpty();\n  }\n\n  handleDelete($event): void {\n    $event.preventDefault();\n\n    this._inputs[this.pinCodeService.currentIndex].value = '';\n\n    this.handlePrevious();\n\n    this._onChange(this.pinCodeService.joinedValues);\n    this._onTouch(this.pinCodeService.joinedValues);\n    this.valueChange.emit(this.pinCodeService.joinedValues);\n  }\n\n  handleInput($event): void {\n    $event.preventDefault();\n\n    if (this.isEnter($event.key)) return;\n\n    const value = $event.key.toUpperCase();\n\n    if (this.digitsOnly && !this.isNumeric(value)) {\n      this.setErrorDigitsOnly();\n\n      return;\n    }\n\n    if (!this.isNumericOrLatin(value)) return;\n\n    this._inputs[this.pinCodeService.currentIndex].value = value;\n    this.pinCodeService.filledTill = this.pinCodeService.currentIndex;\n    this.pinCodeService.addValue(value);\n\n    this.handleNext();\n\n    this._onChange(this.pinCodeService.joinedValues);\n    this._onTouch(this.pinCodeService.joinedValues);\n    this.valueChange.emit(this.pinCodeService.joinedValues);\n  }\n\n  handleBlur(index): void {\n    this.blurCurrent = false;\n\n    if (this.pinCodeService.currentIndex === index) {\n      this.blurCurrent = true;\n      this.checkError();\n    }\n  }\n\n  handleComplete(): void {\n    if (this.pinCodeService.allFilled) {\n      this.completed.emit(this.pinCodeService.joinedValues);\n\n      this.blurAll();\n\n      return;\n    }\n\n    this.triggerValidation();\n  }\n\n  private updateConfiguration(): void {\n    this.label = getLabel(this.config);\n    this.hint = getHint(this.config);\n    this.readonly = getReadonly(this.config);\n    this.readonlyAction = getReadonlyAction(this.config);\n    this.viewonly = getViewonly(this.config);\n    this.viewonlyAction = getViewonlyAction(this.config);\n    this.disabled = getDisabled(this.config) || !!this.control?.disabled;\n    this.hintAction = getHintAction(this.config);\n    this.digitsOnly = getDigitsOnly(this.config);\n    this.codeLength = getCodeLength(this.config);\n    this.focusOnInit = getFocusOnInit(this.config);\n    this.codeHidden = getCodeHidden(this.config);\n  }\n\n  private hasFocusOnInitChanged(config: SimpleChange): boolean {\n    return config.previousValue?.focusOnInit !== config.currentValue?.focusOnInit;\n  }\n\n  private hasCodeLengthChanged(config: SimpleChange): boolean {\n    return config.previousValue?.codeLength !== config.currentValue?.codeLength;\n  }\n\n  private handleCodeLengthChange(): void {\n    this.inputsList?.changes.subscribe(() => {\n      this.control?.markAsPristine();\n      this.emptyAll();\n      this.pinCodeService.reset();\n      this.controlContainer?.reset();\n      this.pinCodeService.codeLength = this.codeLength;\n      this.getInputs();\n      this.focusFirstOnInit();\n    });\n  }\n\n  private getInputs(): void {\n    this._inputs = this.inputsList.map(input => input.nativeElement);\n  }\n\n  private emptyAll(): void {\n    this._inputs.forEach(input => (input.value = ''));\n  }\n\n  private focusFirst(): void {\n    this._inputs[0]?.focus();\n  }\n\n  private focusCurrent(): void {\n    this._inputs[this.pinCodeService.currentIndex].focus();\n  }\n\n  private focusFirstEmpty(): void {\n    if (this.pinCodeService.firstEmpty === -1) return;\n\n    this._inputs[this.pinCodeService.firstEmpty]?.focus();\n    this.pinCodeService.currentIndex = this.pinCodeService.firstEmpty;\n  }\n\n  private focusFirstOnInit(): void {\n    if (this.focusOnInit) this.focusFirst();\n  }\n\n  private blurAll(): void {\n    this._inputs.forEach(input => input.blur());\n  }\n\n  private triggerValidation(): void {\n    this.blurAll();\n    this.focusCurrent();\n  }\n\n  private checkError(): void {\n    this.control?.markAllAsTouched();\n  }\n\n  private handlePaste($event: ClipboardEvent): void {\n    $event.preventDefault();\n\n    if (!this.matchPastedTextPattern($event)) {\n      this.setErrorDigitsOnly();\n\n      return;\n    }\n\n    this.emptyAll();\n    this.focusFirst();\n\n    this.handleInputsWhenPaste(this.getClipboardText($event).toUpperCase().split(''));\n\n    this.pinCodeService.addValues(this.getClipboardText($event));\n    this.focusFirstEmpty();\n    this.handleComplete();\n\n    this._onChange(this.pinCodeService.joinedValues);\n    this._onTouch(this.pinCodeService.joinedValues);\n    this.valueChange.emit(this.pinCodeService.joinedValues);\n  }\n\n  private matchPastedTextPattern($event: ClipboardEvent): boolean {\n    return this.getClipboardText($event)\n      .split('')\n      .every(item => (this.digitsOnly && this.isNumeric(item)) || (!this.digitsOnly && this.isNumericOrLatin(item)));\n  }\n\n  private isInitialTextNumeric(text): boolean {\n    return text.split('').every(element => this.isNumeric(element));\n  }\n\n  private getClipboardText($event: ClipboardEvent): string {\n    return $event.clipboardData.getData('text');\n  }\n\n  private handleInputsWhenPaste(codeList: string[]): void {\n    this.fillInputs(codeList);\n    this.pinCodeService.filledTill =\n      this._inputs.length < codeList.length ? this._inputs.length - 1 : codeList.length - 1;\n  }\n\n  private fillInputs(codeList: string[]): void {\n    this._inputs.forEach((input, i) => (input.value = codeList[i] || ''));\n  }\n\n  private isNumeric(value: string): boolean {\n    return !!value.match(/\\d/giu);\n  }\n\n  private isNumericOrLatin(value: string): boolean {\n    return !!value.match(/[A-Z\\d]/giu);\n  }\n\n  private isEnter(key: KeyboardEvent['key']): boolean {\n    return key === 'Enter';\n  }\n\n  private handlePrevious(): void {\n    this.pinCodeService.stepPrevious();\n\n    this.focusCurrent();\n  }\n\n  private handleNext(): void {\n    this.pinCodeService.stepNext();\n\n    this.focusCurrent();\n  }\n\n  private setErrorDigitsOnly(): void {\n    // TODO: Use FormControl, when Angular Update is done!\n    this.control?.setErrors({ digitsOnly: 'i18n.qd.form.error.digitsOnly' });\n    if (this.control) this.triggerValidation();\n  }\n\n  private initOpModeSubscription(): Subscription | void {\n    if (!this.eventBrokerService) return;\n\n    return this.eventBrokerService.consume<{ isViewonly: boolean }>('operation_mode_changed').subscribe(topic => {\n      if (typeof this.config.viewonly === 'boolean') return;\n\n      this.viewonly = getViewonly(this.config, topic.payload.isViewonly);\n    });\n  }\n}\n","<qd-form-label\n  [label]=\"label\"\n  [readonly]=\"readonly\"\n  [viewonly]=\"viewonly\"\n  [control]=\"control\"\n  [tooltip]=\"config?.tooltip\"\n  [data-test-id]=\"testId\"\n></qd-form-label>\n\n<ng-container *ngFor=\"let i of iterable(codeLength); let index = index; let last = last\">\n  <input\n    #input\n    *ngIf=\"!readonly && !viewonly\"\n    [ngClass]=\"'qd-pin-code__input qd-pin-code--input-' + index + (last ? ' qd-pin-code__input--last' : '')\"\n    [attr.data-test-id]=\"testId + '-input-' + index\"\n    [type]=\"codeHidden ? 'password' : 'tel'\"\n    [tabindex]=\"pinCodeService.firstEmpty === index ? 0 : -1\"\n    (click)=\"handleCLick($event)\"\n    (keydown.backspace)=\"handleDelete($event)\"\n    (keydown.delete)=\"handleDelete($event)\"\n    (keydown.enter)=\"handleComplete()\"\n    (keypress)=\"handleInput($event)\"\n    (blur)=\"handleBlur(index)\"\n    [disabled]=\"disabled\"\n  />\n</ng-container>\n\n<ng-container *ngIf=\"!readonly && !viewonly\">\n  <qd-form-hint\n    [hint]=\"hint\"\n    [control]=\"control\"\n    [hasError]=\"hasError\"\n    [hintAction]=\"hintAction\"\n    [data-test-id]=\"testId\"\n  ></qd-form-hint>\n</ng-container>\n\n<qd-form-readonly\n  *ngIf=\"readonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [readonlyAction]=\"readonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-readonly>\n\n<qd-form-viewonly\n  *ngIf=\"viewonly\"\n  [values]=\"[pinCodeService.joinedValues]\"\n  [viewonlyAction]=\"viewonlyAction\"\n  [data-test-id]=\"testId\"\n></qd-form-viewonly>\n"]}