@seniorsistemas/angular-components 18.0.4 → 18.1.0-feature-sds-276-640ecaac

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

@@ -0,0 +1,460 @@
+import { Component, forwardRef, viewChildren, ElementRef, signal, input, output, effect, computed, model, inject, DestroyRef, } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+/**
+ * Pin Code Field Component
+ *
+ * A flexible, accessible PIN code input component that implements {@link ControlValueAccessor}
+ * for seamless integration with Angular Reactive Forms and Template-driven Forms.
+ *
+ * Features:
+ * - Multiple input fields for PIN/OTP code entry
+ * - Configurable code length and character validation
+ * - Keyboard navigation (arrow keys, backspace)
+ * - Paste support with automatic truncation
+ * - Error state display via the `invalid` input
+ * - Full accessibility support (ARIA labels, semantic roles)
+ * - Signal-based state management
+ *
+ * @example
+ * ```html
+ * <form [formGroup]="form">
+ *   <s-pin-code-field
+ *     formControlName="code"
+ *     [length]="6"
+ *     [alphanumeric]="false"
+ *     [invalid]="(form.get('code')?.invalid && form.get('code')?.dirty) || false"
+ *     helpText="Enter your 6-digit code"
+ *     (codeFilled)="onCodeFilled($event)">
+ *   </s-pin-code-field>
+ * </form>
+ * ```
+ *
+ * @example
+ * ```typescript
+ * form = this.fb.group({
+ *   code: ['', [Validators.required]],
+ * });
+ * ```
+ */
+export class PinCodeFieldComponent {
+    static LAST_INDEX_OFFSET = 1;
+    static EMPTY_VALUE = '';
+    /**
+     * Number of input fields (PIN code length).
+     * Must be at least 1.
+     *
+     * @default 6
+     */
+    length = input(6);
+    /**
+     * Allows alphanumeric and special characters input.
+     * When false, only numeric input (0-9) is accepted.
+     *
+     * @default false
+     */
+    alphanumeric = input(false);
+    /**
+     * Help text displayed below the input fields.
+     *
+     * @default ''
+     */
+    helpText = input('');
+    /**
+     * Controls the error state visualization of the component.
+     * When true, displays red border on input fields.
+     * Typically bound to FormControl's invalid and dirty state.
+     *
+     * @example
+     * ```html
+     * [invalid]="(control?.invalid && control?.dirty) || false"
+     * ```
+     * @default false
+     */
+    invalid = input(false);
+    /**
+     * Two-way binding for the disabled state of the component.
+     * Disables all input fields and prevents user interaction.
+     *
+     * @default false
+     */
+    disabled = model(false);
+    /**
+     * Emitted when all PIN code fields are filled.
+     * Emits the complete PIN code as a string.
+     *
+     * @example
+     * ```html
+     * (codeFilled)="onCodeFilled($event)"
+     * ```
+     */
+    codeFilled = output();
+    /**
+     * Signal containing the current values of each input field.
+     * Array length matches the `length` input value.
+     */
+    inputs = signal([]);
+    /**
+     * Signal tracking whether the component has been touched by the user.
+     * Set to true when the last input field loses focus (blur event).
+     */
+    touched = signal(false);
+    /**
+     * Computed signal indicating whether all PIN code fields are filled.
+     * True only when every field contains a non-empty value.
+     */
+    isComplete = computed(() => this.inputs().every((input) => input !== ''));
+    /**
+     * Computed signal containing the complete PIN code as a joined string.
+     * Returns empty string if no inputs are filled.
+     */
+    currentValue = computed(() => this.inputs().join(''));
+    /**
+     * Signal tracking if the component host has the ng-invalid class from FormControl validators.
+     * Updated reactively whenever the invalid state changes.
+     */
+    hasNgInvalidClass = signal(false);
+    /**
+     * Signal tracking if the FormControl is dirty.
+     * Updated reactively whenever the dirty state changes.
+     */
+    isControlDirty = signal(false);
+    /**
+     * Computed signal indicating if the component should show error state.
+     * Returns true if:
+     * - The `invalid` input is true, OR
+     * - The component has the `ng-invalid` class AND the FormControl is dirty (touched/modified)
+     * This ensures errors are only shown to the user after they've interacted with the field.
+     */
+    hasError = computed(() => this.invalid() || (this.hasNgInvalidClass() && this.isControlDirty()));
+    /**
+     * ViewChildren reference to all input DOM elements.
+     * Used for DOM manipulation (focus, selection).
+     */
+    pinInputs = viewChildren('pinInput');
+    elementRef = inject(ElementRef);
+    destroyRef = inject(DestroyRef);
+    onChange = () => { };
+    onTouched = () => { };
+    constructor() {
+        effect(() => {
+            const newLength = this.length();
+            if (newLength < 1) {
+                console.warn('PIN code length must be at least 1');
+                return;
+            }
+            if (this.inputs().length !== newLength) {
+                this.inputs.set(Array.from({ length: newLength }, () => ''));
+            }
+        }, { allowSignalWrites: true });
+        // Monitor ng-invalid and ng-dirty classes on the host element for reactive error state
+        effect(() => {
+            // Access inputs to create dependency on changes
+            this.inputs();
+            this.invalid();
+            // Use setTimeout to defer the check to next tick to ensure Angular has updated DOM classes
+            const timeoutId = window.setTimeout(() => {
+                const hostElement = this.elementRef.nativeElement;
+                const hasNgInvalid = hostElement.classList.contains('ng-invalid');
+                const isDirty = hostElement.classList.contains('ng-dirty');
+                this.hasNgInvalidClass.set(hasNgInvalid);
+                this.isControlDirty.set(isDirty);
+            });
+            // Cleanup timeout on component destroy
+            this.destroyRef.onDestroy(() => {
+                clearTimeout(timeoutId);
+            });
+        }, { allowSignalWrites: true });
+    }
+    /**
+     * Handles input event on PIN code fields.
+     * Validates character input, prevents multiple characters per field,
+     * auto-advances to next field when character is entered.
+     *
+     * @param index - The input field index (0-based)
+     * @param event - The input event
+     */
+    onInput(index, event) {
+        if (this.disabled()) {
+            event.preventDefault();
+            return;
+        }
+        const target = event.target;
+        const value = target.value;
+        if (value.length > 1 || (value && !this.isValidCharacter(value))) {
+            this.clearInput(target);
+            return;
+        }
+        this.setInputAtIndex(index, value);
+        if (value && index < this.length() - 1) {
+            this.focusAndSelectInput(index + 1);
+        }
+        if (this.isComplete()) {
+            this.codeFilled.emit(this.currentValue());
+        }
+    }
+    /**
+     * Handles keyboard events on PIN code fields.
+     * Supports arrow navigation (left/right) and backspace key.
+     *
+     * Keyboard behavior:
+     * - ArrowRight: Move focus to next field
+     * - ArrowLeft: Move focus to previous field
+     * - Backspace: Clear current or previous field and adjust focus
+     *
+     * @param index - The input field index (0-based)
+     * @param event - The keyboard event
+     */
+    onKeyDown(index, event) {
+        if (this.disabled()) {
+            event.preventDefault();
+            return;
+        }
+        const key = event.key;
+        switch (key) {
+            case 'ArrowRight':
+                if (index < this.length() - 1) {
+                    event.preventDefault();
+                    this.focusAndSelectInput(index + 1);
+                }
+                break;
+            case 'ArrowLeft':
+                if (index > 0) {
+                    event.preventDefault();
+                    this.focusAndSelectInput(index - 1);
+                }
+                break;
+            case 'Backspace':
+                event.preventDefault();
+                this.handleBackspace(index);
+                break;
+        }
+    }
+    /**
+     * Handles paste (clipboard) events on PIN code fields.
+     * Extracts valid characters from pasted content, filters by character type,
+     * and automatically truncates to match field length.
+     *
+     * Behavior:
+     * - Filters characters based on `alphanumeric` setting
+     * - Truncates to maximum field count
+     * - Fills available fields with pasted content
+     * - Emits codeFilled event if all fields are filled
+     *
+     * @param event - The clipboard event
+     */
+    onPaste(event) {
+        if (this.disabled()) {
+            event.preventDefault();
+            return;
+        }
+        event.preventDefault();
+        const validChars = this.extractValidCharactersFromPaste(event);
+        if (validChars.length === 0) {
+            return;
+        }
+        const filledInputs = [
+            ...validChars,
+            ...Array(this.length() - validChars.length).fill(''),
+        ];
+        this.inputs.set(filledInputs);
+        this.updateValue();
+        // Focus on the first empty input or the last filled input if all are filled
+        const firstEmptyIndex = validChars.length < this.length() ? validChars.length : validChars.length - 1;
+        this.focusAndSelectInput(firstEmptyIndex);
+        if (this.isComplete()) {
+            this.codeFilled.emit(this.currentValue());
+        }
+    }
+    /**
+     * Handles focus event on PIN code fields.
+     * Selects all text in the input field when focused.
+     *
+     * @param index - The input field index (0-based)
+     */
+    onFocus(index) {
+        const input = this.pinInputs()[index];
+        if (input) {
+            input.nativeElement.select();
+        }
+    }
+    /**
+     * Handles blur event on PIN code fields.
+     * Marks the component as touched when the last input field loses focus.
+     * Also notifies the registered onTouched callback for FormControl integration.
+     *
+     * @param index - The input field index (0-based)
+     */
+    onBlur(index) {
+        // Only mark as touched when the LAST input loses focus
+        if (index === this.length() - PinCodeFieldComponent.LAST_INDEX_OFFSET) {
+            this.touched.set(true);
+            this.onTouched();
+        }
+    }
+    /**
+     * Clears the input value at specified index and adjusts focus accordingly.
+     * If current field is empty, moves to previous field and clears it.
+     *
+     * @private
+     * @param index - The input field index (0-based)
+     */
+    handleBackspace(index) {
+        const currentInputs = this.inputs();
+        // If current input has value, clear it
+        if (currentInputs[index]) {
+            this.setInputAtIndex(index, PinCodeFieldComponent.EMPTY_VALUE);
+            return;
+        }
+        // Otherwise, clear previous input and focus it
+        if (index > 0) {
+            this.setInputAtIndex(index - 1, PinCodeFieldComponent.EMPTY_VALUE);
+            this.focusAndSelectInput(index - 1);
+        }
+    }
+    /**
+     * Sets the value at a specific input field index and updates the form value.
+     * Updates the signal and triggers the change detection via onChange callback.
+     *
+     * @private
+     * @param index - The input field index (0-based)
+     * @param value - The value to set in the field
+     */
+    setInputAtIndex(index, value) {
+        const currentInputs = this.inputs();
+        currentInputs[index] = value;
+        this.inputs.set([...currentInputs]);
+        this.updateValue();
+    }
+    /**
+     * Focuses on and selects text in the input field at the specified index.
+     * Uses queueMicrotask to ensure DOM is updated before focusing.
+     *
+     * @private
+     * @param index - The input field index (0-based)
+     */
+    focusAndSelectInput(index) {
+        queueMicrotask(() => {
+            const input = this.pinInputs()[index];
+            if (input) {
+                input.nativeElement.focus();
+                input.nativeElement.select();
+            }
+        });
+    }
+    /**
+     * Clears the value of an input element.
+     * Used for input validation to reject invalid characters.
+     *
+     * @private
+     * @param target - The HTML input element to clear
+     */
+    clearInput(target) {
+        target.value = '';
+    }
+    /**
+     * Extracts valid characters from pasted content.
+     * Filters based on alphanumeric setting and limits to component's length.
+     *
+     * @private
+     * @param event - The clipboard event
+     * @returns Array of valid characters from the pasted content
+     */
+    extractValidCharactersFromPaste(event) {
+        const pastedText = (event.clipboardData?.getData('text') || '').trim();
+        return pastedText
+            .split('')
+            .filter((char) => this.isValidCharacter(char))
+            .slice(0, this.length());
+    }
+    /**
+     * Validates if a character is acceptable based on component configuration.
+     * For numeric mode, accepts only digits 0-9.
+     * For alphanumeric mode, accepts any non-whitespace character.
+     *
+     * @private
+     * @param char - The character to validate
+     * @returns true if character is valid, false otherwise
+     */
+    isValidCharacter(char) {
+        if (this.alphanumeric()) {
+            return char.trim().length > 0;
+        }
+        return /^[0-9]$/.test(char);
+    }
+    /**
+     * Updates the form value by calling the onChange callback registered by FormControl.
+     * This ensures the reactive form stays synchronized with component state.
+     *
+     * @private
+     */
+    updateValue() {
+        this.onChange(this.currentValue());
+    }
+    /**
+     * Implements ControlValueAccessor interface.
+     * Called by the FormControl to write a value to the component.
+     * Only accepts string values with length matching the component's length setting.
+     *
+     * @param value - The value to write (typically from the FormControl)
+     */
+    writeValue(value) {
+        if (value) {
+            const stringValue = String(value);
+            if (stringValue.length === this.length()) {
+                this.inputs.set(stringValue.split(''));
+            }
+        }
+    }
+    /**
+     * Implements ControlValueAccessor interface.
+     * Called by the FormControl when value changes.
+     * Registers the callback to be called when the component value changes.
+     *
+     * @param fn - Callback function to invoke when component value changes
+     */
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    /**
+     * Implements ControlValueAccessor interface.
+     * Called by the FormControl to register the touched callback.
+     * The callback is invoked when the last input field loses focus.
+     *
+     * @param fn - Callback function to invoke when component is touched
+     */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /**
+     * Implements ControlValueAccessor interface.
+     * Called by the FormControl to set the disabled state of the component.
+     * Updates the disabled model to reflect the form's disabled state.
+     *
+     * @param isDisabled - Whether the component should be disabled
+     */
+    setDisabledState(isDisabled) {
+        this.disabled.set(isDisabled);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.14", type: PinCodeFieldComponent, isStandalone: true, selector: "s-pin-code-field", inputs: { length: { classPropertyName: "length", publicName: "length", isSignal: true, isRequired: false, transformFunction: null }, alphanumeric: { classPropertyName: "alphanumeric", publicName: "alphanumeric", isSignal: true, isRequired: false, transformFunction: null }, helpText: { classPropertyName: "helpText", publicName: "helpText", isSignal: true, isRequired: false, transformFunction: null }, invalid: { classPropertyName: "invalid", publicName: "invalid", isSignal: true, isRequired: false, transformFunction: null }, disabled: { classPropertyName: "disabled", publicName: "disabled", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { disabled: "disabledChange", codeFilled: "codeFilled" }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: forwardRef(() => PinCodeFieldComponent),
+                multi: true,
+            },
+        ], viewQueries: [{ propertyName: "pinInputs", predicate: ["pinInput"], descendants: true, isSignal: true }], ngImport: i0, template: "<div class=\"gap-xsmall flex flex-col\">\n    <div\n        class=\"flex gap-2\"\n        role=\"group\"\n        aria-label=\"PIN code input\"\n        [attr.aria-labelledby]=\"helpText() ? 'pin-help-text' : null\"\n    >\n        @for (input of inputs(); let i = $index; track i) {\n            <input\n                #pinInput\n                type=\"text\"\n                class=\"h-12 w-12 rounded-xbig border text-center text-lg font-medium transition-all duration-200\"\n                [ngClass]=\"{\n                    'border-criticality-red focus:ring-criticality-red': hasError(),\n                    'border-grayscale-30 focus:border-primary focus:ring-primary': !hasError(),\n                    'cursor-not-allowed bg-grayscale-10 text-grayscale-60': disabled(),\n                    'bg-grayscale-0 text-grayscale-100 focus:outline-none': !disabled(),\n                }\"\n                [value]=\"input\"\n                [disabled]=\"disabled()\"\n                [attr.maxlength]=\"1\"\n                [attr.inputmode]=\"alphanumeric() ? 'text' : 'numeric'\"\n                [attr.aria-label]=\"'PIN code character ' + (i + 1) + ' of ' + length()\"\n                [attr.aria-describedby]=\"helpText() ? 'pin-help-text' : null\"\n                [attr.aria-required]=\"true\"\n                autocomplete=\"off\"\n                (input)=\"onInput(i, $event)\"\n                (keydown)=\"onKeyDown(i, $event)\"\n                (paste)=\"onPaste($event)\"\n                (focus)=\"onFocus(i)\"\n                (blur)=\"onBlur(i)\"\n            />\n        }\n    </div>\n\n    @if (helpText()) {\n        <div\n            id=\"pin-help-text\"\n            class=\"mt-small text-sm text-grayscale-60\"\n        >\n            {{ helpText() }}\n        </div>\n    }\n</div>\n\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-pin-code-field', standalone: true, imports: [CommonModule], providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: forwardRef(() => PinCodeFieldComponent),
+                            multi: true,
+                        },
+                    ], template: "<div class=\"gap-xsmall flex flex-col\">\n    <div\n        class=\"flex gap-2\"\n        role=\"group\"\n        aria-label=\"PIN code input\"\n        [attr.aria-labelledby]=\"helpText() ? 'pin-help-text' : null\"\n    >\n        @for (input of inputs(); let i = $index; track i) {\n            <input\n                #pinInput\n                type=\"text\"\n                class=\"h-12 w-12 rounded-xbig border text-center text-lg font-medium transition-all duration-200\"\n                [ngClass]=\"{\n                    'border-criticality-red focus:ring-criticality-red': hasError(),\n                    'border-grayscale-30 focus:border-primary focus:ring-primary': !hasError(),\n                    'cursor-not-allowed bg-grayscale-10 text-grayscale-60': disabled(),\n                    'bg-grayscale-0 text-grayscale-100 focus:outline-none': !disabled(),\n                }\"\n                [value]=\"input\"\n                [disabled]=\"disabled()\"\n                [attr.maxlength]=\"1\"\n                [attr.inputmode]=\"alphanumeric() ? 'text' : 'numeric'\"\n                [attr.aria-label]=\"'PIN code character ' + (i + 1) + ' of ' + length()\"\n                [attr.aria-describedby]=\"helpText() ? 'pin-help-text' : null\"\n                [attr.aria-required]=\"true\"\n                autocomplete=\"off\"\n                (input)=\"onInput(i, $event)\"\n                (keydown)=\"onKeyDown(i, $event)\"\n                (paste)=\"onPaste($event)\"\n                (focus)=\"onFocus(i)\"\n                (blur)=\"onBlur(i)\"\n            />\n        }\n    </div>\n\n    @if (helpText()) {\n        <div\n            id=\"pin-help-text\"\n            class=\"mt-small text-sm text-grayscale-60\"\n        >\n            {{ helpText() }}\n        </div>\n    }\n</div>\n\n" }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pin-code-field.component.js","sourceRoot":"","sources":["../../../../../projects/angular-components/pin-code-field/src/lib/pin-code-field/pin-code-field.component.ts","../../../../../projects/angular-components/pin-code-field/src/lib/pin-code-field/pin-code-field.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n    Component,\n    forwardRef,\n    viewChildren,\n    ElementRef,\n    signal,\n    input,\n    output,\n    effect,\n    computed,\n    model,\n    inject,\n    DestroyRef,\n} from '@angular/core';\nimport { CommonModule } from '@angular/common';\nimport { ControlValueAccessor, NG_VALUE_ACCESSOR } from '@angular/forms';\n\n/**\n * Pin Code Field Component\n *\n * A flexible, accessible PIN code input component that implements {@link ControlValueAccessor}\n * for seamless integration with Angular Reactive Forms and Template-driven Forms.\n *\n * Features:\n * - Multiple input fields for PIN/OTP code entry\n * - Configurable code length and character validation\n * - Keyboard navigation (arrow keys, backspace)\n * - Paste support with automatic truncation\n * - Error state display via the `invalid` input\n * - Full accessibility support (ARIA labels, semantic roles)\n * - Signal-based state management\n *\n * @example\n * ```html\n * <form [formGroup]=\"form\">\n *   <s-pin-code-field\n *     formControlName=\"code\"\n *     [length]=\"6\"\n *     [alphanumeric]=\"false\"\n *     [invalid]=\"(form.get('code')?.invalid && form.get('code')?.dirty) || false\"\n *     helpText=\"Enter your 6-digit code\"\n *     (codeFilled)=\"onCodeFilled($event)\">\n *   </s-pin-code-field>\n * </form>\n * ```\n *\n * @example\n * ```typescript\n * form = this.fb.group({\n *   code: ['', [Validators.required]],\n * });\n * ```\n */\n@Component({\n    selector: 's-pin-code-field',\n    templateUrl: './pin-code-field.component.html',\n    standalone: true,\n    imports: [CommonModule],\n    providers: [\n        {\n            provide: NG_VALUE_ACCESSOR,\n            useExisting: forwardRef(() => PinCodeFieldComponent),\n            multi: true,\n        },\n    ],\n})\nexport class PinCodeFieldComponent implements ControlValueAccessor {\n    private static readonly LAST_INDEX_OFFSET = 1;\n    private static readonly EMPTY_VALUE = '';\n\n    /**\n     * Number of input fields (PIN code length).\n     * Must be at least 1.\n     *\n     * @default 6\n     */\n    public length = input(6);\n\n    /**\n     * Allows alphanumeric and special characters input.\n     * When false, only numeric input (0-9) is accepted.\n     *\n     * @default false\n     */\n    public alphanumeric = input(false);\n\n    /**\n     * Help text displayed below the input fields.\n     *\n     * @default ''\n     */\n    public helpText = input('');\n\n    /**\n     * Controls the error state visualization of the component.\n     * When true, displays red border on input fields.\n     * Typically bound to FormControl's invalid and dirty state.\n     *\n     * @example\n     * ```html\n     * [invalid]=\"(control?.invalid && control?.dirty) || false\"\n     * ```\n     * @default false\n     */\n    public invalid = input(false);\n\n    /**\n     * Two-way binding for the disabled state of the component.\n     * Disables all input fields and prevents user interaction.\n     *\n     * @default false\n     */\n    public disabled = model(false);\n\n    /**\n     * Emitted when all PIN code fields are filled.\n     * Emits the complete PIN code as a string.\n     *\n     * @example\n     * ```html\n     * (codeFilled)=\"onCodeFilled($event)\"\n     * ```\n     */\n    public codeFilled = output<string>();\n\n    /**\n     * Signal containing the current values of each input field.\n     * Array length matches the `length` input value.\n     */\n    public inputs = signal<string[]>([]);\n\n    /**\n     * Signal tracking whether the component has been touched by the user.\n     * Set to true when the last input field loses focus (blur event).\n     */\n    public touched = signal<boolean>(false);\n\n    /**\n     * Computed signal indicating whether all PIN code fields are filled.\n     * True only when every field contains a non-empty value.\n     */\n    public isComplete = computed(() => this.inputs().every((input) => input !== ''));\n\n    /**\n     * Computed signal containing the complete PIN code as a joined string.\n     * Returns empty string if no inputs are filled.\n     */\n    public currentValue = computed(() => this.inputs().join(''));\n\n    /**\n     * Signal tracking if the component host has the ng-invalid class from FormControl validators.\n     * Updated reactively whenever the invalid state changes.\n     */\n    private hasNgInvalidClass = signal<boolean>(false);\n\n    /**\n     * Signal tracking if the FormControl is dirty.\n     * Updated reactively whenever the dirty state changes.\n     */\n    private isControlDirty = signal<boolean>(false);\n\n    /**\n     * Computed signal indicating if the component should show error state.\n     * Returns true if:\n     * - The `invalid` input is true, OR\n     * - The component has the `ng-invalid` class AND the FormControl is dirty (touched/modified)\n     * This ensures errors are only shown to the user after they've interacted with the field.\n     */\n    public hasError = computed(() =>\n        this.invalid() || (this.hasNgInvalidClass() && this.isControlDirty())\n    );\n\n    /**\n     * ViewChildren reference to all input DOM elements.\n     * Used for DOM manipulation (focus, selection).\n     */\n    public pinInputs = viewChildren<ElementRef>('pinInput');\n\n    private readonly elementRef = inject(ElementRef);\n    private readonly destroyRef = inject(DestroyRef);\n\n    private onChange: (value: string) => void = () => {};\n    private onTouched: () => void = () => {};\n\n    constructor() {\n        effect(\n            () => {\n                const newLength = this.length();\n                if (newLength < 1) {\n                    console.warn('PIN code length must be at least 1');\n                    return;\n                }\n                if (this.inputs().length !== newLength) {\n                    this.inputs.set(Array.from({ length: newLength }, () => ''));\n                }\n            },\n            { allowSignalWrites: true },\n        );\n\n        // Monitor ng-invalid and ng-dirty classes on the host element for reactive error state\n        effect(\n            () => {\n                // Access inputs to create dependency on changes\n                this.inputs();\n                this.invalid();\n                \n                // Use setTimeout to defer the check to next tick to ensure Angular has updated DOM classes\n                const timeoutId = window.setTimeout(() => {\n                    const hostElement = this.elementRef.nativeElement;\n                    const hasNgInvalid = hostElement.classList.contains('ng-invalid');\n                    const isDirty = hostElement.classList.contains('ng-dirty');\n                    \n                    this.hasNgInvalidClass.set(hasNgInvalid);\n                    this.isControlDirty.set(isDirty);\n                });\n\n                // Cleanup timeout on component destroy\n                this.destroyRef.onDestroy(() => {\n                    clearTimeout(timeoutId);\n                });\n            },\n            { allowSignalWrites: true },\n        );\n    }\n\n    /**\n     * Handles input event on PIN code fields.\n     * Validates character input, prevents multiple characters per field,\n     * auto-advances to next field when character is entered.\n     *\n     * @param index - The input field index (0-based)\n     * @param event - The input event\n     */\n    public onInput(index: number, event: Event): void {\n        if (this.disabled()) {\n            event.preventDefault();\n            return;\n        }\n\n        const target = event.target as HTMLInputElement;\n        const value = target.value;\n\n        if (value.length > 1 || (value && !this.isValidCharacter(value))) {\n            this.clearInput(target);\n            return;\n        }\n\n        this.setInputAtIndex(index, value);\n\n        if (value && index < this.length() - 1) {\n            this.focusAndSelectInput(index + 1);\n        }\n\n        if (this.isComplete()) {\n            this.codeFilled.emit(this.currentValue());\n        }\n    }\n\n    /**\n     * Handles keyboard events on PIN code fields.\n     * Supports arrow navigation (left/right) and backspace key.\n     *\n     * Keyboard behavior:\n     * - ArrowRight: Move focus to next field\n     * - ArrowLeft: Move focus to previous field\n     * - Backspace: Clear current or previous field and adjust focus\n     *\n     * @param index - The input field index (0-based)\n     * @param event - The keyboard event\n     */\n    public onKeyDown(index: number, event: KeyboardEvent): void {\n        if (this.disabled()) {\n            event.preventDefault();\n            return;\n        }\n\n        const key = event.key;\n\n        switch (key) {\n            case 'ArrowRight':\n                if (index < this.length() - 1) {\n                    event.preventDefault();\n                    this.focusAndSelectInput(index + 1);\n                }\n                break;\n            case 'ArrowLeft':\n                if (index > 0) {\n                    event.preventDefault();\n                    this.focusAndSelectInput(index - 1);\n                }\n                break;\n            case 'Backspace':\n                event.preventDefault();\n                this.handleBackspace(index);\n                break;\n        }\n    }\n\n    /**\n     * Handles paste (clipboard) events on PIN code fields.\n     * Extracts valid characters from pasted content, filters by character type,\n     * and automatically truncates to match field length.\n     *\n     * Behavior:\n     * - Filters characters based on `alphanumeric` setting\n     * - Truncates to maximum field count\n     * - Fills available fields with pasted content\n     * - Emits codeFilled event if all fields are filled\n     *\n     * @param event - The clipboard event\n     */\n    public onPaste(event: ClipboardEvent): void {\n        if (this.disabled()) {\n            event.preventDefault();\n            return;\n        }\n\n        event.preventDefault();\n\n        const validChars = this.extractValidCharactersFromPaste(event);\n\n        if (validChars.length === 0) {\n            return;\n        }\n\n        const filledInputs = [\n            ...validChars,\n            ...Array(this.length() - validChars.length).fill(''),\n        ];\n\n        this.inputs.set(filledInputs);\n        this.updateValue();\n\n        // Focus on the first empty input or the last filled input if all are filled\n        const firstEmptyIndex = validChars.length < this.length() ? validChars.length : validChars.length - 1;\n        this.focusAndSelectInput(firstEmptyIndex);\n\n        if (this.isComplete()) {\n            this.codeFilled.emit(this.currentValue());\n        }\n    }\n\n    /**\n     * Handles focus event on PIN code fields.\n     * Selects all text in the input field when focused.\n     *\n     * @param index - The input field index (0-based)\n     */\n    public onFocus(index: number): void {\n        const input = this.pinInputs()[index];\n        if (input) {\n            input.nativeElement.select();\n        }\n    }\n\n    /**\n     * Handles blur event on PIN code fields.\n     * Marks the component as touched when the last input field loses focus.\n     * Also notifies the registered onTouched callback for FormControl integration.\n     *\n     * @param index - The input field index (0-based)\n     */\n    public onBlur(index: number): void {\n        // Only mark as touched when the LAST input loses focus\n        if (index === this.length() - PinCodeFieldComponent.LAST_INDEX_OFFSET) {\n            this.touched.set(true);\n            this.onTouched();\n        }\n    }\n\n    /**\n     * Clears the input value at specified index and adjusts focus accordingly.\n     * If current field is empty, moves to previous field and clears it.\n     *\n     * @private\n     * @param index - The input field index (0-based)\n     */\n    private handleBackspace(index: number): void {\n        const currentInputs = this.inputs();\n        \n        // If current input has value, clear it\n        if (currentInputs[index]) {\n            this.setInputAtIndex(index, PinCodeFieldComponent.EMPTY_VALUE);\n            return;\n        }\n\n        // Otherwise, clear previous input and focus it\n        if (index > 0) {\n            this.setInputAtIndex(index - 1, PinCodeFieldComponent.EMPTY_VALUE);\n            this.focusAndSelectInput(index - 1);\n        }\n    }\n\n    /**\n     * Sets the value at a specific input field index and updates the form value.\n     * Updates the signal and triggers the change detection via onChange callback.\n     *\n     * @private\n     * @param index - The input field index (0-based)\n     * @param value - The value to set in the field\n     */\n    private setInputAtIndex(index: number, value: string): void {\n        const currentInputs = this.inputs();\n        currentInputs[index] = value;\n        this.inputs.set([...currentInputs]);\n        this.updateValue();\n    }\n\n    /**\n     * Focuses on and selects text in the input field at the specified index.\n     * Uses queueMicrotask to ensure DOM is updated before focusing.\n     *\n     * @private\n     * @param index - The input field index (0-based)\n     */\n    private focusAndSelectInput(index: number): void {\n        queueMicrotask(() => {\n            const input = this.pinInputs()[index];\n            if (input) {\n                input.nativeElement.focus();\n                input.nativeElement.select();\n            }\n        });\n    }\n\n    /**\n     * Clears the value of an input element.\n     * Used for input validation to reject invalid characters.\n     *\n     * @private\n     * @param target - The HTML input element to clear\n     */\n    private clearInput(target: HTMLInputElement): void {\n        target.value = '';\n    }\n\n    /**\n     * Extracts valid characters from pasted content.\n     * Filters based on alphanumeric setting and limits to component's length.\n     *\n     * @private\n     * @param event - The clipboard event\n     * @returns Array of valid characters from the pasted content\n     */\n    private extractValidCharactersFromPaste(event: ClipboardEvent): string[] {\n        const pastedText = (event.clipboardData?.getData('text') || '').trim();\n        return pastedText\n            .split('')\n            .filter((char) => this.isValidCharacter(char))\n            .slice(0, this.length());\n    }\n\n    /**\n     * Validates if a character is acceptable based on component configuration.\n     * For numeric mode, accepts only digits 0-9.\n     * For alphanumeric mode, accepts any non-whitespace character.\n     *\n     * @private\n     * @param char - The character to validate\n     * @returns true if character is valid, false otherwise\n     */\n    private isValidCharacter(char: string): boolean {\n        if (this.alphanumeric()) {\n            return char.trim().length > 0;\n        }\n        return /^[0-9]$/.test(char);\n    }\n\n    /**\n     * Updates the form value by calling the onChange callback registered by FormControl.\n     * This ensures the reactive form stays synchronized with component state.\n     *\n     * @private\n     */\n    private updateValue(): void {\n        this.onChange(this.currentValue());\n    }\n\n    /**\n     * Implements ControlValueAccessor interface.\n     * Called by the FormControl to write a value to the component.\n     * Only accepts string values with length matching the component's length setting.\n     *\n     * @param value - The value to write (typically from the FormControl)\n     */\n    public writeValue(value: any): void {\n        if (value) {\n            const stringValue = String(value);\n            if (stringValue.length === this.length()) {\n                this.inputs.set(stringValue.split(''));\n            }\n        }\n    }\n\n    /**\n     * Implements ControlValueAccessor interface.\n     * Called by the FormControl when value changes.\n     * Registers the callback to be called when the component value changes.\n     *\n     * @param fn - Callback function to invoke when component value changes\n     */\n    public registerOnChange(fn: (value: string) => void): void {\n        this.onChange = fn;\n    }\n\n    /**\n     * Implements ControlValueAccessor interface.\n     * Called by the FormControl to register the touched callback.\n     * The callback is invoked when the last input field loses focus.\n     *\n     * @param fn - Callback function to invoke when component is touched\n     */\n    public registerOnTouched(fn: () => void): void {\n        this.onTouched = fn;\n    }\n\n    /**\n     * Implements ControlValueAccessor interface.\n     * Called by the FormControl to set the disabled state of the component.\n     * Updates the disabled model to reflect the form's disabled state.\n     *\n     * @param isDisabled - Whether the component should be disabled\n     */\n    public setDisabledState(isDisabled: boolean): void {\n        this.disabled.set(isDisabled);\n    }\n}\n\n","<div class=\"gap-xsmall flex flex-col\">\n    <div\n        class=\"flex gap-2\"\n        role=\"group\"\n        aria-label=\"PIN code input\"\n        [attr.aria-labelledby]=\"helpText() ? 'pin-help-text' : null\"\n    >\n        @for (input of inputs(); let i = $index; track i) {\n            <input\n                #pinInput\n                type=\"text\"\n                class=\"h-12 w-12 rounded-xbig border text-center text-lg font-medium transition-all duration-200\"\n                [ngClass]=\"{\n                    'border-criticality-red focus:ring-criticality-red': hasError(),\n                    'border-grayscale-30 focus:border-primary focus:ring-primary': !hasError(),\n                    'cursor-not-allowed bg-grayscale-10 text-grayscale-60': disabled(),\n                    'bg-grayscale-0 text-grayscale-100 focus:outline-none': !disabled(),\n                }\"\n                [value]=\"input\"\n                [disabled]=\"disabled()\"\n                [attr.maxlength]=\"1\"\n                [attr.inputmode]=\"alphanumeric() ? 'text' : 'numeric'\"\n                [attr.aria-label]=\"'PIN code character ' + (i + 1) + ' of ' + length()\"\n                [attr.aria-describedby]=\"helpText() ? 'pin-help-text' : null\"\n                [attr.aria-required]=\"true\"\n                autocomplete=\"off\"\n                (input)=\"onInput(i, $event)\"\n                (keydown)=\"onKeyDown(i, $event)\"\n                (paste)=\"onPaste($event)\"\n                (focus)=\"onFocus(i)\"\n                (blur)=\"onBlur(i)\"\n            />\n        }\n    </div>\n\n    @if (helpText()) {\n        <div\n            id=\"pin-help-text\"\n            class=\"mt-small text-sm text-grayscale-60\"\n        >\n            {{ helpText() }}\n        </div>\n    }\n</div>\n\n"]}

package/esm2022/pin-code-field/lib/pin-code-field.module.mjs

@@ -0,0 +1,16 @@
+import { NgModule } from '@angular/core';
+import { PinCodeFieldComponent } from './pin-code-field/pin-code-field.component';
+import * as i0 from "@angular/core";
+export class PinCodeFieldModule {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+    static ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldModule, imports: [PinCodeFieldComponent], exports: [PinCodeFieldComponent] });
+    static ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldModule, imports: [PinCodeFieldComponent] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: PinCodeFieldModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [PinCodeFieldComponent],
+                    exports: [PinCodeFieldComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGluLWNvZGUtZmllbGQubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL3Bpbi1jb2RlLWZpZWxkL3NyYy9saWIvcGluLWNvZGUtZmllbGQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLHFCQUFxQixFQUFFLE1BQU0sMkNBQTJDLENBQUM7O0FBTWxGLE1BQU0sT0FBTyxrQkFBa0I7d0dBQWxCLGtCQUFrQjt5R0FBbEIsa0JBQWtCLFlBSGpCLHFCQUFxQixhQUNyQixxQkFBcUI7eUdBRXRCLGtCQUFrQixZQUhqQixxQkFBcUI7OzRGQUd0QixrQkFBa0I7a0JBSjlCLFFBQVE7bUJBQUM7b0JBQ04sT0FBTyxFQUFFLENBQUMscUJBQXFCLENBQUM7b0JBQ2hDLE9BQU8sRUFBRSxDQUFDLHFCQUFxQixDQUFDO2lCQUNuQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBQaW5Db2RlRmllbGRDb21wb25lbnQgfSBmcm9tICcuL3Bpbi1jb2RlLWZpZWxkL3Bpbi1jb2RlLWZpZWxkLmNvbXBvbmVudCc7XG5cbkBOZ01vZHVsZSh7XG4gICAgaW1wb3J0czogW1BpbkNvZGVGaWVsZENvbXBvbmVudF0sXG4gICAgZXhwb3J0czogW1BpbkNvZGVGaWVsZENvbXBvbmVudF0sXG59KVxuZXhwb3J0IGNsYXNzIFBpbkNvZGVGaWVsZE1vZHVsZSB7fVxuIl19

package/esm2022/pin-code-field/public-api.mjs

@@ -0,0 +1,3 @@
+export * from './lib/pin-code-field.module';
+export * from './lib/pin-code-field/pin-code-field.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXItY29tcG9uZW50cy9waW4tY29kZS1maWVsZC9zcmMvcHVibGljLWFwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsK0NBQStDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2xpYi9waW4tY29kZS1maWVsZC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcGluLWNvZGUtZmllbGQvcGluLWNvZGUtZmllbGQuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/pin-code-field/seniorsistemas-angular-components-pin-code-field.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VuaW9yc2lzdGVtYXMtYW5ndWxhci1jb21wb25lbnRzLXBpbi1jb2RlLWZpZWxkLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vcHJvamVjdHMvYW5ndWxhci1jb21wb25lbnRzL3Bpbi1jb2RlLWZpZWxkL3NyYy9zZW5pb3JzaXN0ZW1hcy1hbmd1bGFyLWNvbXBvbmVudHMtcGluLWNvZGUtZmllbGQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/fesm2022/seniorsistemas-angular-components-form-dynamic-lib-optional-fields-editor.mjs

@@ -0,0 +1,44 @@
+import { FormDynamicRegistry } from '@seniorsistemas/angular-components/form-dynamic';
+import * as i0 from '@angular/core';
+import { input, viewChild, Component } from '@angular/core';
+import Quill from 'quill';
+
+class EditorFieldComponent {
+    id = crypto.randomUUID();
+    field = input.required();
+    control = input.required();
+    editorContainer = viewChild.required('editorContainer');
+    quill;
+    ngAfterViewInit() {
+        this.quill = new Quill(this.editorContainer().nativeElement, {
+            theme: this.field().theme ?? 'snow',
+        });
+        this.quill.on('text-change', () => {
+            const html = this.editorContainer().nativeElement.querySelector('.ql-editor')?.innerHTML;
+            this.control().setValue(html, { emitEvent: true });
+        });
+        const initial = this.control().value;
+        if (initial) {
+            this.quill.root.innerHTML = initial;
+        }
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditorFieldComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.2.0", version: "18.2.14", type: EditorFieldComponent, isStandalone: true, selector: "s-editor-field", inputs: { field: { classPropertyName: "field", publicName: "field", isSignal: true, isRequired: true, transformFunction: null }, control: { classPropertyName: "control", publicName: "control", isSignal: true, isRequired: true, transformFunction: null } }, viewQueries: [{ propertyName: "editorContainer", first: true, predicate: ["editorContainer"], descendants: true, isSignal: true }], ngImport: i0, template: " <label [for]=\"id\">{{ field().label }}</label>\n\n<div [id]=\"id\" #editorContainer class=\"quill-container\"></div>\n", styles: [""] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.14", ngImport: i0, type: EditorFieldComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 's-editor-field', standalone: true, imports: [], template: " <label [for]=\"id\">{{ field().label }}</label>\n\n<div [id]=\"id\" #editorContainer class=\"quill-container\"></div>\n" }]
+        }] });
+
+// import { FieldDynamicBase } from "../../schemas/field-dynamic";
+
+// import { FormDynamicRegistry } from '@e-components/form-dynamic';
+// import { FormDynamicRegistry } from '../../core/registry';
+FormDynamicRegistry.registerField('editor', EditorFieldComponent);
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { EditorFieldComponent };
+//# sourceMappingURL=seniorsistemas-angular-components-form-dynamic-lib-optional-fields-editor.mjs.map

package/fesm2022/seniorsistemas-angular-components-form-dynamic-lib-optional-fields-editor.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"seniorsistemas-angular-components-form-dynamic-lib-optional-fields-editor.mjs","sources":["../../projects/angular-components/form-dynamic/lib/optional-fields/editor/editor-field/editor-field.component.ts","../../projects/angular-components/form-dynamic/lib/optional-fields/editor/editor-field/editor-field.component.html","../../projects/angular-components/form-dynamic/lib/optional-fields/editor/editor-types.ts","../../projects/angular-components/form-dynamic/lib/optional-fields/editor/public-api.ts","../../projects/angular-components/form-dynamic/lib/optional-fields/editor/seniorsistemas-angular-components-form-dynamic-lib-optional-fields-editor.ts"],"sourcesContent":["import { AfterViewInit, Component, ElementRef, input, viewChild } from '@angular/core';\nimport { EditorField } from '../editor-types';\nimport { FormControl } from '@angular/forms';\nimport Quill from 'quill';\n\n@Component({\n    selector: 's-editor-field',\n    standalone: true,\n    imports: [],\n    templateUrl: './editor-field.component.html',\n    styleUrl: './editor-field.component.css',\n})\nexport class EditorFieldComponent implements AfterViewInit {\n    id = crypto.randomUUID();\n\n    field = input.required<EditorField>();\n    control = input.required<FormControl>();\n\n    editorContainer = viewChild.required<ElementRef<HTMLElement>>('editorContainer');\n\n    quill!: Quill;\n\n    ngAfterViewInit() {\n        this.quill = new Quill(this.editorContainer().nativeElement, {\n            theme: this.field().theme ?? 'snow',\n        });\n\n        this.quill.on('text-change', () => {\n            const html = this.editorContainer().nativeElement.querySelector('.ql-editor')?.innerHTML;\n            this.control().setValue(html, { emitEvent: true });\n        });\n\n        const initial = this.control().value;\n        if (initial) {\n            this.quill.root.innerHTML = initial;\n        }\n    }\n}\n\n"," <label [for]=\"id\">{{ field().label }}</label>\n\n<div [id]=\"id\" #editorContainer class=\"quill-container\"></div>\n","// import { FieldDynamicBase } from \"../../schemas/field-dynamic\";\n\nimport { FieldDynamicBase } from '@seniorsistemas/angular-components/form-dynamic';\n\n// import { FieldDynamicBase } from \"@e-components/form-dynamic\";\nexport interface EditorField extends FieldDynamicBase {\n    type: 'editor';\n    key: string;\n    label?: string;\n    required?: boolean;\n\n    theme?: 'snow' | 'bubble';\n}\n\n// import { FieldTypeMap } from \"./../../schemas/field-dynamic\";\n\ndeclare module '@seniorsistemas/angular-components/form-dynamic' {\n    export interface FieldTypeMap {\n        editor: EditorField;\n    }\n}\n","// import { FormDynamicRegistry } from '@e-components/form-dynamic';\n// import { FormDynamicRegistry } from '../../core/registry';\nimport { FormDynamicRegistry } from '@seniorsistemas/angular-components/form-dynamic';\nimport { EditorFieldComponent } from '../editor/editor-field/editor-field.component';\n\nFormDynamicRegistry.registerField('editor', EditorFieldComponent);\n\nexport * from '../editor/editor-types';\nexport { EditorFieldComponent } from '../editor/editor-field/editor-field.component';\n\n","/**\n * Generated bundle index. Do not edit.\n */\n\nexport * from './public-api';\n"],"names":[],"mappings":";;;;;MAYa,oBAAoB,CAAA;AAC7B,IAAA,EAAE,GAAG,MAAM,CAAC,UAAU,EAAE,CAAC;AAEzB,IAAA,KAAK,GAAG,KAAK,CAAC,QAAQ,EAAe,CAAC;AACtC,IAAA,OAAO,GAAG,KAAK,CAAC,QAAQ,EAAe,CAAC;AAExC,IAAA,eAAe,GAAG,SAAS,CAAC,QAAQ,CAA0B,iBAAiB,CAAC,CAAC;AAEjF,IAAA,KAAK,CAAS;IAEd,eAAe,GAAA;AACX,QAAA,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,aAAa,EAAE;YACzD,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,MAAM;AACtC,SAAA,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,aAAa,EAAE,MAAK;AAC9B,YAAA,MAAM,IAAI,GAAG,IAAI,CAAC,eAAe,EAAE,CAAC,aAAa,CAAC,aAAa,CAAC,YAAY,CAAC,EAAE,SAAS,CAAC;AACzF,YAAA,IAAI,CAAC,OAAO,EAAE,CAAC,QAAQ,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;AACvD,SAAC,CAAC,CAAC;QAEH,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC;QACrC,IAAI,OAAO,EAAE;YACT,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC;SACvC;KACJ;wGAxBQ,oBAAoB,EAAA,IAAA,EAAA,EAAA,EAAA,MAAA,EAAA,EAAA,CAAA,eAAA,CAAA,SAAA,EAAA,CAAA,CAAA;AAApB,IAAA,OAAA,IAAA,GAAA,EAAA,CAAA,oBAAA,CAAA,EAAA,UAAA,EAAA,QAAA,EAAA,OAAA,EAAA,SAAA,EAAA,IAAA,EAAA,oBAAoB,8cCZjC,0HAGA,EAAA,MAAA,EAAA,CAAA,EAAA,CAAA,EAAA,CAAA,CAAA;;4FDSa,oBAAoB,EAAA,UAAA,EAAA,CAAA;kBAPhC,SAAS;+BACI,gBAAgB,EAAA,UAAA,EACd,IAAI,EAAA,OAAA,EACP,EAAE,EAAA,QAAA,EAAA,0HAAA,EAAA,CAAA;;;AERf;;ACAA;AACA;AAIA,mBAAmB,CAAC,aAAa,CAAC,QAAQ,EAAE,oBAAoB,CAAC;;ACLjE;;AAEG;;;;"}