@ardium-ui/ui 1.0.0

package/esm2022/lib/inputs/color-input/color-input.module.mjs

@@ -0,0 +1,85 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ArdiumClickOutsideEventModule } from '@ardium-ui/devkit';
+import { ArdiumButtonModule } from '../../buttons/button/button.module';
+import { ArdiumCardModule } from '../../card/card.module';
+import { ArdiumColorDisplayModule } from '../../color/color-display/color-display.module';
+import { ArdiumColorPickerModule } from '../../color/color-picker/color-picker.module';
+import { ArdiumFormFieldFrameModule } from '../../form-field-frame/form-field-frame.module';
+import { _ClearButtonModule } from '../../_internal/clear-button/clear-button.module';
+import { ArdiumColorInputComponent } from './color-input.component';
+import { ArdColorInputActionButtonsTemplateDirective, ArdColorInputColorReferenceTemplateDirective, ArdColorInputHueIndicatorTemplateDirective, ArdColorInputOpacityIndicatorTemplateDirective, ArdColorInputPlaceholderTemplateDirective, ArdColorInputPrefixTemplateDirective, ArdColorInputShadeIndicatorTemplateDirective, ArdColorInputSuffixTemplateDirective, } from './color-input.directives';
+import * as i0 from "@angular/core";
+export class ArdiumColorInputModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumColorInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.7", ngImport: i0, type: ArdiumColorInputModule, declarations: [ArdiumColorInputComponent,
+            ArdColorInputPlaceholderTemplateDirective,
+            ArdColorInputPrefixTemplateDirective,
+            ArdColorInputSuffixTemplateDirective,
+            ArdColorInputShadeIndicatorTemplateDirective,
+            ArdColorInputHueIndicatorTemplateDirective,
+            ArdColorInputOpacityIndicatorTemplateDirective,
+            ArdColorInputColorReferenceTemplateDirective,
+            ArdColorInputActionButtonsTemplateDirective], imports: [CommonModule,
+            ArdiumFormFieldFrameModule,
+            _ClearButtonModule,
+            ArdiumColorPickerModule,
+            ArdiumColorDisplayModule,
+            ArdiumCardModule,
+            ArdiumClickOutsideEventModule,
+            ArdiumButtonModule], exports: [ArdiumColorInputComponent,
+            ArdColorInputPlaceholderTemplateDirective,
+            ArdColorInputPrefixTemplateDirective,
+            ArdColorInputSuffixTemplateDirective,
+            ArdColorInputShadeIndicatorTemplateDirective,
+            ArdColorInputHueIndicatorTemplateDirective,
+            ArdColorInputOpacityIndicatorTemplateDirective,
+            ArdColorInputColorReferenceTemplateDirective,
+            ArdColorInputActionButtonsTemplateDirective] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumColorInputModule, imports: [CommonModule,
+            ArdiumFormFieldFrameModule,
+            _ClearButtonModule,
+            ArdiumColorPickerModule,
+            ArdiumColorDisplayModule,
+            ArdiumCardModule,
+            ArdiumClickOutsideEventModule,
+            ArdiumButtonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumColorInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        ArdiumColorInputComponent,
+                        ArdColorInputPlaceholderTemplateDirective,
+                        ArdColorInputPrefixTemplateDirective,
+                        ArdColorInputSuffixTemplateDirective,
+                        ArdColorInputShadeIndicatorTemplateDirective,
+                        ArdColorInputHueIndicatorTemplateDirective,
+                        ArdColorInputOpacityIndicatorTemplateDirective,
+                        ArdColorInputColorReferenceTemplateDirective,
+                        ArdColorInputActionButtonsTemplateDirective,
+                    ],
+                    imports: [
+                        CommonModule,
+                        ArdiumFormFieldFrameModule,
+                        _ClearButtonModule,
+                        ArdiumColorPickerModule,
+                        ArdiumColorDisplayModule,
+                        ArdiumCardModule,
+                        ArdiumClickOutsideEventModule,
+                        ArdiumButtonModule,
+                    ],
+                    exports: [
+                        ArdiumColorInputComponent,
+                        ArdColorInputPlaceholderTemplateDirective,
+                        ArdColorInputPrefixTemplateDirective,
+                        ArdColorInputSuffixTemplateDirective,
+                        ArdColorInputShadeIndicatorTemplateDirective,
+                        ArdColorInputHueIndicatorTemplateDirective,
+                        ArdColorInputOpacityIndicatorTemplateDirective,
+                        ArdColorInputColorReferenceTemplateDirective,
+                        ArdColorInputActionButtonsTemplateDirective,
+                    ],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sb3ItaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9pbnB1dHMvY29sb3ItaW5wdXQvY29sb3ItaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxPQUFPLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ3pDLE9BQU8sRUFBRSw2QkFBNkIsRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3hFLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQzFELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQzFGLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBQ3ZGLE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLGdEQUFnRCxDQUFDO0FBQzVGLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtEQUFrRCxDQUFDO0FBQ3RGLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BFLE9BQU8sRUFDSCwyQ0FBMkMsRUFDM0MsNENBQTRDLEVBQzVDLDBDQUEwQyxFQUMxQyw4Q0FBOEMsRUFDOUMseUNBQXlDLEVBQ3pDLG9DQUFvQyxFQUNwQyw0Q0FBNEMsRUFDNUMsb0NBQW9DLEdBQ3ZDLE1BQU0sMEJBQTBCLENBQUM7O0FBb0NsQyxNQUFNLE9BQU8sc0JBQXNCOzhHQUF0QixzQkFBc0I7K0dBQXRCLHNCQUFzQixpQkFoQzNCLHlCQUF5QjtZQUN6Qix5Q0FBeUM7WUFDekMsb0NBQW9DO1lBQ3BDLG9DQUFvQztZQUNwQyw0Q0FBNEM7WUFDNUMsMENBQTBDO1lBQzFDLDhDQUE4QztZQUM5Qyw0Q0FBNEM7WUFDNUMsMkNBQTJDLGFBRzNDLFlBQVk7WUFDWiwwQkFBMEI7WUFDMUIsa0JBQWtCO1lBQ2xCLHVCQUF1QjtZQUN2Qix3QkFBd0I7WUFDeEIsZ0JBQWdCO1lBQ2hCLDZCQUE2QjtZQUM3QixrQkFBa0IsYUFHbEIseUJBQXlCO1lBQ3pCLHlDQUF5QztZQUN6QyxvQ0FBb0M7WUFDcEMsb0NBQW9DO1lBQ3BDLDRDQUE0QztZQUM1QywwQ0FBMEM7WUFDMUMsOENBQThDO1lBQzlDLDRDQUE0QztZQUM1QywyQ0FBMkM7K0dBR3RDLHNCQUFzQixZQXJCM0IsWUFBWTtZQUNaLDBCQUEwQjtZQUMxQixrQkFBa0I7WUFDbEIsdUJBQXVCO1lBQ3ZCLHdCQUF3QjtZQUN4QixnQkFBZ0I7WUFDaEIsNkJBQTZCO1lBQzdCLGtCQUFrQjs7MkZBY2Isc0JBQXNCO2tCQWxDbEMsUUFBUTttQkFBQztvQkFDTixZQUFZLEVBQUU7d0JBQ1YseUJBQXlCO3dCQUN6Qix5Q0FBeUM7d0JBQ3pDLG9DQUFvQzt3QkFDcEMsb0NBQW9DO3dCQUNwQyw0Q0FBNEM7d0JBQzVDLDBDQUEwQzt3QkFDMUMsOENBQThDO3dCQUM5Qyw0Q0FBNEM7d0JBQzVDLDJDQUEyQztxQkFDOUM7b0JBQ0QsT0FBTyxFQUFFO3dCQUNMLFlBQVk7d0JBQ1osMEJBQTBCO3dCQUMxQixrQkFBa0I7d0JBQ2xCLHVCQUF1Qjt3QkFDdkIsd0JBQXdCO3dCQUN4QixnQkFBZ0I7d0JBQ2hCLDZCQUE2Qjt3QkFDN0Isa0JBQWtCO3FCQUNyQjtvQkFDRCxPQUFPLEVBQUU7d0JBQ0wseUJBQXlCO3dCQUN6Qix5Q0FBeUM7d0JBQ3pDLG9DQUFvQzt3QkFDcEMsb0NBQW9DO3dCQUNwQyw0Q0FBNEM7d0JBQzVDLDBDQUEwQzt3QkFDMUMsOENBQThDO3dCQUM5Qyw0Q0FBNEM7d0JBQzVDLDJDQUEyQztxQkFDOUM7aUJBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBDb21tb25Nb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb21tb24nO1xuaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IEFyZGl1bUNsaWNrT3V0c2lkZUV2ZW50TW9kdWxlIH0gZnJvbSAnQGFyZGl1bS11aS9kZXZraXQnO1xuaW1wb3J0IHsgQXJkaXVtQnV0dG9uTW9kdWxlIH0gZnJvbSAnLi4vLi4vYnV0dG9ucy9idXR0b24vYnV0dG9uLm1vZHVsZSc7XG5pbXBvcnQgeyBBcmRpdW1DYXJkTW9kdWxlIH0gZnJvbSAnLi4vLi4vY2FyZC9jYXJkLm1vZHVsZSc7XG5pbXBvcnQgeyBBcmRpdW1Db2xvckRpc3BsYXlNb2R1bGUgfSBmcm9tICcuLi8uLi9jb2xvci9jb2xvci1kaXNwbGF5L2NvbG9yLWRpc3BsYXkubW9kdWxlJztcbmltcG9ydCB7IEFyZGl1bUNvbG9yUGlja2VyTW9kdWxlIH0gZnJvbSAnLi4vLi4vY29sb3IvY29sb3ItcGlja2VyL2NvbG9yLXBpY2tlci5tb2R1bGUnO1xuaW1wb3J0IHsgQXJkaXVtRm9ybUZpZWxkRnJhbWVNb2R1bGUgfSBmcm9tICcuLi8uLi9mb3JtLWZpZWxkLWZyYW1lL2Zvcm0tZmllbGQtZnJhbWUubW9kdWxlJztcbmltcG9ydCB7IF9DbGVhckJ1dHRvbk1vZHVsZSB9IGZyb20gJy4uLy4uL19pbnRlcm5hbC9jbGVhci1idXR0b24vY2xlYXItYnV0dG9uLm1vZHVsZSc7XG5pbXBvcnQgeyBBcmRpdW1Db2xvcklucHV0Q29tcG9uZW50IH0gZnJvbSAnLi9jb2xvci1pbnB1dC5jb21wb25lbnQnO1xuaW1wb3J0IHtcbiAgICBBcmRDb2xvcklucHV0QWN0aW9uQnV0dG9uc1RlbXBsYXRlRGlyZWN0aXZlLFxuICAgIEFyZENvbG9ySW5wdXRDb2xvclJlZmVyZW5jZVRlbXBsYXRlRGlyZWN0aXZlLFxuICAgIEFyZENvbG9ySW5wdXRIdWVJbmRpY2F0b3JUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICBBcmRDb2xvcklucHV0T3BhY2l0eUluZGljYXRvclRlbXBsYXRlRGlyZWN0aXZlLFxuICAgIEFyZENvbG9ySW5wdXRQbGFjZWhvbGRlclRlbXBsYXRlRGlyZWN0aXZlLFxuICAgIEFyZENvbG9ySW5wdXRQcmVmaXhUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICBBcmRDb2xvcklucHV0U2hhZGVJbmRpY2F0b3JUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICBBcmRDb2xvcklucHV0U3VmZml4VGVtcGxhdGVEaXJlY3RpdmUsXG59IGZyb20gJy4vY29sb3ItaW5wdXQuZGlyZWN0aXZlcyc7XG5cbkBOZ01vZHVsZSh7XG4gICAgZGVjbGFyYXRpb25zOiBbXG4gICAgICAgIEFyZGl1bUNvbG9ySW5wdXRDb21wb25lbnQsXG4gICAgICAgIEFyZENvbG9ySW5wdXRQbGFjZWhvbGRlclRlbXBsYXRlRGlyZWN0aXZlLFxuICAgICAgICBBcmRDb2xvcklucHV0UHJlZml4VGVtcGxhdGVEaXJlY3RpdmUsXG4gICAgICAgIEFyZENvbG9ySW5wdXRTdWZmaXhUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dFNoYWRlSW5kaWNhdG9yVGVtcGxhdGVEaXJlY3RpdmUsXG4gICAgICAgIEFyZENvbG9ySW5wdXRIdWVJbmRpY2F0b3JUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dE9wYWNpdHlJbmRpY2F0b3JUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dENvbG9yUmVmZXJlbmNlVGVtcGxhdGVEaXJlY3RpdmUsXG4gICAgICAgIEFyZENvbG9ySW5wdXRBY3Rpb25CdXR0b25zVGVtcGxhdGVEaXJlY3RpdmUsXG4gICAgXSxcbiAgICBpbXBvcnRzOiBbXG4gICAgICAgIENvbW1vbk1vZHVsZSxcbiAgICAgICAgQXJkaXVtRm9ybUZpZWxkRnJhbWVNb2R1bGUsXG4gICAgICAgIF9DbGVhckJ1dHRvbk1vZHVsZSxcbiAgICAgICAgQXJkaXVtQ29sb3JQaWNrZXJNb2R1bGUsXG4gICAgICAgIEFyZGl1bUNvbG9yRGlzcGxheU1vZHVsZSxcbiAgICAgICAgQXJkaXVtQ2FyZE1vZHVsZSxcbiAgICAgICAgQXJkaXVtQ2xpY2tPdXRzaWRlRXZlbnRNb2R1bGUsXG4gICAgICAgIEFyZGl1bUJ1dHRvbk1vZHVsZSxcbiAgICBdLFxuICAgIGV4cG9ydHM6IFtcbiAgICAgICAgQXJkaXVtQ29sb3JJbnB1dENvbXBvbmVudCxcbiAgICAgICAgQXJkQ29sb3JJbnB1dFBsYWNlaG9sZGVyVGVtcGxhdGVEaXJlY3RpdmUsXG4gICAgICAgIEFyZENvbG9ySW5wdXRQcmVmaXhUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dFN1ZmZpeFRlbXBsYXRlRGlyZWN0aXZlLFxuICAgICAgICBBcmRDb2xvcklucHV0U2hhZGVJbmRpY2F0b3JUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dEh1ZUluZGljYXRvclRlbXBsYXRlRGlyZWN0aXZlLFxuICAgICAgICBBcmRDb2xvcklucHV0T3BhY2l0eUluZGljYXRvclRlbXBsYXRlRGlyZWN0aXZlLFxuICAgICAgICBBcmRDb2xvcklucHV0Q29sb3JSZWZlcmVuY2VUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICAgICAgQXJkQ29sb3JJbnB1dEFjdGlvbkJ1dHRvbnNUZW1wbGF0ZURpcmVjdGl2ZSxcbiAgICBdLFxufSlcbmV4cG9ydCBjbGFzcyBBcmRpdW1Db2xvcklucHV0TW9kdWxlIHt9XG4iXX0=

package/esm2022/lib/inputs/color-input/color-input.types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sb3ItaW5wdXQudHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS9zcmMvbGliL2lucHV0cy9jb2xvci1pbnB1dC9jb2xvci1pbnB1dC50eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHR5cGUgQ29sb3JJbnB1dEFjdGlvbkJ1dHRvbnNDb250ZXh0ID0ge1xuICAgIGFwcGx5OiAoKSA9PiB2b2lkO1xuICAgIGNhbmNlbDogKCkgPT4gdm9pZDtcbiAgICByZXNldDogKCkgPT4gdm9pZDtcbn07XG4iXX0=

package/esm2022/lib/inputs/digit-input/digit-input.component.mjs

@@ -0,0 +1,218 @@
+import { ChangeDetectionStrategy, Component, ViewEncapsulation, forwardRef, Output, EventEmitter, Input, ViewChildren, } from '@angular/core';
+import { _NgModelComponentBase } from '../../_internal/ngmodel-component';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { coerceBooleanProperty } from '@ardium-ui/devkit';
+import { FormElementAppearance, FormElementVariant } from '../../types/theming.types';
+import { DigitInputModel } from './digit-input.model';
+import { DigitInputShape } from './digit-input.types';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+export class ArdiumDigitInputComponent extends _NgModelComponentBase {
+    constructor() {
+        super(...arguments);
+        this.model = new DigitInputModel(this);
+        //! appearance
+        this.appearance = FormElementAppearance.Outlined;
+        this.variant = FormElementVariant.Rounded;
+        this.shape = DigitInputShape.Square;
+        this._compact = false;
+        this.configArrayData = [];
+        //! value two-way binding
+        this._outputAsString = false;
+        this.valueChange = new EventEmitter();
+        //! event emitters
+        this.inputEvent = new EventEmitter();
+        this.changeEvent = new EventEmitter();
+        this.finishedValue = new EventEmitter();
+        this.focusIndexEvent = new EventEmitter();
+        this.blurIndexEvent = new EventEmitter();
+    }
+    get compact() {
+        return this._compact;
+    }
+    set compact(v) {
+        this._compact = coerceBooleanProperty(v);
+    }
+    get ngClasses() {
+        return [`ard-appearance-${this.appearance}`, `ard-variant-${this.variant}`, `ard-shape-${this.shape}`, this.compact ? 'ard-compact' : ''].join(' ');
+    }
+    //! model access points
+    set config(v) {
+        this.model.setConfig(v);
+    }
+    get isConfigDefined() {
+        return this.model.isConfigDefined;
+    }
+    isInputEmpty(index) {
+        return !this.model.isDefinedAtIndex(index);
+    }
+    //! control value accessor's write value implementation
+    writeValue(v) {
+        this._writeValue(v);
+    }
+    _writeValue(v) {
+        return this.model.writeValue(v);
+    }
+    get outputAsString() {
+        return this._outputAsString;
+    }
+    set outputAsString(v) {
+        this._outputAsString = coerceBooleanProperty(v);
+    }
+    set value(v) {
+        this.writeValue(v);
+    }
+    get value() {
+        return this.model.value;
+    }
+    get stringValue() {
+        return this.model.stringValue;
+    }
+    get emittableValue() {
+        if (this.outputAsString)
+            return this.model.stringValue;
+        return this.value;
+    }
+    //! event handlers
+    onPaste(event, index) {
+        const value = event.clipboardData?.getData('text');
+        event.stopPropagation();
+        event.preventDefault();
+        if (!value)
+            return;
+        const maxLength = this.inputs.length - index;
+        value
+            .slice(0, maxLength)
+            .split('')
+            .forEach((char, i) => {
+            this.model.validateInputAndSetValue(char, index + i);
+        });
+        this.focusByIndex(index - 1 + Math.min(value.length, maxLength));
+    }
+    onInput(event, index) {
+        this._updateSingleInputValue(event.target.value, index);
+    }
+    _updateSingleInputValue(value, index) {
+        const valueChanged = this.model.validateInputAndSetValue(value, index);
+        if (!valueChanged || !valueChanged[0])
+            return;
+        if (valueChanged[1]) {
+            this.focusByIndex(index + 1);
+        }
+        this._emitInput();
+    }
+    focusByIndex(index, tryFocusingNext, direction) {
+        if (index < 0 || index >= this.inputs.length)
+            return false;
+        const nextEl = this.inputs.get(index)?.nativeElement;
+        if (!nextEl)
+            return false;
+        nextEl.focus();
+        if (tryFocusingNext && direction && document.activeElement != nextEl) {
+            return this.focusByIndex(index + direction);
+        }
+        return document.activeElement == nextEl;
+    }
+    _emitInput() {
+        this._onChangeRegistered?.(this.value);
+        this.inputEvent.emit(this.emittableValue);
+        this.valueChange.emit(this.emittableValue);
+        if (this.model.isValueFull) {
+            this.finishedValue.emit(this.emittableValue);
+        }
+    }
+    //focus, blur, change
+    onFocusMaster(event, index) {
+        this.focusIndexEvent.emit(index);
+        this.onFocus(event);
+    }
+    onBlurMaster(event, index) {
+        this._emitChange();
+        this.blurIndexEvent.emit(index);
+        this.onBlur(event);
+    }
+    _emitChange() {
+        this.changeEvent.emit(this.emittableValue);
+    }
+    onKeydown(event, index) {
+        switch (event.key) {
+            case 'ArrowLeft':
+                this.focusByIndex(index - 1, true, -1);
+                break;
+            case 'ArrowRight':
+                this.focusByIndex(index + 1, true, +1);
+                break;
+            case 'Home':
+                this.focusByIndex(0, true, 1);
+                break;
+            case 'End':
+                this.focusByIndex(this.inputs.length - 1, true, -1);
+                break;
+            case 'Backspace':
+            case 'Delete':
+                this._updateSingleInputValue('', index);
+                this.focusByIndex(index - 1, true, -1);
+                event.preventDefault();
+                break;
+            default:
+                break;
+        }
+    }
+    ngAfterContentInit() {
+        if (!this.isConfigDefined) {
+            throw new Error(`ARD-FT040: <ard-digit-input>'s [config] field has to be defined.`);
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputComponent, deps: null, target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.0.7", type: ArdiumDigitInputComponent, selector: "ard-digit-input", inputs: { appearance: "appearance", variant: "variant", shape: "shape", compact: "compact", config: "config", outputAsString: "outputAsString", value: "value" }, outputs: { valueChange: "valueChange", inputEvent: "input", changeEvent: "change", finishedValue: "finishedValue", focusIndexEvent: "focusIndex", blurIndexEvent: "blurIndex" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => ArdiumDigitInputComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "inputs", predicate: ["input"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"ard-digit-input\" [ngClass]=\"ngClasses\">\r\n    <div class=\"ard-digit-input__item\" *ngFor=\"let data of configArrayData\">\r\n        <input\r\n            #input\r\n            #focusableElement\r\n            *ngIf=\"data.type == 'input'\"\r\n            class=\"ard-digit-input__input\"\r\n            type=\"text\"\r\n            autocomplete=\"off\"\r\n            [readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-empty]=\"isInputEmpty(data.index!)\"\r\n            (paste)=\"onPaste($event, data.index!)\"\r\n            (input)=\"onInput($event, data.index!)\"\r\n            (focus)=\"onFocusMaster($event, data.index!)\"\r\n            (blur)=\"onBlurMaster($event, data.index!)\"\r\n            (keydown)=\"onKeydown($event, data.index!)\"\r\n        />\r\n        <div\r\n            *ngIf=\"data.type == 'static'\"\r\n            class=\"ard-digit-input__static\"\r\n        >\r\n            {{ data.char }}\r\n        </div>\r\n    </div>\r\n</div>", styles: [""], dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'ard-digit-input', encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => ArdiumDigitInputComponent),
+                            multi: true,
+                        },
+                    ], template: "<div class=\"ard-digit-input\" [ngClass]=\"ngClasses\">\r\n    <div class=\"ard-digit-input__item\" *ngFor=\"let data of configArrayData\">\r\n        <input\r\n            #input\r\n            #focusableElement\r\n            *ngIf=\"data.type == 'input'\"\r\n            class=\"ard-digit-input__input\"\r\n            type=\"text\"\r\n            autocomplete=\"off\"\r\n            [readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-empty]=\"isInputEmpty(data.index!)\"\r\n            (paste)=\"onPaste($event, data.index!)\"\r\n            (input)=\"onInput($event, data.index!)\"\r\n            (focus)=\"onFocusMaster($event, data.index!)\"\r\n            (blur)=\"onBlurMaster($event, data.index!)\"\r\n            (keydown)=\"onKeydown($event, data.index!)\"\r\n        />\r\n        <div\r\n            *ngIf=\"data.type == 'static'\"\r\n            class=\"ard-digit-input__static\"\r\n        >\r\n            {{ data.char }}\r\n        </div>\r\n    </div>\r\n</div>" }]
+        }], propDecorators: { appearance: [{
+                type: Input
+            }], variant: [{
+                type: Input
+            }], shape: [{
+                type: Input
+            }], compact: [{
+                type: Input
+            }], config: [{
+                type: Input
+            }], outputAsString: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], inputEvent: [{
+                type: Output,
+                args: ['input']
+            }], changeEvent: [{
+                type: Output,
+                args: ['change']
+            }], finishedValue: [{
+                type: Output
+            }], focusIndexEvent: [{
+                type: Output,
+                args: ['focusIndex']
+            }], blurIndexEvent: [{
+                type: Output,
+                args: ['blurIndex']
+            }], inputs: [{
+                type: ViewChildren,
+                args: ['input']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"digit-input.component.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/inputs/digit-input/digit-input.component.ts","../../../../../../projects/ui/src/lib/inputs/digit-input/digit-input.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    Component,\n    ViewEncapsulation,\n    forwardRef,\n    Output,\n    EventEmitter,\n    Input,\n    ViewChildren,\n    QueryList,\n    AfterViewInit,\n    AfterContentInit,\n    ElementRef,\n} from '@angular/core';\nimport { _NgModelComponentBase } from '../../_internal/ngmodel-component';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\nimport { coerceBooleanProperty } from '@ardium-ui/devkit';\nimport { FormElementAppearance, FormElementVariant } from '../../types/theming.types';\nimport { DigitInputModel } from './digit-input.model';\nimport { DigitInputConfigData, DigitInputModelHost } from './digit-input.utils';\nimport { DigitInputConfig, DigitInputShape } from './digit-input.types';\n\n@Component({\n    selector: 'ard-digit-input',\n    templateUrl: './digit-input.component.html',\n    styleUrls: ['./digit-input.component.scss'],\n    encapsulation: ViewEncapsulation.None,\n    changeDetection: ChangeDetectionStrategy.OnPush,\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => ArdiumDigitInputComponent),\n            multi: true,\n        },\n    ],\n})\nexport class ArdiumDigitInputComponent extends _NgModelComponentBase implements ControlValueAccessor, DigitInputModelHost, AfterContentInit {\n    private readonly model = new DigitInputModel(this);\n\n    //! appearance\n    @Input() appearance: FormElementAppearance = FormElementAppearance.Outlined;\n    @Input() variant: FormElementVariant = FormElementVariant.Rounded;\n    @Input() shape: DigitInputShape = DigitInputShape.Square;\n\n    private _compact: boolean = false;\n    @Input()\n    get compact(): boolean {\n        return this._compact;\n    }\n    set compact(v: any) {\n        this._compact = coerceBooleanProperty(v);\n    }\n\n    get ngClasses(): string {\n        return [`ard-appearance-${this.appearance}`, `ard-variant-${this.variant}`, `ard-shape-${this.shape}`, this.compact ? 'ard-compact' : ''].join(' ');\n    }\n\n    //! model access points\n    @Input()\n    set config(v: DigitInputConfig) {\n        this.model.setConfig(v);\n    }\n    configArrayData: DigitInputConfigData[] = [];\n\n    get isConfigDefined(): boolean {\n        return this.model.isConfigDefined;\n    }\n\n    isInputEmpty(index: number): boolean {\n        return !this.model.isDefinedAtIndex(index);\n    }\n\n    //! control value accessor's write value implementation\n    writeValue(v: any): void {\n        this._writeValue(v);\n    }\n    private _writeValue(v: any): boolean {\n        return this.model.writeValue(v);\n    }\n\n    //! value two-way binding\n    private _outputAsString: boolean = false;\n    @Input()\n    get outputAsString(): boolean {\n        return this._outputAsString;\n    }\n    set outputAsString(v: any) {\n        this._outputAsString = coerceBooleanProperty(v);\n    }\n\n    @Input()\n    set value(v: string | (string | null)[] | null) {\n        this.writeValue(v);\n    }\n    get value(): (string | null)[] | null {\n        return this.model.value;\n    }\n    @Output() valueChange = new EventEmitter<string | (string | null)[] | null>();\n\n    get stringValue(): string {\n        return this.model.stringValue;\n    }\n\n    get emittableValue(): string | (string | null)[] | null {\n        if (this.outputAsString) return this.model.stringValue;\n        return this.value;\n    }\n\n    //! event emitters\n    @Output('input') inputEvent = new EventEmitter<string | (string | null)[] | null>();\n    @Output('change') changeEvent = new EventEmitter<string | (string | null)[] | null>();\n    @Output() finishedValue = new EventEmitter<string | (string | null)[] | null>();\n\n    @Output('focusIndex') focusIndexEvent = new EventEmitter<number>();\n    @Output('blurIndex') blurIndexEvent = new EventEmitter<number>();\n\n    //! event handlers\n    onPaste(event: ClipboardEvent, index: number): void {\n        const value = event.clipboardData?.getData('text');\n        event.stopPropagation();\n        event.preventDefault();\n        if (!value) return;\n\n        const maxLength = this.inputs.length - index;\n        value\n            .slice(0, maxLength)\n            .split('')\n            .forEach((char, i) => {\n                this.model.validateInputAndSetValue(char, index + i);\n            });\n        this.focusByIndex(index - 1 + Math.min(value.length, maxLength));\n    }\n    onInput(event: Event, index: number): void {\n        this._updateSingleInputValue((event.target as HTMLInputElement).value, index);\n    }\n    private _updateSingleInputValue(value: string, index: number): void {\n        const valueChanged = this.model.validateInputAndSetValue(value, index);\n        if (!valueChanged || !valueChanged[0]) return;\n\n        if (valueChanged[1]) {\n            this.focusByIndex(index + 1);\n        }\n        this._emitInput();\n    }\n    focusByIndex(index: number): boolean;\n    focusByIndex(index: number, tryFocusingNext: boolean, direction: 1 | -1): boolean;\n    focusByIndex(index: number, tryFocusingNext?: boolean, direction?: 1 | -1): boolean {\n        if (index < 0 || index >= this.inputs.length) return false;\n        const nextEl = this.inputs.get(index)?.nativeElement;\n        if (!nextEl) return false;\n\n        nextEl.focus();\n        if (tryFocusingNext && direction && document.activeElement != nextEl) {\n            return this.focusByIndex(index + direction);\n        }\n        return document.activeElement == nextEl;\n    }\n    private _emitInput(): void {\n        this._onChangeRegistered?.(this.value);\n        this.inputEvent.emit(this.emittableValue);\n        this.valueChange.emit(this.emittableValue);\n        if (this.model.isValueFull) {\n            this.finishedValue.emit(this.emittableValue);\n        }\n    }\n    //focus, blur, change\n    onFocusMaster(event: FocusEvent, index: number): void {\n        this.focusIndexEvent.emit(index);\n        this.onFocus(event);\n    }\n    onBlurMaster(event: FocusEvent, index: number): void {\n        this._emitChange();\n        this.blurIndexEvent.emit(index);\n        this.onBlur(event);\n    }\n    protected _emitChange(): void {\n        this.changeEvent.emit(this.emittableValue);\n    }\n    onKeydown(event: KeyboardEvent, index: number): void {\n        switch (event.key) {\n            case 'ArrowLeft':\n                this.focusByIndex(index - 1, true, -1);\n                break;\n            case 'ArrowRight':\n                this.focusByIndex(index + 1, true, +1);\n                break;\n            case 'Home':\n                this.focusByIndex(0, true, 1);\n                break;\n            case 'End':\n                this.focusByIndex(this.inputs.length - 1, true, -1);\n                break;\n            case 'Backspace':\n            case 'Delete':\n                this._updateSingleInputValue('', index);\n                this.focusByIndex(index - 1, true, -1);\n                event.preventDefault();\n                break;\n\n            default:\n                break;\n        }\n    }\n\n    //! inputs ref\n    @ViewChildren('input') inputs!: QueryList<ElementRef<HTMLInputElement>>;\n\n    ngAfterContentInit(): void {\n        if (!this.isConfigDefined) {\n            throw new Error(`ARD-FT040: <ard-digit-input>'s [config] field has to be defined.`);\n        }\n    }\n}\n","<div class=\"ard-digit-input\" [ngClass]=\"ngClasses\">\r\n    <div class=\"ard-digit-input__item\" *ngFor=\"let data of configArrayData\">\r\n        <input\r\n            #input\r\n            #focusableElement\r\n            *ngIf=\"data.type == 'input'\"\r\n            class=\"ard-digit-input__input\"\r\n            type=\"text\"\r\n            autocomplete=\"off\"\r\n            [readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-readonly]=\"data.readonly\"\r\n            [class.ard-digit-input__input-empty]=\"isInputEmpty(data.index!)\"\r\n            (paste)=\"onPaste($event, data.index!)\"\r\n            (input)=\"onInput($event, data.index!)\"\r\n            (focus)=\"onFocusMaster($event, data.index!)\"\r\n            (blur)=\"onBlurMaster($event, data.index!)\"\r\n            (keydown)=\"onKeydown($event, data.index!)\"\r\n        />\r\n        <div\r\n            *ngIf=\"data.type == 'static'\"\r\n            class=\"ard-digit-input__static\"\r\n        >\r\n            {{ data.char }}\r\n        </div>\r\n    </div>\r\n</div>"]}

package/esm2022/lib/inputs/digit-input/digit-input.model.mjs

@@ -0,0 +1,217 @@
+import { coerceArrayProperty } from '@ardium-ui/devkit';
+import { isAnyString, isArray, isDefined, isFunction, isNull, isNumber, isRegExp } from 'simple-bool';
+import { DigitInputConfigDataType, _sanitizeRegExpString } from './digit-input.utils';
+import { DigitInputPrimitiveOption, TransformType } from './digit-input.types';
+export class DigitInputModel {
+    constructor(_ardHost) {
+        this._ardHost = _ardHost;
+        this._configArray = [];
+        this._configArrayNoStatics = [];
+        this._value = null;
+        this._stringValueMemo = null;
+    }
+    set configArray(arr) {
+        this._configArray = arr;
+        this._configArrayNoStatics = arr.filter(v => !('static' in v));
+        this.setConfigArrayData();
+    }
+    setConfigArrayData() {
+        let inputIndex = 0;
+        this._ardHost.configArrayData = this._configArray.map(v => {
+            if ('static' in v) {
+                return {
+                    type: DigitInputConfigDataType.Static,
+                    char: v.static,
+                };
+            }
+            return {
+                type: DigitInputConfigDataType.Input,
+                index: inputIndex++,
+            };
+        });
+    }
+    get isConfigDefined() {
+        return this._configArray.length > 0;
+    }
+    set value(v) {
+        this._value = v;
+        this._stringValueMemo = null;
+    }
+    get value() {
+        return this._value;
+    }
+    get stringValue() {
+        if (isNull(this._stringValueMemo)) {
+            const v = this.value
+                ?.map(v => v ?? ' ')
+                .join('')
+                .trimEnd() ?? '';
+            this._stringValueMemo = v;
+        }
+        return this._stringValueMemo;
+    }
+    get isValueFull() {
+        return isDefined(this.value) && this.value.length === this._configArrayNoStatics.length;
+    }
+    isDefinedAtIndex(index) {
+        return Boolean(this.value?.[index]);
+    }
+    writeValue(v) {
+        if (!isArray(v) && !isAnyString(v) && !isNull(v)) {
+            //warn when using non-string/non-null value
+            console.warn(new Error(`ARD-WA041: Trying to set <ard-digit-input>'s value to ${typeof v}, expected string or array strings.`));
+            //normalize the value
+            v = v?.toString?.() ?? String(v);
+        }
+        const vArray = coerceArrayProperty(v);
+        const problemIndex = vArray.findIndex(el => !isAnyString(el) || el.length > 1);
+        if (problemIndex != -1) {
+            throw new Error(`ARD-FT042: Array passed to <ard-digit-input>'s value must only contain strings of length 1 or 0. Element at index ${problemIndex} does not match those requirements.`);
+        }
+        return this._writeValue(vArray);
+    }
+    _writeValue(v) {
+        let oldVal = this.value;
+        this.value = v && v.map(el => el || null);
+        this.validateValueAndUpdate();
+        this._updateInputElements();
+        return oldVal !== v;
+    }
+    _updateInputElements() {
+        const value = this.value ?? [];
+        let i = 0;
+        for (const inputEl of this._ardHost.inputs) {
+            inputEl.nativeElement.value = value[i] ?? '';
+            i++;
+        }
+    }
+    //! setting config
+    setConfig(config) {
+        this._setConfig(config);
+        this.validateValueAndUpdate();
+    }
+    _setConfig(config) {
+        //map a number to ready objects
+        let configAsNumber = isAnyString(config) ? Number(config) : null;
+        if (isNumber(config) || isNumber(configAsNumber)) {
+            configAsNumber = isNumber(config) ? config : configAsNumber;
+            this.configArray = 'a'
+                .repeat(configAsNumber)
+                .split('')
+                .map(() => ({ accept: str => /[0-9]/.test(str) }));
+            return;
+        }
+        //map a string to an array
+        let configArr;
+        if (isAnyString(config)) {
+            configArr = coerceArrayProperty(config);
+        }
+        else {
+            configArr = config;
+        }
+        //map array to ready objects
+        this.configArray = configArr.map((v, i) => {
+            if (!isAnyString(v)) {
+                if ('accept' in v && !isFunction(v.accept)) {
+                    const regExp = isRegExp(v.accept) ? v.accept : new RegExp(`[${_sanitizeRegExpString(v.accept)}]`);
+                    v.accept = str => regExp.test(str);
+                }
+                return v;
+            }
+            switch (v) {
+                case DigitInputPrimitiveOption.Number:
+                    return { accept: str => /[0-9]/.test(str) };
+                case DigitInputPrimitiveOption.Letter:
+                    return { accept: str => /[a-zA-Z]/.test(str) };
+                case DigitInputPrimitiveOption.Alphanumeric:
+                    return { accept: str => /[0-9a-zA-Z]/.test(str) };
+                case DigitInputPrimitiveOption.Special:
+                    return { accept: str => /[!@#$%^&*-_=+/\\.,]/.test(str) };
+                default:
+                    if (configArr.length == 1) {
+                        throw new Error(`ARD-NF043S: <ard-digit-input>'s config is invalid. Expected number or array, got "${v}"`);
+                    }
+                    throw new Error(`ARD-NF043B: Found invalid string in <ard-digit-input>'s config: "${v}" at index ${i}`);
+            }
+        });
+    }
+    //! validate against the config
+    validateInputAndSetValue(input, index) {
+        if (index < 0 || index > this._configArrayNoStatics.length)
+            return false;
+        //prepare the value array if does not exist
+        if (!this.value) {
+            this.value = [];
+        }
+        //prepare the characters before the current one (to be used in validation)
+        const before = this.value
+            .slice(0, index)
+            .map(v => v ?? ' ')
+            .join('');
+        //remove the old character from the input element
+        const oldVal = this.value[index];
+        if (oldVal && input.length > 1 && input.match(oldVal)) {
+            input = input.replace(oldVal, '');
+        }
+        //use only the first character (error safety)
+        input = input.charAt(0);
+        //validate and transform, if necessary
+        const inputChar = this._validateSingleChar(input, before, this._configArrayNoStatics[index]);
+        //get the corresponding HTML input element
+        const inputEl = this._ardHost.inputs.get(index);
+        if (!inputEl) {
+            throw new Error("ARD-IS048: <ard-digit-input>'s value changed, but its corresponding input element could not be found. This is error is fatal to the functioning of Ardium UI. Please report this issue to the creators.");
+        }
+        //update the input element and value array
+        const newVal = inputChar ?? oldVal;
+        inputEl.nativeElement.value = newVal ?? '';
+        this.value[index] = newVal;
+        //return changes marker and validated value
+        return [newVal !== oldVal, inputChar];
+    }
+    validateValueAndUpdate() {
+        const v = this.value;
+        if (!v)
+            return;
+        let before = '';
+        const newValue = [];
+        for (let i = 0; i < Math.min(this._configArrayNoStatics.length, v.length); i++) {
+            const char = v[i];
+            before += char ?? ' ';
+            if (!char) {
+                newValue.push(char);
+                continue;
+            }
+            const config = this._configArrayNoStatics[i];
+            const newChar = this._validateSingleChar(char, before, config);
+            newValue.push(newChar);
+        }
+        this.value = newValue;
+    }
+    _validateSingleChar(char, before, config) {
+        if (config.readonly) {
+            throw new Error(`ARD-IS049R: trying to set value of a digit-input's readonly field. This is error is fatal to the functioning of Ardium UI. Please report this issue to the creators.`);
+        }
+        if (!isFunction(config.accept)) {
+            const regExp = isRegExp(config.accept) ? config.accept : new RegExp(`[${_sanitizeRegExpString(config.accept)}]`);
+            config.accept = str => regExp.test(str);
+            console.warn(`ARD-IS049A: digit-input's value validator encountered an unexpected value of the config's "accept" property. Ardium UI was able to handle this issue, but please report it to the creators.`);
+        }
+        if (!char)
+            return char;
+        const canAccept = config.accept(char, before);
+        if (!canAccept)
+            return null;
+        if (config.transform) {
+            if (config.transform == TransformType.Lowercase) {
+                return char.toLowerCase();
+            }
+            if (config.transform == TransformType.Uppercase) {
+                return char.toUpperCase();
+            }
+            console.warn(`ARD-IS049T: digit-input's value validator encountered an unexpected value of the config's "transform" property. Ardium UI was able to handle this issue, but please report it to the creators.`);
+        }
+        return char;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"digit-input.model.js","sourceRoot":"","sources":["../../../../../../projects/ui/src/lib/inputs/digit-input/digit-input.model.ts"],"names":[],"mappings":"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","sourcesContent":["import { ElementRef, QueryList } from '@angular/core';\nimport { coerceArrayProperty } from '@ardium-ui/devkit';\nimport { isAnyString, isArray, isDefined, isFunction, isNull, isNumber, isRegExp } from 'simple-bool';\nimport { DigitInputConfigDataType, DigitInputModelHost, _sanitizeRegExpString } from './digit-input.utils';\nimport { DigitInputAcceptObject, DigitInputConfig, DigitInputOption, DigitInputPrimitiveOption, TransformType } from './digit-input.types';\n\nexport class DigitInputModel {\n    constructor(private _ardHost: DigitInputModelHost) {}\n\n    private _configArray: DigitInputOption[] = [];\n    private set configArray(arr: DigitInputOption[]) {\n        this._configArray = arr;\n        this._configArrayNoStatics = arr.filter(v => !('static' in v)) as DigitInputAcceptObject[];\n        this.setConfigArrayData();\n    }\n    private _configArrayNoStatics: DigitInputAcceptObject[] = [];\n\n    setConfigArrayData() {\n        let inputIndex = 0;\n        this._ardHost.configArrayData = this._configArray.map(v => {\n            if ('static' in v) {\n                return {\n                    type: DigitInputConfigDataType.Static,\n                    char: v.static,\n                };\n            }\n            return {\n                type: DigitInputConfigDataType.Input,\n                index: inputIndex++,\n            };\n        });\n    }\n    get isConfigDefined(): boolean {\n        return this._configArray.length > 0;\n    }\n\n    private _value: (string | null)[] | null = null;\n    private set value(v: (string | null)[] | null) {\n        this._value = v;\n        this._stringValueMemo = null;\n    }\n    get value(): (string | null)[] | null {\n        return this._value;\n    }\n\n    private _stringValueMemo: string | null = null;\n    get stringValue(): string {\n        if (isNull(this._stringValueMemo)) {\n            const v =\n                this.value\n                    ?.map(v => v ?? ' ')\n                    .join('')\n                    .trimEnd() ?? '';\n            this._stringValueMemo = v;\n        }\n        return this._stringValueMemo;\n    }\n\n    get isValueFull(): boolean {\n        return isDefined(this.value) && this.value.length === this._configArrayNoStatics.length;\n    }\n\n    isDefinedAtIndex(index: number): boolean {\n        return Boolean(this.value?.[index]);\n    }\n\n    writeValue(v: any): boolean {\n        if (!isArray(v) && !isAnyString(v) && !isNull(v)) {\n            //warn when using non-string/non-null value\n            console.warn(new Error(`ARD-WA041: Trying to set <ard-digit-input>'s value to ${typeof v}, expected string or array strings.`));\n            //normalize the value\n            v = v?.toString?.() ?? String(v);\n        }\n        const vArray = coerceArrayProperty(v);\n        const problemIndex = vArray.findIndex(el => !isAnyString(el) || el.length > 1);\n        if (problemIndex != -1) {\n            throw new Error(\n                `ARD-FT042: Array passed to <ard-digit-input>'s value must only contain strings of length 1 or 0. Element at index ${problemIndex} does not match those requirements.`\n            );\n        }\n        return this._writeValue(vArray);\n    }\n    private _writeValue(v: string[] | null): boolean {\n        let oldVal = this.value;\n        this.value = v && v.map(el => el || null);\n        this.validateValueAndUpdate();\n        this._updateInputElements();\n        return oldVal !== v;\n    }\n\n    private _updateInputElements() {\n        const value = this.value ?? [];\n        let i = 0;\n        for (const inputEl of this._ardHost.inputs) {\n            inputEl.nativeElement.value = value[i] ?? '';\n            i++;\n        }\n    }\n\n    //! setting config\n    setConfig(config: DigitInputConfig): void {\n        this._setConfig(config);\n        this.validateValueAndUpdate();\n    }\n    private _setConfig(config: DigitInputConfig): void {\n        //map a number to ready objects\n        let configAsNumber = isAnyString(config) ? Number(config) : null;\n        if (isNumber(config) || isNumber(configAsNumber)) {\n            configAsNumber = isNumber(config) ? config : configAsNumber!;\n            this.configArray = 'a'\n                .repeat(configAsNumber)\n                .split('')\n                .map(() => ({ accept: str => /[0-9]/.test(str) }));\n            return;\n        }\n        //map a string to an array\n        let configArr: string[] | Exclude<DigitInputConfig, number | string>;\n        if (isAnyString(config)) {\n            configArr = coerceArrayProperty(config);\n        } else {\n            configArr = config;\n        }\n        //map array to ready objects\n        this.configArray = configArr.map((v, i) => {\n            if (!isAnyString(v)) {\n                if ('accept' in v && !isFunction(v.accept)) {\n                    const regExp = isRegExp(v.accept) ? v.accept : new RegExp(`[${_sanitizeRegExpString(v.accept)}]`);\n                    v.accept = str => regExp.test(str);\n                }\n                return v;\n            }\n\n            switch (v) {\n                case DigitInputPrimitiveOption.Number:\n                    return { accept: str => /[0-9]/.test(str) };\n                case DigitInputPrimitiveOption.Letter:\n                    return { accept: str => /[a-zA-Z]/.test(str) };\n                case DigitInputPrimitiveOption.Alphanumeric:\n                    return { accept: str => /[0-9a-zA-Z]/.test(str) };\n                case DigitInputPrimitiveOption.Special:\n                    return { accept: str => /[!@#$%^&*-_=+/\\\\.,]/.test(str) };\n\n                default:\n                    if (configArr.length == 1) {\n                        throw new Error(`ARD-NF043S: <ard-digit-input>'s config is invalid. Expected number or array, got \"${v}\"`);\n                    }\n                    throw new Error(`ARD-NF043B: Found invalid string in <ard-digit-input>'s config: \"${v}\" at index ${i}`);\n            }\n        });\n    }\n\n    //! validate against the config\n    validateInputAndSetValue(input: string, index: number): false | [boolean, string | null] {\n        if (index < 0 || index > this._configArrayNoStatics.length) return false;\n\n        //prepare the value array if does not exist\n        if (!this.value) {\n            this.value = [];\n        }\n        //prepare the characters before the current one (to be used in validation)\n        const before = this.value\n            .slice(0, index)\n            .map(v => v ?? ' ')\n            .join('');\n\n        //remove the old character from the input element\n        const oldVal = this.value[index];\n        if (oldVal && input.length > 1 && input.match(oldVal)) {\n            input = input.replace(oldVal, '');\n        }\n        //use only the first character (error safety)\n        input = input.charAt(0);\n\n        //validate and transform, if necessary\n        const inputChar = this._validateSingleChar(input, before, this._configArrayNoStatics[index]);\n\n        //get the corresponding HTML input element\n        const inputEl = this._ardHost.inputs.get(index);\n        if (!inputEl) {\n            throw new Error(\n                \"ARD-IS048: <ard-digit-input>'s value changed, but its corresponding input element could not be found. This is error is fatal to the functioning of Ardium UI. Please report this issue to the creators.\"\n            );\n        }\n        //update the input element and value array\n        const newVal = inputChar ?? oldVal;\n        inputEl.nativeElement.value = newVal ?? '';\n        this.value[index] = newVal;\n\n        //return changes marker and validated value\n        return [newVal !== oldVal, inputChar];\n    }\n    validateValueAndUpdate(): void {\n        const v = this.value;\n        if (!v) return;\n\n        let before = '';\n        const newValue: (string | null)[] = [];\n        for (let i = 0; i < Math.min(this._configArrayNoStatics.length, v.length); i++) {\n            const char = v[i];\n            before += char ?? ' ';\n\n            if (!char) {\n                newValue.push(char);\n                continue;\n            }\n            const config = this._configArrayNoStatics[i];\n\n            const newChar = this._validateSingleChar(char, before, config);\n            newValue.push(newChar);\n        }\n        this.value = newValue;\n    }\n    private _validateSingleChar(char: string | null, before: string, config: DigitInputAcceptObject): string | null {\n        if (config.readonly) {\n            throw new Error(\n                `ARD-IS049R: trying to set value of a digit-input's readonly field. This is error is fatal to the functioning of Ardium UI. Please report this issue to the creators.`\n            );\n        }\n        if (!isFunction(config.accept)) {\n            const regExp = isRegExp(config.accept) ? config.accept : new RegExp(`[${_sanitizeRegExpString(config.accept)}]`);\n            config.accept = str => regExp.test(str);\n            console.warn(\n                `ARD-IS049A: digit-input's value validator encountered an unexpected value of the config's \"accept\" property. Ardium UI was able to handle this issue, but please report it to the creators.`\n            );\n        }\n        if (!char) return char;\n\n        const canAccept = config.accept(char, before);\n        if (!canAccept) return null;\n\n        if (config.transform) {\n            if (config.transform == TransformType.Lowercase) {\n                return char.toLowerCase();\n            }\n            if (config.transform == TransformType.Uppercase) {\n                return char.toUpperCase();\n            }\n            console.warn(\n                `ARD-IS049T: digit-input's value validator encountered an unexpected value of the config's \"transform\" property. Ardium UI was able to handle this issue, but please report it to the creators.`\n            );\n        }\n        return char;\n    }\n}\n"]}

package/esm2022/lib/inputs/digit-input/digit-input.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { ArdiumDigitInputComponent } from './digit-input.component';
+import * as i0 from "@angular/core";
+export class ArdiumDigitInputModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputModule, declarations: [ArdiumDigitInputComponent], imports: [CommonModule], exports: [ArdiumDigitInputComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputModule, imports: [CommonModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.7", ngImport: i0, type: ArdiumDigitInputModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [ArdiumDigitInputComponent],
+                    imports: [CommonModule],
+                    exports: [ArdiumDigitInputComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlnaXQtaW5wdXQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdWkvc3JjL2xpYi9pbnB1dHMvZGlnaXQtaW5wdXQvZGlnaXQtaW5wdXQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDOztBQU9wRSxNQUFNLE9BQU8sc0JBQXNCOzhHQUF0QixzQkFBc0I7K0dBQXRCLHNCQUFzQixpQkFKaEIseUJBQXlCLGFBQzlCLFlBQVksYUFDWix5QkFBeUI7K0dBRTFCLHNCQUFzQixZQUhyQixZQUFZOzsyRkFHYixzQkFBc0I7a0JBTGxDLFFBQVE7bUJBQUM7b0JBQ04sWUFBWSxFQUFFLENBQUMseUJBQXlCLENBQUM7b0JBQ3pDLE9BQU8sRUFBRSxDQUFDLFlBQVksQ0FBQztvQkFDdkIsT0FBTyxFQUFFLENBQUMseUJBQXlCLENBQUM7aUJBQ3ZDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBBcmRpdW1EaWdpdElucHV0Q29tcG9uZW50IH0gZnJvbSAnLi9kaWdpdC1pbnB1dC5jb21wb25lbnQnO1xuXG5ATmdNb2R1bGUoe1xuICAgIGRlY2xhcmF0aW9uczogW0FyZGl1bURpZ2l0SW5wdXRDb21wb25lbnRdLFxuICAgIGltcG9ydHM6IFtDb21tb25Nb2R1bGVdLFxuICAgIGV4cG9ydHM6IFtBcmRpdW1EaWdpdElucHV0Q29tcG9uZW50XSxcbn0pXG5leHBvcnQgY2xhc3MgQXJkaXVtRGlnaXRJbnB1dE1vZHVsZSB7fVxuIl19