@xosue-utils/inputs 0.1.0

package/lib/password-entry/password-entry.component.d.ts

@@ -0,0 +1,34 @@
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class PasswordEntryComponent implements ControlValueAccessor, OnInit {
+    hostElement: HTMLElement;
+    private cdr;
+    private elementRef;
+    label: string;
+    description: string;
+    opcional: boolean;
+    placeholder: string;
+    toggleVisibility: boolean;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    value: string | null;
+    isDisabled: boolean;
+    isFocus: boolean;
+    isPasswordVisible: boolean;
+    ngOnInit(): void;
+    private onChange;
+    onTouched: () => void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onInput(event: Event): void;
+    onFocus(event: FocusEvent): void;
+    onBlur(event: FocusEvent): void;
+    private emitValue;
+    togglePasswordVisibility(event?: Event): void;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PasswordEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PasswordEntryComponent, "password-entry", never, { "label": { "alias": "label"; "required": false; }; "description": { "alias": "description"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "toggleVisibility": { "alias": "toggleVisibility"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/phone-entry/phone-display.util.d.ts

@@ -0,0 +1,19 @@
+import { PhoneCountry } from './phone-entry.types';
+/** Normaliza prefijo a formato +NNN */
+export declare function normalizePhonePrefix(prefix: string | null | undefined): string;
+/**
+ * Quita el código de país del número si ya está incluido (solo para mostrar o editar en el input).
+ * Ej: prefix +51, number +51932454853 → 932454853
+ */
+export declare function stripCountryCodeFromNumber(number: string | null | undefined, prefix: string | null | undefined): string;
+/** Formato legible: "+51 932454853" sin duplicar el prefijo */
+export declare function formatPhoneForDisplay(prefix: string | null | undefined, number: string | null | undefined, fallback?: string): string;
+/**
+ * Detecta código de país en un número pegado o completo.
+ * Usa la lista de países (prefijo más largo primero).
+ */
+export declare function parseEmbeddedCountryCode(raw: string, countries: readonly PhoneCountry[]): {
+    prefix: string;
+    localNumber: string;
+    country: PhoneCountry | null;
+};

package/lib/phone-entry/phone-entry.component.d.ts

@@ -0,0 +1,80 @@
+import { OnInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { PhoneCountry } from './phone-entry.types';
+import * as i0 from "@angular/core";
+export type { PhoneCountry } from './phone-entry.types';
+export { formatPhoneForDisplay, stripCountryCodeFromNumber, } from './phone-display.util';
+export declare class PhoneEntryComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private phoneEntryModal;
+    private inputOverlayCoordinator;
+    private readonly overlayToken;
+    label: string;
+    opcional: boolean;
+    description: string;
+    placeholder: string;
+    defaultCountry: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    isFocus: boolean;
+    textValue: string;
+    error: boolean;
+    countries: PhoneCountry[];
+    selectedCountry: PhoneCountry;
+    showPicker: boolean;
+    searchQuery: string;
+    filteredCountries: PhoneCountry[];
+    customPrefix: string;
+    isEditingPrefix: boolean;
+    constructor();
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private onChange;
+    private onTouched;
+    writeValue(value: [string, string] | string | null): void;
+    /** Separa prefijo y número local si el valor guardado incluye el código duplicado */
+    private resolveLocalNumber;
+    private applyPrefixSelection;
+    registerOnChange(fn: (value: [string, string] | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onFocus(): void;
+    onBlur(): void;
+    onInput(event: Event): void;
+    onKeyDown(event: KeyboardEvent): void;
+    onPaste(event: ClipboardEvent): void;
+    isValidPhone(value: string): boolean;
+    togglePicker(): void;
+    private buildModalView;
+    private syncModalView;
+    private openModalPortal;
+    private closeModalPortal;
+    private onOverlayDismissedByCoordinator;
+    selectCountry(country: PhoneCountry): void;
+    onSearchChange(e: Event): void;
+    /**
+     * Aplica la búsqueda y reordena los países por relevancia.
+     * @param query Texto de búsqueda.
+     */
+    private applySearch;
+    /**
+     * Calcula el score de relevancia de un país basado en la búsqueda.
+     * @param country País a evaluar.
+     * @param query Query de búsqueda normalizado.
+     * @returns Score de relevancia (mayor = más relevante).
+     */
+    private calculateRelevanceScore;
+    onPrefixFocus(): void;
+    onPrefixBlur(): void;
+    onPrefixInput(e: Event): void;
+    onPrefixKeyDown(e: KeyboardEvent): void;
+    /**
+     * Valida y establece el prefijo personalizado.
+     */
+    private validateAndSetCustomPrefix;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PhoneEntryComponent, "phone-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "defaultCountry": { "alias": "defaultCountry"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/phone-entry/phone-entry.types.d.ts

@@ -0,0 +1,6 @@
+export interface PhoneCountry {
+    img?: string;
+    code: string;
+    prefix: string;
+    name: string;
+}

package/lib/phone-entry/services/phone-entry-modal/phone-entry-modal.service.d.ts

@@ -0,0 +1,24 @@
+import { PhoneCountry } from '../../phone-entry.types';
+import * as i0 from "@angular/core";
+export interface PhoneEntryModalViewModel {
+    searchQuery: string;
+    filteredCountries: PhoneCountry[];
+}
+export interface PhoneEntryModalHandlers {
+    onSearchInput: (e: Event) => void;
+    onBackdropClick: (e: Event) => void;
+    onSelectCountry: (country: PhoneCountry, e: Event) => void;
+}
+export interface PhoneEntryModalSession {
+    view: PhoneEntryModalViewModel;
+    handlers: PhoneEntryModalHandlers;
+}
+export declare class PhoneEntryModalService {
+    private readonly state;
+    readonly state$: import("rxjs").Observable<PhoneEntryModalSession>;
+    open(session: PhoneEntryModalSession): void;
+    patchView(patch: Partial<PhoneEntryModalViewModel>): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PhoneEntryModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PhoneEntryModalService>;
+}

package/lib/price-entry/price-entry.component.d.ts

@@ -0,0 +1,42 @@
+import { OnInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class PriceEntryComponent implements ControlValueAccessor, OnInit {
+    private cdr;
+    private elementRef;
+    label: string;
+    opcional: boolean;
+    description: string;
+    placeholder: string;
+    symbol: string;
+    decimals: number;
+    decimalSeparator: string;
+    thousandSeparator: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    isFocus: boolean;
+    internalValue: string | null;
+    ansInternalValue: string | null;
+    realValue: number | null;
+    repValue: string | null;
+    ngOnInit(): void;
+    private onChange;
+    onTouched: () => void;
+    writeValue(value: number | null | undefined): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private emitValue;
+    handleKeyDown(event: KeyboardEvent): void;
+    private forceCursorToEnd;
+    onFocus(): void;
+    onBlur(): void;
+    private updateView;
+    private formatToInternal;
+    private parseInternalToDecimal;
+    private formatNumber;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PriceEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PriceEntryComponent, "price-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "symbol": { "alias": "symbol"; "required": false; }; "decimals": { "alias": "decimals"; "required": false; }; "decimalSeparator": { "alias": "decimalSeparator"; "required": false; }; "thousandSeparator": { "alias": "thousandSeparator"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/range-entry/range-entry.component.d.ts

@@ -0,0 +1,74 @@
+import { ElementRef, OnInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class RangeEntryComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private platformId;
+    trackWrapper: ElementRef<HTMLDivElement>;
+    trackRef: ElementRef<HTMLDivElement>;
+    label: string;
+    opcional: boolean;
+    description: string;
+    min: number;
+    max: number;
+    gap: number;
+    decimal: boolean;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    minValue: number;
+    maxValue: number;
+    isDisabled: boolean;
+    isDraggingMin: boolean;
+    isDraggingMax: boolean;
+    activeThumb: 'min' | 'max' | null;
+    private documentMouseMoveHandler;
+    private documentMouseUpHandler;
+    private documentTouchMoveHandler;
+    private documentTouchEndHandler;
+    private onChange;
+    private onTouched;
+    writeValue(value: [number, number] | null): void;
+    registerOnChange(fn: (value: [number, number]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    private emit;
+    onMinChange(event: Event): void;
+    onMaxChange(event: Event): void;
+    onSliderRelease(): void;
+    onValueKeydown(event: KeyboardEvent): void;
+    /**
+     * Normaliza un valor según el modo decimal.
+     * - Si decimal es true: redondea a 2 decimales (o formatea enteros con .00)
+     * - Si decimal es false: convierte a entero
+     * @param value - Valor a normalizar
+     * @returns Valor normalizado
+     */
+    private normalizeValue;
+    /**
+     * Retorna el step según el modo decimal.
+     * - decimal true: 0.01 (2 decimales)
+     * - decimal false: 1 (enteros)
+     */
+    get step(): number;
+    get leftPercent(): number;
+    get rightPercent(): number;
+    get rangeStyle(): {
+        [key: string]: string;
+    };
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onThumbMouseDown(thumb: 'min' | 'max', event: MouseEvent): void;
+    onThumbTouchStart(thumb: 'min' | 'max', event: TouchEvent): void;
+    onTrackClick(event: MouseEvent): void;
+    onTrackTouchStart(event: TouchEvent): void;
+    private handleDocumentMouseMove;
+    private handleDocumentMouseUp;
+    private handleDocumentTouchMove;
+    private handleDocumentTouchEnd;
+    private touchToMouseEvent;
+    private updateValueFromEvent;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangeEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RangeEntryComponent, "range-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "gap": { "alias": "gap"; "required": false; }; "decimal": { "alias": "decimal"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/rating-entry/rating-entry.component.d.ts

@@ -0,0 +1,25 @@
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class RatingEntryComponent implements ControlValueAccessor {
+    private cdr;
+    private elementRef;
+    label: string;
+    opcional: boolean;
+    description: string;
+    maxStars: number;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    value: number | null;
+    isDisabled: boolean;
+    get stars(): number[];
+    private onChange;
+    private onTouched;
+    writeValue(value: number | null): void;
+    registerOnChange(fn: (value: number | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    select(value: number): void;
+    manualClick(event?: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RatingEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RatingEntryComponent, "rating-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "maxStars": { "alias": "maxStars"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/rich-text-entry/caludy-image.node.d.ts

@@ -0,0 +1,36 @@
+import type { DOMConversionMap, DOMExportOutput, LexicalNode, NodeKey, SerializedLexicalNode } from 'lexical';
+import { DecoratorNode } from 'lexical';
+export type CaludyImagePayload = Readonly<{
+    src: string;
+    altText?: string;
+    width?: number;
+    height?: number;
+}>;
+export type SerializedCaludyImageNode = SerializedLexicalNode & {
+    type: 'caludy-image';
+    version: 1;
+    src: string;
+    altText: string;
+    width?: number;
+    height?: number;
+};
+export declare class CaludyImageNode extends DecoratorNode<null> {
+    __src: string;
+    __altText: string;
+    __width?: number;
+    __height?: number;
+    static getType(): string;
+    static clone(node: CaludyImageNode): CaludyImageNode;
+    constructor(payload: CaludyImagePayload, key?: NodeKey);
+    createDOM(): HTMLElement;
+    updateDOM(prevNode: CaludyImageNode, dom: HTMLElement): boolean;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    exportJSON(): SerializedCaludyImageNode;
+    static importJSON(serialized: SerializedCaludyImageNode): CaludyImageNode;
+    isInline(): boolean;
+    decorate(): null;
+    setDimensions(width?: number, height?: number): void;
+}
+export declare function $createCaludyImageNode(payload: CaludyImagePayload): CaludyImageNode;
+export declare function $isCaludyImageNode(node: LexicalNode | null | undefined): boolean;

package/lib/rich-text-entry/lexical-editor-theme.d.ts

@@ -0,0 +1,3 @@
+import type { EditorThemeClasses } from 'lexical';
+/** Theme compartido: clases estables para estilar nodos generados por Lexical. */
+export declare const RICH_TEXT_LEXICAL_THEME: EditorThemeClasses;

package/lib/rich-text-entry/rich-text-entry.component.d.ts

@@ -0,0 +1,92 @@
+import { OnInit, OnDestroy, ElementRef, AfterViewInit } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class RichTextEntryComponent implements ControlValueAccessor, OnInit, AfterViewInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private platformId;
+    label: string;
+    opcional: boolean;
+    description: string;
+    placeholder: string;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    /** Solo true en el navegador; en SSR no se instancia el editor. */
+    readonly isBrowser: boolean;
+    contentEditable?: ElementRef<HTMLElement>;
+    imageInput?: ElementRef<HTMLInputElement>;
+    imageOverlay?: ElementRef<HTMLElement>;
+    tableOverlay?: ElementRef<HTMLElement>;
+    private editor;
+    private lastEmittedHtml;
+    private pendingHtmlWrite;
+    private lastIncomingWriteHtml;
+    showPlaceholder: boolean;
+    isDisabled: boolean;
+    canUndo: boolean;
+    canRedo: boolean;
+    isBold: boolean;
+    isItalic: boolean;
+    isUnderline: boolean;
+    isStrikethrough: boolean;
+    isAlignLeft: boolean;
+    isAlignCenter: boolean;
+    isAlignRight: boolean;
+    isAlignJustify: boolean;
+    isH1: boolean;
+    isLink: boolean;
+    isOnImage: boolean;
+    isInTable: boolean;
+    imageOverlayVisible: boolean;
+    imageOverlayTop: number;
+    imageOverlayLeft: number;
+    imageOverlayKey: string | null;
+    private imageResizeActive;
+    private imageResizeStartX;
+    private imageResizeStartW;
+    private imageResizeStartH;
+    private imageResizeAspect;
+    tableOverlayVisible: boolean;
+    tableOverlayTop: number;
+    tableOverlayLeft: number;
+    tableOverlayMaxHeight: number;
+    private tableOverlayAnchorX;
+    private tableOverlayAnchorY;
+    private lastTableRect;
+    private onChange;
+    private onTouched;
+    private imageResizeCleanup;
+    private overlayCleanup;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onEditorBlur(event: FocusEvent): void;
+    onToolbarMouseDown(event: MouseEvent): void;
+    onInput(): void;
+    manualClick(event?: MouseEvent): void;
+    private applyEditorInteractionStyles;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(disabled: boolean): void;
+    exec(action: 'undo' | 'redo' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'h1' | 'link' | 'image' | 'table' | 'image-move-up' | 'image-move-down' | 'table-row-after' | 'table-row-before' | 'table-col-after' | 'table-col-before' | 'table-row-delete' | 'table-col-delete' | 'table-delete' | 'ol' | 'ul' | 'align-left' | 'align-center' | 'align-right' | 'align-justify'): void;
+    private moveSelectedImage;
+    private setupImageResizeHandles;
+    private setupOverlays;
+    onImageResizeStart(event: PointerEvent): void;
+    private hideImageOverlay;
+    private hideTableOverlay;
+    private toggleLink;
+    private pickImage;
+    onImageSelected(event: Event): Promise<void>;
+    private compressAndResizeImageToDataUrl;
+    private readImageBitmap;
+    private blobToDataUrl;
+    private toggleH1;
+    private setEditorHtml;
+    private emitChangeFromEditor;
+    private updatePlaceholderFlag;
+    private updateToolbarState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RichTextEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RichTextEntryComponent, "rich-text-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/search-entry/search-entry.component.d.ts

@@ -0,0 +1,65 @@
+import { ChangeDetectorRef, OnInit, OnChanges, OnDestroy, SimpleChanges, ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { Router } from '@angular/router';
+import { HttpClient } from '@angular/common/http';
+import { SearchOption } from './search-entry.types';
+import * as i0 from "@angular/core";
+export type { SearchOption } from './search-entry.types';
+export declare class SearchEntryComponent implements ControlValueAccessor, OnInit, OnChanges, OnDestroy {
+    private http;
+    private elementRef;
+    private cdr;
+    private router;
+    private readonly inputsConfig;
+    label: string;
+    placeholder: string;
+    opcional: boolean;
+    options: SearchOption[];
+    api?: string;
+    search: boolean;
+    minSearch: number;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isOpen: boolean;
+    isFocus: boolean;
+    isDisabled: boolean;
+    filteredOptions: SearchOption[];
+    internalOptions: SearchOption[];
+    searchText: string;
+    loading: boolean;
+    error: boolean;
+    private pendingValue;
+    private isExternalUpdate;
+    private search$;
+    private sub?;
+    private searchEntryModal;
+    private inputOverlayCoordinator;
+    private readonly overlayToken;
+    constructor(http: HttpClient, elementRef: ElementRef, cdr: ChangeDetectorRef, router: Router);
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private buildModalView;
+    private syncModalView;
+    private openModalPortal;
+    private closeModalPortal;
+    private onOverlayDismissedByCoordinator;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    onSearchChange(e: Event): void;
+    private filterLocalOptions;
+    private fetchFromApi;
+    private loadLocalOptions;
+    toggleOpenOptions(e: Event): void;
+    clear(): void;
+    focus(): void;
+    blur(): void;
+    shouldShowSearchInput(): boolean;
+    onChange: (value: string | null) => void;
+    onTouched: () => void;
+    onEnter(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SearchEntryComponent, "search-entry", never, { "label": { "alias": "label"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "options": { "alias": "options"; "required": false; }; "api": { "alias": "api"; "required": false; }; "search": { "alias": "search"; "required": false; }; "minSearch": { "alias": "minSearch"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}

package/lib/search-entry/search-entry.types.d.ts

@@ -0,0 +1,8 @@
+export interface SearchOption {
+    image?: string;
+    color?: string;
+    to: string;
+    name: string;
+    description?: string;
+    param?: string;
+}

package/lib/search-entry/services/search-entry-modal/search-entry-modal.service.d.ts

@@ -0,0 +1,29 @@
+import { SearchOption } from '../../search-entry.types';
+import * as i0 from "@angular/core";
+export interface SearchEntryModalViewModel {
+    searchText: string;
+    placeholder: string;
+    filteredOptions: SearchOption[];
+    loading: boolean;
+    error: boolean;
+    shouldShowSearch: boolean;
+}
+export interface SearchEntryModalHandlers {
+    onSearchInput: (e: Event) => void;
+    onBackdropClick: (e: Event) => void;
+    onCloseIconClick: (e: Event) => void;
+    onResultNavigate: () => void;
+}
+export interface SearchEntryModalSession {
+    view: SearchEntryModalViewModel;
+    handlers: SearchEntryModalHandlers;
+}
+export declare class SearchEntryModalService {
+    private readonly state;
+    readonly state$: import("rxjs").Observable<SearchEntryModalSession>;
+    open(session: SearchEntryModalSession): void;
+    patchView(patch: Partial<SearchEntryModalViewModel>): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchEntryModalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SearchEntryModalService>;
+}

package/lib/signature-entry/signature-entry.component.d.ts

@@ -0,0 +1,47 @@
+import { ElementRef, AfterViewInit, OnDestroy } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i0 from "@angular/core";
+export declare class SignatureEntryComponent implements ControlValueAccessor, AfterViewInit, OnDestroy {
+    private cdr;
+    private elementRef;
+    private platformId;
+    label: string;
+    opcional: boolean;
+    description: string;
+    clearText: string;
+    quality: number;
+    exportWidth: number;
+    get hostDisabledClass(): boolean;
+    set disabled(value: boolean);
+    isDisabled: boolean;
+    canvasRef: ElementRef<HTMLCanvasElement>;
+    private ctx;
+    private drawing;
+    private dpr;
+    private lastPos;
+    private lastTimestamp;
+    private onChange;
+    private onTouched;
+    private listeners;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private initCanvas;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string | null) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    private emitValue;
+    /**
+     * Comprime y redimensiona la imagen del canvas y emite el valor base64.
+     * El canvas se mantiene en alta calidad para dibujar.
+     * Al exportar: redimensiona a exportWidth de ancho (manteniendo relación de aspecto) y aplica compresión JPEG.
+     * Captura TODO el contenido del canvas original sin recortar.
+     */
+    private compressAndEmit;
+    /** Solo vista: usado por `writeValue(null)` sin notificar al modelo (el `FormControl` ya está vacío). */
+    private paintBlankCanvas;
+    clearCanvas(): void;
+    private registerEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SignatureEntryComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SignatureEntryComponent, "signature-entry", never, { "label": { "alias": "label"; "required": false; }; "opcional": { "alias": "opcional"; "required": false; }; "description": { "alias": "description"; "required": false; }; "clearText": { "alias": "clearText"; "required": false; }; "quality": { "alias": "quality"; "required": false; }; "exportWidth": { "alias": "exportWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, never, true, never>;
+}