@caribeng/ui 22.4.0 → 22.6.0

package/types/caribeng-ui-image-cropper.d.ts

@@ -0,0 +1,169 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+
+/** Recuadro de recorte en fracciones de la imagen (0–1). */
+interface CbCropRect {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** Opciones de la imagen recortada. */
+interface CbCropOutput {
+    /** `image/png` (por defecto, o el tipo de la original si es JPEG), `image/jpeg` o `image/webp`. */
+    readonly type?: 'image/png' | 'image/jpeg' | 'image/webp';
+    /** Calidad de JPEG y WebP (0–1). */
+    readonly quality?: number;
+    /** Tamaño máximo en píxeles: el recorte se reduce (nunca se amplía) para no pasar de él. */
+    readonly maxWidth?: number;
+    readonly maxHeight?: number;
+    /** Recorte circular (PNG con fondo transparente), p. ej. para fotos de perfil. */
+    readonly circle?: boolean;
+}
+/** Mantiene el recuadro dentro de la imagen y con un tamaño mínimo. */
+declare function clampRect(rect: CbCropRect): CbCropRect;
+/**
+ * Ajusta el recuadro a una proporción (ancho / alto en píxeles), lo más grande
+ * posible dentro del actual y centrado en él. `ratio` null = libre.
+ */
+declare function fitRatio(rect: CbCropRect, ratio: number | null, imageWidth: number, imageHeight: number): CbCropRect;
+/** Recuadro inicial: el mayor posible con la proporción, centrado. */
+declare function initialRect(ratio: number | null, imageWidth: number, imageHeight: number): CbCropRect;
+/**
+ * Redimensiona arrastrando una esquina (`nw`, `ne`, `sw`, `se`) un desplazamiento
+ * (dx, dy) en fracciones; con proporción, el alto sigue al ancho.
+ */
+declare function resizeRect(rect: CbCropRect, corner: 'nw' | 'ne' | 'sw' | 'se', dx: number, dy: number, ratio: number | null, imageWidth: number, imageHeight: number): CbCropRect;
+/** Tamaño en píxeles del recorte, reducido para no pasar de `maxWidth` × `maxHeight`. */
+declare function outputSize(rect: CbCropRect, imageWidth: number, imageHeight: number, output?: CbCropOutput): {
+    w: number;
+    h: number;
+};
+/**
+ * Estilo de una vista previa del recorte hecha con CSS (sin canvas): la imagen como fondo,
+ * ampliada y desplazada para que solo se vea el recuadro.
+ */
+declare function previewStyle(src: string, rect: CbCropRect): Record<string, string>;
+/**
+ * Recorta los píxeles de la imagen. Las imágenes de otro dominio necesitan que
+ * su servidor permita CORS; si no, el navegador bloquea la lectura y se rechaza.
+ */
+declare function cropImage(src: string, rect: CbCropRect, doc: Document, output?: CbCropOutput): Promise<Blob>;
+/** Gira la imagen un cuarto de vuelta (`1` a la derecha, `-1` a la izquierda) y la devuelve como data URL PNG. */
+declare function rotateImage(src: string, turns: 1 | -1, doc: Document): Promise<string>;
+/** Lee un archivo como data URL. */
+declare function readFileAsDataUrl(file: Blob): Promise<string>;
+
+/** Proporción que se ofrece en la barra (`value` null = libre). */
+interface CbCropRatio {
+    readonly label: string;
+    readonly value: number | null;
+}
+/** Resultado del recorte. */
+interface CbCropResult {
+    readonly blob: Blob;
+    readonly dataUrl: string;
+    readonly rect: CbCropRect;
+    readonly width: number;
+    readonly height: number;
+}
+type Corner = 'nw' | 'ne' | 'sw' | 'se';
+/**
+ * Recortador de imagen de CaribeNG: recuadro que se mueve y redimensiona con ratón, dedo o
+ * teclado, proporciones fijas o libre, forma circular para fotos de perfil, giro, vista previa
+ * y selección de archivo (botón o arrastrar). Devuelve el recorte como `Blob` y data URL.
+ *
+ * @example
+ * ```html
+ * <cb-image-cropper [src]="foto" shape="circle" preview (cropped)="guardar($event.blob)" />
+ * ```
+ */
+declare class CbImageCropper {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    private readonly document;
+    private readonly injector;
+    private readonly destroyRef;
+    protected readonly helpId: string;
+    /** Imagen a recortar (URL o data URL). Las de otro dominio necesitan CORS para poder recortarse. */
+    readonly src: _angular_core.InputSignal<string>;
+    /** Recuadro en fracciones de la imagen (0–1). Se inicia al cargar la imagen si no se indica. */
+    readonly rect: _angular_core.ModelSignal<CbCropRect | null>;
+    /** Proporción ancho / alto (`null` = libre). Con `shape="circle"` siempre es 1. */
+    readonly ratio: _angular_core.ModelSignal<number | null>;
+    /** Proporciones de la barra (vacío para ocultarla). */
+    readonly ratios: _angular_core.InputSignal<readonly CbCropRatio[]>;
+    /** Recorte rectangular o circular (PNG con fondo transparente, para fotos de perfil). */
+    readonly shape: _angular_core.InputSignal<"rect" | "circle">;
+    /** Formato, calidad y tamaño máximo del recorte. */
+    readonly output: _angular_core.InputSignal<CbCropOutput>;
+    /** Botones de girar 90°. */
+    readonly rotatable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Vista previa del recorte. */
+    readonly preview: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Botón para elegir otra imagen (y arrastrar archivos al área vacía). */
+    readonly chooser: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Botón Recortar (sin él, recorta llamando a `crop()`). */
+    readonly showApply: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly accept: _angular_core.InputSignal<string>;
+    /** Alto máximo de la imagen en pantalla. */
+    readonly maxHeight: _angular_core.InputSignal<string>;
+    readonly emptyMessage: _angular_core.InputSignal<string | undefined>;
+    /** Recorte hecho con el botón Recortar o Enter. */
+    readonly cropped: _angular_core.OutputEmitterRef<CbCropResult>;
+    /** Imagen elegida por el usuario (archivo). */
+    readonly fileSelect: _angular_core.OutputEmitterRef<File>;
+    /** No se pudo cargar o recortar la imagen. */
+    readonly cropError: _angular_core.OutputEmitterRef<unknown>;
+    protected readonly corners: readonly Corner[];
+    /** Imagen en pantalla: `src`, el archivo elegido o la imagen girada. */
+    protected readonly displaySrc: _angular_core.WritableSignal<string>;
+    protected readonly natural: _angular_core.WritableSignal<{
+        w: number;
+        h: number;
+    } | null>;
+    protected readonly busy: _angular_core.WritableSignal<boolean>;
+    protected readonly error: _angular_core.WritableSignal<string>;
+    protected readonly dragOver: _angular_core.WritableSignal<boolean>;
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    private readonly effRatio;
+    /** El recuadro vigente (`rect` es null hasta que carga la imagen). */
+    protected readonly current: _angular_core.Signal<CbCropRect>;
+    protected readonly valueText: _angular_core.Signal<string>;
+    protected readonly previewCss: _angular_core.Signal<{
+        'aspect-ratio': string;
+    }>;
+    private readonly stage;
+    private readonly box;
+    private readonly fileInput;
+    constructor();
+    /** Recorta y devuelve el resultado (sin emitir `cropped`). */
+    crop(): Promise<CbCropResult>;
+    /** Abre el selector de archivos. */
+    choose(): void;
+    /** Proporción fija (ancho / alto) o libre (`null`). */
+    setRatio(ratio: number | null): void;
+    protected onLoad(event: Event): void;
+    protected onImageError(): void;
+    protected apply(): Promise<void>;
+    protected rotate(turns: 1 | -1): Promise<void>;
+    protected onFile(event: Event): Promise<void>;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): Promise<void>;
+    /** Mueve (`corner` null) o redimensiona el recuadro arrastrando. */
+    protected startDrag(event: PointerEvent, corner: Corner | null): void;
+    /** Flechas: mover (2 %, 10 % con Ctrl); Mayús + flechas: tamaño desde la esquina inferior derecha; Enter: recortar. */
+    protected onKeydown(event: KeyboardEvent): void;
+    private load;
+    private useFile;
+    /** El recuadro aparece cuando carga la imagen: entonces recibe el foco. */
+    private focusWhenReady;
+    /** Un espacio duro alterno hace que el mismo texto cuente como cambio y se vuelva a anunciar. */
+    private announce;
+    private announceFlip;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbImageCropper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbImageCropper, "cb-image-cropper", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "rect": { "alias": "rect"; "required": false; "isSignal": true; }; "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; "ratios": { "alias": "ratios"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "output": { "alias": "output"; "required": false; "isSignal": true; }; "rotatable": { "alias": "rotatable"; "required": false; "isSignal": true; }; "preview": { "alias": "preview"; "required": false; "isSignal": true; }; "chooser": { "alias": "chooser"; "required": false; "isSignal": true; }; "showApply": { "alias": "showApply"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; }, { "rect": "rectChange"; "ratio": "ratioChange"; "cropped": "cropped"; "fileSelect": "fileSelect"; "cropError": "cropError"; }, never, never, true, never>;
+}
+
+export { CbImageCropper, clampRect, cropImage, fitRatio, initialRect, outputSize, previewStyle, readFileAsDataUrl, resizeRect, rotateImage };
+export type { CbCropOutput, CbCropRatio, CbCropRect, CbCropResult };
+//# sourceMappingURL=caribeng-ui-image-cropper.d.ts.map

package/types/caribeng-ui-import-wizard.d.ts

@@ -0,0 +1,149 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat } from '@caribeng/ui';
+import { CbDataGridColumn } from '@caribeng/ui/datagrid';
+import { CbXlsxReadSheet } from '@caribeng/ui/xlsx';
+
+/** Tipo de un campo a importar (cómo se interpreta el texto). */
+type CbImportFieldType = 'text' | 'number' | 'date' | 'boolean';
+/** Campo de destino de la importación. */
+interface CbImportField {
+    readonly key: string;
+    readonly label: string;
+    readonly type?: CbImportFieldType;
+    readonly required?: boolean;
+    /** Otros nombres de columna con los que se asigna solo (p. ej. `['nit', 'documento']`). */
+    readonly aliases?: readonly string[];
+    /** Validación propia: mensaje de error o `null`. */
+    readonly validate?: (value: unknown, row: Record<string, unknown>) => string | null;
+}
+/** Error de una celda importada. */
+interface CbImportError {
+    /** Fila de datos (1 = la primera después del encabezado). */
+    readonly row: number;
+    readonly field: string;
+    readonly message: string;
+}
+/** Resultado de la importación. */
+interface CbImportResult<T = Record<string, unknown>> {
+    readonly rows: T[];
+    readonly errors: CbImportError[];
+    /** Filas descartadas por tener errores. */
+    readonly skipped: number;
+}
+type CbImportCell = string | number | boolean | null;
+interface ImportTexts {
+    readonly required: string;
+    readonly number: string;
+    readonly date: string;
+    readonly boolean: string;
+}
+/** Separador más probable de un texto delimitado (tabulador, punto y coma o coma). */
+declare function detectDelimiter(text: string): string;
+/** CSV / TSV a filas (comillas dobles, saltos de línea dentro de comillas, BOM). */
+declare function parseDelimited(text: string, delimiter?: string): string[][];
+/**
+ * Importe a partir de texto: `$ 1.234,56`, `1,234.56`, `(1.234)` (negativo),
+ * `-1234`, `1.234.567`. Con un solo separador repetido, o seguido de 3 cifras,
+ * se toma como de miles.
+ */
+declare function parseAmount(value: CbImportCell): number | null | undefined;
+/** Fecha a partir de texto (`AAAA-MM-DD`, `DD/MM/AAAA`, `DD-MM-AAAA`) o de un número de serie de Excel. */
+declare function parseDate(value: CbImportCell): Date | null | undefined;
+declare function parseBoolean(value: CbImportCell): boolean | null | undefined;
+/** Asigna cada campo a la columna cuyo encabezado coincide con su clave, etiqueta o alias. */
+declare function autoMap(headers: readonly string[], fields: readonly CbImportField[]): Record<string, number | null>;
+/** Convierte las filas con la asignación de columnas: valores con tipo y errores por celda. */
+declare function convertRows(rows: readonly (readonly CbImportCell[])[], mapping: Readonly<Record<string, number | null>>, fields: readonly CbImportField[], texts: ImportTexts): {
+    rows: Record<string, unknown>[];
+    errors: CbImportError[];
+};
+
+type Step = 'file' | 'map' | 'review';
+/**
+ * Asistente de importación de CaribeNG: archivo (CSV, TSV, Excel o datos pegados),
+ * asignación de columnas y revisión con validación fila a fila antes de importar.
+ *
+ * - Lee .xlsx en el navegador (varias hojas), CSV con `,` o `;` y lo copiado de una hoja de cálculo.
+ * - Asigna sola cada columna cuyo encabezado coincide con el campo (o sus `aliases`).
+ * - Interpreta importes (`$ 1.234,56`, `(1.234)`), fechas (`DD/MM/AAAA`, serie de Excel)
+ *   y casillas (Sí / No); marca cada celda con error y deja importar solo las filas válidas.
+ *
+ * @example
+ * ```html
+ * <cb-import-wizard [fields]="campos" (import)="guardar($event.rows)" />
+ * ```
+ */
+declare class CbImportWizard {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly fmt: typeof cbFormat;
+    protected readonly uid: string;
+    protected readonly steps: Step[];
+    protected readonly accept = ".csv,.tsv,.txt,.xlsx,text/csv,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    /** Campos de destino (clave, etiqueta, tipo, obligatorio, alias y validación). */
+    readonly fields: _angular_core.InputSignal<readonly CbImportField[]>;
+    /** Importa también las filas con errores (marcadas en `errors`). */
+    readonly allowInvalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Filas importadas (con tipo) y errores encontrados. */
+    readonly import: _angular_core.OutputEmitterRef<CbImportResult<Record<string, unknown>>>;
+    protected readonly step: _angular_core.WritableSignal<Step>;
+    protected readonly stepIndex: _angular_core.Signal<number>;
+    protected readonly dragging: _angular_core.WritableSignal<boolean>;
+    protected readonly pasteOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly fileName: _angular_core.WritableSignal<string>;
+    protected readonly error: _angular_core.WritableSignal<string>;
+    protected readonly sheets: _angular_core.WritableSignal<CbXlsxReadSheet[]>;
+    protected readonly sheetIndex: _angular_core.WritableSignal<number>;
+    private readonly text;
+    protected readonly hasHeader: _angular_core.WritableSignal<boolean>;
+    protected readonly mapping: _angular_core.WritableSignal<Record<string, number | null>>;
+    protected readonly onlyValid: _angular_core.WritableSignal<boolean>;
+    /** Filas leídas (de la hoja elegida o del texto). */
+    protected readonly raw: _angular_core.Signal<CbImportCell[][]>;
+    protected readonly headers: _angular_core.Signal<string[]>;
+    protected readonly dataRows: _angular_core.Signal<CbImportCell[][]>;
+    protected readonly sheetOptions: _angular_core.Signal<{
+        label: string;
+        value: number;
+    }[]>;
+    protected readonly columnOptions: _angular_core.Signal<{
+        label: string;
+        value: number;
+    }[]>;
+    protected readonly missing: _angular_core.Signal<string[]>;
+    private readonly texts;
+    private readonly converted;
+    protected readonly invalidRows: _angular_core.Signal<Set<number>>;
+    protected readonly validCount: _angular_core.Signal<number>;
+    private readonly errorIndex;
+    protected readonly previewRows: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly previewColumns: _angular_core.Signal<CbDataGridColumn<Record<string, unknown>>[]>;
+    protected readonly importable: _angular_core.Signal<number>;
+    protected stepLabel(step: Step): string;
+    protected columnName(i: number): string;
+    protected example(key: string): string;
+    private plain;
+    protected onDrop(event: DragEvent): void;
+    protected onFile(event: Event): void;
+    protected onPaste(event: Event): void;
+    /** Carga un archivo (.xlsx, .csv, .tsv, .txt). */
+    load(file: File): Promise<void>;
+    /** Carga texto delimitado (CSV, TSV o lo pegado de una hoja de cálculo). */
+    loadText(text: string): void;
+    protected setHeader(value: boolean): void;
+    protected setMapping(key: string, column: number): void;
+    private remap;
+    protected canNext(): boolean;
+    protected next(): void;
+    protected back(): void;
+    protected finish(): void;
+    /** Vuelve al primer paso sin datos. */
+    reset(): void;
+    private focusHeading;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbImportWizard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbImportWizard, "cb-import-wizard", never, { "fields": { "alias": "fields"; "required": false; "isSignal": true; }; "allowInvalid": { "alias": "allowInvalid"; "required": false; "isSignal": true; }; }, { "import": "import"; }, never, never, true, never>;
+}
+
+export { CbImportWizard, autoMap, convertRows, detectDelimiter, parseAmount, parseBoolean, parseDate, parseDelimited };
+export type { CbImportError, CbImportField, CbImportFieldType, CbImportResult };
+//# sourceMappingURL=caribeng-ui-import-wizard.d.ts.map

package/types/caribeng-ui-infinite-scroll.d.ts

@@ -0,0 +1,75 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+
+/** `auto`: carga al llegar al final; `button`: solo con el botón "Cargar más". */
+type CbInfiniteScrollMode = 'auto' | 'button';
+/** Quién pidió la carga. */
+type CbLoadMoreSource = 'scroll' | 'button' | 'retry';
+/**
+ * Scroll infinito de CaribeNG: envuelve una lista y pide más elementos (`loadMore`) al acercarse
+ * al final, con un botón "Cargar más" como alternativa. Tras `autoLimit` cargas automáticas pasa
+ * al botón, para que el pie de página siga siendo alcanzable; anuncia las cargas y, al cargar con
+ * el botón, lleva el foco al primer elemento nuevo.
+ *
+ * @example
+ * ```html
+ * <cb-infinite-scroll [loading]="cargando()" [hasMore]="hayMas()" [count]="items().length" (loadMore)="cargar()">
+ *   <ul>@for (i of items(); track i.id) { <li>{{ i.nombre }}</li> }</ul>
+ * </cb-infinite-scroll>
+ * ```
+ */
+declare class CbInfiniteScroll {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    private readonly host;
+    private readonly injector;
+    /** Hay una carga en curso (muestra el indicador y evita pedir otra). */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Quedan elementos por cargar. */
+    readonly hasMore: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** La última carga falló: muestra el aviso y "Reintentar". */
+    readonly error: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Número de elementos ya cargados: para anunciar cuántos llegaron y enfocar el primero nuevo. */
+    readonly count: _angular_core.InputSignal<number | undefined>;
+    /** Carga automática al llegar al final o solo con el botón. */
+    readonly mode: _angular_core.InputSignal<CbInfiniteScrollMode>;
+    /** Cargas automáticas seguidas antes de pasar al botón (0 = sin límite). */
+    readonly autoLimit: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Distancia al final a la que se empieza a cargar (margen del IntersectionObserver). */
+    readonly threshold: _angular_core.InputSignal<string>;
+    /** El propio componente hace scroll, con este alto máximo (si no, se usa la página). */
+    readonly scrollable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly height: _angular_core.InputSignal<string>;
+    /** Elementos de la lista, para llevar el foco al primero nuevo tras "Cargar más". */
+    readonly itemSelector: _angular_core.InputSignal<string>;
+    /** Mensaje al llegar al final (con `showEnd`). */
+    readonly showEnd: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly endMessage: _angular_core.InputSignal<string | undefined>;
+    readonly errorMessage: _angular_core.InputSignal<string | undefined>;
+    readonly loadMoreLabel: _angular_core.InputSignal<string | undefined>;
+    /** Pide la siguiente página. */
+    readonly loadMore: _angular_core.OutputEmitterRef<CbLoadMoreSource>;
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    /** Cargas automáticas desde la última con el botón. */
+    private readonly autoCount;
+    protected readonly showButton: _angular_core.Signal<boolean>;
+    private readonly sentinel;
+    private readonly observerSupported;
+    /** Cuántos había al pedir la carga y si la pidió el botón (para el anuncio y el foco). */
+    private pending;
+    private visible;
+    constructor();
+    /** Vuelve a permitir cargas automáticas (p. ej. al cambiar un filtro y reiniciar la lista). */
+    reset(): void;
+    protected request(source: CbLoadMoreSource): void;
+    private tryAuto;
+    private focusItem;
+    /** Un espacio duro alterno hace que el mismo texto cuente como cambio y se vuelva a anunciar. */
+    private announce;
+    private announceFlip;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbInfiniteScroll, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbInfiniteScroll, "cb-infinite-scroll", never, { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "hasMore": { "alias": "hasMore"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "autoLimit": { "alias": "autoLimit"; "required": false; "isSignal": true; }; "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "scrollable": { "alias": "scrollable"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "itemSelector": { "alias": "itemSelector"; "required": false; "isSignal": true; }; "showEnd": { "alias": "showEnd"; "required": false; "isSignal": true; }; "endMessage": { "alias": "endMessage"; "required": false; "isSignal": true; }; "errorMessage": { "alias": "errorMessage"; "required": false; "isSignal": true; }; "loadMoreLabel": { "alias": "loadMoreLabel"; "required": false; "isSignal": true; }; }, { "loadMore": "loadMore"; }, never, ["*"], true, never>;
+}
+
+export { CbInfiniteScroll };
+export type { CbInfiniteScrollMode, CbLoadMoreSource };
+//# sourceMappingURL=caribeng-ui-infinite-scroll.d.ts.map

package/types/caribeng-ui-input-number.d.ts

@@ -77,7 +77,7 @@ declare class CbInputNumber implements ControlValueAccessor {
     registerOnChange(fn: (value: number | null) => void): void;
     registerOnTouched(fn: () => void): void;
     setDisabledState(isDisabled: boolean): void;
-    protected onFocus(): void;
+    protected onFocus(event: FocusEvent): void;
     protected onInput(event: Event): void;
     protected onBlur(): void;
     protected onKeydown(event: KeyboardEvent): void;

package/types/{caribeng-ui-caribe-input-search.d.ts → caribeng-ui-input-search.d.ts}

@@ -3,7 +3,7 @@ import * as _caribeng_ui from '@caribeng/ui';
 import { ControlValueAccessor } from '@angular/forms';
 
 /**
- * Input-search de Caribe Design: campo de búsqueda con icono, botón de limpiar
+ * Input-search: campo de búsqueda con icono, botón de limpiar
  * e integración con Angular Forms (CVA).
  *
  * @example
@@ -37,4 +37,4 @@ declare class CbInputSearch implements ControlValueAccessor {
 }
 
 export { CbInputSearch };
-//# sourceMappingURL=caribeng-ui-caribe-input-search.d.ts.map
+//# sourceMappingURL=caribeng-ui-input-search.d.ts.map

package/types/{caribeng-ui-caribe-input-token.d.ts → caribeng-ui-input-token.d.ts}

@@ -4,7 +4,7 @@ import { cbFormat } from '@caribeng/ui';
 import { ControlValueAccessor } from '@angular/forms';
 
 /**
- * Input-token de Caribe Design: entrada de código OTP con casillas por dígito,
+ * Input-token: entrada de código OTP con casillas por dígito,
  * enmascarado opcional y CVA.
  *
  * @example
@@ -51,4 +51,4 @@ declare class CbInputToken implements ControlValueAccessor {
 }
 
 export { CbInputToken };
-//# sourceMappingURL=caribeng-ui-caribe-input-token.d.ts.map
+//# sourceMappingURL=caribeng-ui-input-token.d.ts.map

package/types/caribeng-ui-journal-entry.d.ts

@@ -0,0 +1,110 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat } from '@caribeng/ui';
+import { CbAccount } from '@caribeng/ui/account-picker';
+import { CbDataGridColumn } from '@caribeng/ui/datagrid';
+
+/** Línea (movimiento) de un comprobante. */
+interface CbJournalLine {
+    readonly id: string | number;
+    /** Código de la cuenta. */
+    readonly account: string | null;
+    readonly thirdParty?: unknown;
+    readonly costCenter?: unknown;
+    /** Detalle de la línea (si queda vacío, al guardar toma la descripción del comprobante). */
+    readonly description?: string | null;
+    readonly debit: number | null;
+    readonly credit: number | null;
+}
+/** Comprobante contable (asiento). */
+interface CbJournalEntryData {
+    readonly date: Date | null;
+    /** Tipo de comprobante (`CE` egreso, `RC` recibo de caja…). */
+    readonly type?: unknown;
+    readonly number?: string | null;
+    readonly description?: string | null;
+    readonly lines: readonly CbJournalLine[];
+}
+/** Opción de tercero, centro de costo o tipo de comprobante. */
+interface CbJournalOption {
+    readonly label: string;
+    readonly value: unknown;
+    readonly description?: string;
+}
+/** Comprobante vacío con dos líneas. */
+declare function cbEmptyJournalEntry(date?: Date | null): CbJournalEntryData;
+/**
+ * Editor de comprobante contable de CaribeNG: cabecera (fecha, tipo, número y
+ * descripción) y líneas con cuenta, tercero, centro de costo, detalle, débito y
+ * crédito, editables como una hoja de cálculo.
+ *
+ * - La cuenta se busca por código o nombre en el plan de cuentas y solo admite
+ *   cuentas de movimiento; escribir el débito borra el crédito de la línea y al revés.
+ * - Totales de débitos y créditos con la diferencia en vivo; «Cuadrar» pone la
+ *   diferencia en la última línea vacía (o en una nueva).
+ * - Guardar (o Ctrl + Enter) valida fecha, líneas, cuentas y que cuadre, y emite `save`.
+ *
+ * @example
+ * ```html
+ * <cb-journal-entry [(entry)]="comprobante" [accounts]="puc" [thirdParties]="terceros" (save)="guardar($event)" />
+ * ```
+ */
+declare class CbJournalEntry {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly fmt: typeof cbFormat;
+    private readonly amount;
+    protected readonly uid: string;
+    private readonly grid;
+    /** Comprobante (bidireccional). */
+    readonly entry: _angular_core.ModelSignal<CbJournalEntryData>;
+    /** Plan de cuentas: solo se eligen cuentas de movimiento. */
+    readonly accounts: _angular_core.InputSignal<readonly CbAccount[]>;
+    /** Terceros (sin ellos no se muestra la columna). */
+    readonly thirdParties: _angular_core.InputSignal<readonly CbJournalOption[]>;
+    /** Centros de costo (sin ellos no se muestra la columna). */
+    readonly costCenters: _angular_core.InputSignal<readonly CbJournalOption[]>;
+    /** Tipos de comprobante (sin ellos no se muestra el campo). */
+    readonly types: _angular_core.InputSignal<readonly CbJournalOption[]>;
+    /** Cuentas que exigen tercero (por prefijo de código, p. ej. `['13', '22']`). */
+    readonly thirdPartyRequired: _angular_core.InputSignal<readonly string[]>;
+    /** Moneda de los importes (si no, la de `provideCaribeNG({ currency })`). */
+    readonly currency: _angular_core.InputSignal<string | undefined>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Muestra el botón de guardar cargando. */
+    readonly saving: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly saveLabel: _angular_core.InputSignal<string | undefined>;
+    readonly scrollHeight: _angular_core.InputSignal<string | null>;
+    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Comprobante válido y cuadrado al guardar (líneas sin importe quitadas, detalles heredados). */
+    readonly save: _angular_core.OutputEmitterRef<CbJournalEntryData>;
+    /** Se intentó guardar con problemas: cuáles. */
+    readonly invalid: _angular_core.OutputEmitterRef<string[]>;
+    /** Se intentó guardar (desde entonces se muestran los problemas). */
+    protected readonly tried: _angular_core.WritableSignal<boolean>;
+    private readonly accountOptions;
+    protected readonly columns: _angular_core.Signal<CbDataGridColumn<CbJournalLine>[]>;
+    /** Totales de débitos y créditos y su diferencia. */
+    readonly totals: _angular_core.Signal<{
+        debit: number;
+        credit: number;
+        difference: number;
+    }>;
+    /** Débitos y créditos iguales y mayores que cero. */
+    readonly balanced: _angular_core.Signal<boolean>;
+    /** Problemas que impiden guardar. */
+    readonly problems: _angular_core.Signal<string[]>;
+    protected readonly newLine: () => CbJournalLine;
+    protected money(value: number): string;
+    protected patch(change: Partial<CbJournalEntryData>): void;
+    /** Pone la diferencia en la última línea sin importe (o en una nueva) para que cuadre. */
+    balance(): void;
+    /** Valida y, si está todo bien, emite `save`. */
+    submit(): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbJournalEntry, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbJournalEntry, "cb-journal-entry", never, { "entry": { "alias": "entry"; "required": false; "isSignal": true; }; "accounts": { "alias": "accounts"; "required": false; "isSignal": true; }; "thirdParties": { "alias": "thirdParties"; "required": false; "isSignal": true; }; "costCenters": { "alias": "costCenters"; "required": false; "isSignal": true; }; "types": { "alias": "types"; "required": false; "isSignal": true; }; "thirdPartyRequired": { "alias": "thirdPartyRequired"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "saving": { "alias": "saving"; "required": false; "isSignal": true; }; "saveLabel": { "alias": "saveLabel"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "entry": "entryChange"; "save": "save"; "invalid": "invalid"; }, never, never, true, never>;
+}
+
+export { CbJournalEntry, cbEmptyJournalEntry };
+export type { CbJournalEntryData, CbJournalLine, CbJournalOption };
+//# sourceMappingURL=caribeng-ui-journal-entry.d.ts.map

package/types/caribeng-ui-kpi.d.ts

@@ -0,0 +1,64 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat } from '@caribeng/ui';
+
+/** Formato del valor del indicador. */
+type CbKpiFormat = 'currency' | 'number' | 'integer' | 'percent';
+/**
+ * Indicador (KPI) de CaribeNG: valor, variación frente al periodo anterior,
+ * minigráfica de tendencia y avance hacia una meta.
+ *
+ * - `better` dice si subir es bueno (`up`, ingresos) o malo (`down`, gastos): el
+ *   color de la variación lo sigue.
+ * - La variación se calcula sola a partir de `previous` y se dice con texto
+ *   («sube 12,3 %»), no solo con el color o la flecha.
+ *
+ * @example
+ * ```html
+ * <cb-kpi label="Ingresos del mes" [value]="208330000" [previous]="167440000" [series]="ventas" compareLabel="vs. octubre 2025" />
+ * ```
+ */
+declare class CbKpi {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly fmt: typeof cbFormat;
+    protected readonly Math: Math;
+    private readonly config;
+    protected readonly uid: string;
+    readonly label: _angular_core.InputSignal<string>;
+    readonly value: _angular_core.InputSignal<number | null>;
+    /** Valor del periodo con el que se compara. */
+    readonly previous: _angular_core.InputSignal<number | null>;
+    /** Texto de la comparación («vs. mes anterior»). */
+    readonly compareLabel: _angular_core.InputSignal<string>;
+    /** `up`: subir es bueno (ingresos); `down`: subir es malo (gastos); `none`: sin color. */
+    readonly better: _angular_core.InputSignal<"up" | "down" | "none">;
+    readonly format_: _angular_core.InputSignal<CbKpiFormat>;
+    readonly currency: _angular_core.InputSignal<string | undefined>;
+    readonly decimals: _angular_core.InputSignal<number | undefined>;
+    /** Serie para la minigráfica (del más antiguo al más reciente). */
+    readonly series: _angular_core.InputSignal<readonly number[]>;
+    /** Meta: muestra el avance del valor hacia ella. */
+    readonly target: _angular_core.InputSignal<number | null>;
+    private readonly locale;
+    protected format(v: number | null): string;
+    protected readonly delta: _angular_core.Signal<{
+        change: number;
+        good: boolean | null;
+        text: string;
+        spoken: string;
+    } | null>;
+    protected readonly points: _angular_core.Signal<{
+        line: string;
+        area: string;
+    } | null>;
+    protected readonly sparkLabel: _angular_core.Signal<string>;
+    protected readonly progress: _angular_core.Signal<{
+        pct: number;
+    } | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbKpi, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbKpi, "cb-kpi", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "previous": { "alias": "previous"; "required": false; "isSignal": true; }; "compareLabel": { "alias": "compareLabel"; "required": false; "isSignal": true; }; "better": { "alias": "better"; "required": false; "isSignal": true; }; "format_": { "alias": "format"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "decimals": { "alias": "decimals"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { CbKpi };
+export type { CbKpiFormat };
+//# sourceMappingURL=caribeng-ui-kpi.d.ts.map

package/types/{caribeng-ui-caribe-link.d.ts → caribeng-ui-link.d.ts}

@@ -2,7 +2,7 @@ import * as _angular_core from '@angular/core';
 import * as _caribeng_ui from '@caribeng/ui';
 
 /**
- * Enlace de Caribe Design. Renderiza un ancla accesible con estilos de marca,
+ * Enlace. Renderiza un ancla accesible con estilos de marca,
  * soporte de enlaces externos y estado deshabilitado.
  *
  * @example
@@ -27,4 +27,4 @@ declare class CbLink {
 }
 
 export { CbLink };
-//# sourceMappingURL=caribeng-ui-caribe-link.d.ts.map
+//# sourceMappingURL=caribeng-ui-link.d.ts.map

package/types/{caribeng-ui-caribe-logo.d.ts → caribeng-ui-logo.d.ts}

@@ -14,4 +14,4 @@ declare class CbLogo {
 
 export { CbLogo };
 export type { CbLogoFormat };
-//# sourceMappingURL=caribeng-ui-caribe-logo.d.ts.map
+//# sourceMappingURL=caribeng-ui-logo.d.ts.map