@caribeng/ui 22.4.0 → 22.6.0

package/types/caribeng-ui-financial-report.d.ts

@@ -0,0 +1,102 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat, CbNegativeStyle } from '@caribeng/ui';
+import { CbAccount } from '@caribeng/ui/account-picker';
+import { CbTreeTableNode, CbTreeTableColumn } from '@caribeng/ui/treetable';
+import { CbXlsxSheet } from '@caribeng/ui/xlsx';
+
+/** Fila de total calculada a partir de cuentas (p. ej. «Utilidad del ejercicio» = 4 − 5 − 6). */
+interface CbReportTotal {
+    readonly label: string;
+    readonly terms: readonly {
+        readonly code: string;
+        readonly sign?: 1 | -1;
+    }[];
+}
+/** Valores por cuenta de movimiento: uno por periodo, en el orden de `periods`. */
+type CbReportBalances = Readonly<Record<string, readonly (number | null)[]>>;
+/**
+ * Informe financiero jerárquico de CaribeNG: balance general, estado de resultados
+ * o balance de prueba a partir del plan de cuentas y los saldos de las cuentas de
+ * movimiento.
+ *
+ * - Cada cuenta mayor suma a sus auxiliares; los niveles se abren con los botones
+ *   «Nivel 1…N» y se pueden ocultar las cuentas en cero.
+ * - Varios periodos en columnas y, con `comparative`, la variación y el % del
+ *   primero frente al segundo.
+ * - Totales calculados (`totals`), saldos de naturaleza crédito en positivo
+ *   (`signByNature`), exportación a Excel con niveles plegables e impresión.
+ * - Clic o Enter en una cuenta de movimiento emite `accountOpen` (ver sus movimientos).
+ *
+ * @example
+ * ```html
+ * <cb-financial-report title="Estado de resultados" [accounts]="puc" [balances]="saldos" [periods]="['2026', '2025']" comparative [classes]="['4', '5', '6']" [totals]="utilidad" />
+ * ```
+ */
+declare class CbFinancialReport {
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly fmt: typeof cbFormat;
+    private readonly config;
+    protected readonly uid: string;
+    private readonly tree;
+    readonly title: _angular_core.InputSignal<string>;
+    /** Líneas bajo el título (empresa, NIT, periodo). */
+    readonly subtitle: _angular_core.InputSignal<readonly string[]>;
+    /** Plan de cuentas. */
+    readonly accounts: _angular_core.InputSignal<readonly CbAccount[]>;
+    /** Saldos de las cuentas de movimiento, uno por periodo. */
+    readonly balances: _angular_core.InputSignal<Readonly<Record<string, readonly (number | null)[]>>>;
+    /** Nombres de los periodos (columnas). */
+    readonly periods: _angular_core.InputSignal<readonly string[]>;
+    /** Columnas de variación y % del primer periodo frente al segundo. */
+    readonly comparative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Clases (cuentas raíz) que se muestran: `['1', '2', '3']` para el balance. Todas
+     * por defecto. Los `totals` pueden usar cualquier cuenta, también de otras clases.
+     */
+    readonly classes: _angular_core.InputSignal<readonly string[] | null>;
+    /** Muestra en positivo los saldos de naturaleza crédito (pasivo, patrimonio, ingresos). */
+    readonly signByNature: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Filas de total al final. */
+    readonly totals: _angular_core.InputSignal<readonly CbReportTotal[]>;
+    /** Niveles abiertos (1 = solo las clases). */
+    readonly level: _angular_core.ModelSignal<number>;
+    /** Oculta las cuentas cuyos saldos son todos cero. */
+    readonly hideZero: _angular_core.ModelSignal<boolean>;
+    readonly toolbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly currency: _angular_core.InputSignal<string | undefined>;
+    readonly negativeStyle: _angular_core.InputSignal<CbNegativeStyle | undefined>;
+    /** Clic o Enter en una cuenta de movimiento. */
+    readonly accountOpen: _angular_core.OutputEmitterRef<CbAccount>;
+    private readonly resolved;
+    private readonly byCode;
+    /** Signo de cada cuenta según la naturaleza de su clase. */
+    private signOf;
+    /** Árbol de todo el plan de cuentas con los saldos (con signo) en las hojas. */
+    private readonly allNodes;
+    /** Árbol del informe: solo las clases pedidas (`classes`). */
+    private readonly baseNodes;
+    /** Árbol mostrado: sin las cuentas en cero (si se pide) y con las filas de total. */
+    protected readonly nodes: _angular_core.Signal<CbTreeTableNode[]>;
+    /** Total (con signo) de una cuenta en cada periodo, sumando sus hojas. */
+    private readonly sums;
+    private readonly totalNodes;
+    protected readonly columns: _angular_core.Signal<CbTreeTableColumn[]>;
+    /** Niveles disponibles (hasta la profundidad del plan de cuentas). */
+    protected readonly levels: _angular_core.Signal<number[]>;
+    protected readonly rowClass: (node: CbTreeTableNode) => string | null;
+    constructor();
+    protected onActivate(node: CbTreeTableNode): void;
+    /** Hoja de Excel del informe: todas las cuentas con sus niveles plegables, títulos y totales. */
+    toExcelSheet(): CbXlsxSheet;
+    /** Descarga el informe en Excel. */
+    exportExcel(filename?: string): void;
+    /** Imprime el informe (todas las cuentas hasta el nivel abierto) en una ventana de impresión limpia. */
+    print(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbFinancialReport, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbFinancialReport, "cb-financial-report", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "accounts": { "alias": "accounts"; "required": false; "isSignal": true; }; "balances": { "alias": "balances"; "required": false; "isSignal": true; }; "periods": { "alias": "periods"; "required": false; "isSignal": true; }; "comparative": { "alias": "comparative"; "required": false; "isSignal": true; }; "classes": { "alias": "classes"; "required": false; "isSignal": true; }; "signByNature": { "alias": "signByNature"; "required": false; "isSignal": true; }; "totals": { "alias": "totals"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "hideZero": { "alias": "hideZero"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; "negativeStyle": { "alias": "negativeStyle"; "required": false; "isSignal": true; }; }, { "level": "levelChange"; "hideZero": "hideZeroChange"; "accountOpen": "accountOpen"; }, never, never, true, never>;
+}
+
+export { CbFinancialReport };
+export type { CbReportBalances, CbReportTotal };
+//# sourceMappingURL=caribeng-ui-financial-report.d.ts.map

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

@@ -6,7 +6,7 @@ interface CbFloatMenuItem {
     label: string;
 }
 /**
- * Float-menu de Caribe Design: menú flotante en forma de píldora con opciones
+ * Float-menu: menú flotante en forma de píldora con opciones
  * seleccionables (segmentado horizontal).
  *
  * @example
@@ -31,4 +31,4 @@ declare class CbFloatMenu {
 
 export { CbFloatMenu };
 export type { CbFloatMenuItem };
-//# sourceMappingURL=caribeng-ui-caribe-float-menu.d.ts.map
+//# sourceMappingURL=caribeng-ui-float-menu.d.ts.map

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

@@ -0,0 +1,228 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat } from '@caribeng/ui';
+
+/** Tipo de nodo de un flujo. */
+type CbFlowNodeType = 'start' | 'task' | 'decision' | 'end';
+/** Nodo: `x`, `y` es su esquina superior izquierda en el lienzo (px a zoom 100 %). */
+interface CbFlowNode {
+    readonly id: string;
+    readonly type: CbFlowNodeType;
+    readonly label: string;
+    readonly x: number;
+    readonly y: number;
+}
+/** Conexión dirigida de `from` a `to`, con una etiqueta opcional ("Aprobado"). */
+interface CbFlowEdge {
+    readonly id: string;
+    readonly from: string;
+    readonly to: string;
+    readonly label?: string;
+}
+/** Un flujo: nodos y conexiones. */
+interface CbFlow {
+    readonly nodes: readonly CbFlowNode[];
+    readonly edges: readonly CbFlowEdge[];
+}
+/** Problema de un flujo (`cbValidateFlow`). */
+type CbFlowIssueCode = 'no-start' | 'many-starts' | 'no-end' | 'start-incoming' | 'end-outgoing' | 'dead-end' | 'decision-branches' | 'branch-label' | 'unreachable';
+interface CbFlowIssue {
+    readonly code: CbFlowIssueCode;
+    /** Nodo afectado (si lo hay). */
+    readonly nodeId?: string;
+    /** `warning` no impide usar el flujo (una salida de decisión sin etiqueta). */
+    readonly severity: 'error' | 'warning';
+}
+/** Tamaño de cada tipo de nodo (px a zoom 100 %). */
+declare const CB_FLOW_NODE_SIZE: Readonly<Record<CbFlowNodeType, {
+    readonly w: number;
+    readonly h: number;
+}>>;
+/**
+ * Problemas del flujo: falta un inicio o un fin, nodos sin salida o inalcanzables desde el inicio,
+ * decisiones con menos de dos salidas (o salidas sin etiqueta), y conexiones que entran en un inicio
+ * o salen de un fin. Un flujo vacío no tiene problemas.
+ */
+declare function cbValidateFlow(flow: CbFlow): CbFlowIssue[];
+/**
+ * Coloca los nodos por niveles de arriba abajo (el inicio arriba y cada paso debajo del anterior),
+ * centrados y sin cruzar más de lo necesario. Las conexiones que vuelven atrás no cuentan para
+ * los niveles. Las posiciones se ajustan a la rejilla `grid`.
+ */
+declare function cbLayoutFlow(flow: CbFlow, grid?: number): CbFlow;
+
+/** Conexión ya colocada: trazado, flecha, etiqueta y nombre accesible. */
+interface EdgeView {
+    readonly edge: CbFlowEdge;
+    readonly d: string;
+    readonly arrow: string;
+    readonly mid: readonly [number, number];
+    readonly label: string;
+}
+/** Edición en línea del nombre de un nodo o de la etiqueta de una conexión. */
+interface Editing {
+    readonly id: string;
+    readonly kind: 'node' | 'edge';
+}
+/**
+ * Editor de flujos (aprobaciones, procesos): nodos de inicio, tarea, decisión y fin unidos por
+ * conexiones con etiqueta. Se arrastran los nodos, se conectan desde su tirador y el lienzo se
+ * desplaza y amplía. Todo se puede hacer con el teclado, y la vista Lista es una alternativa
+ * sin lienzo para editar el flujo con lector de pantalla. Valida el flujo (`issues`) y lo ordena
+ * por niveles (`layout()`).
+ *
+ * @example
+ * ```html
+ * <cb-flow-editor [(flow)]="aprobacion" />
+ * ```
+ */
+declare class CbFlowEditor {
+    /** Textos de interfaz en el idioma activo (`provideCaribeNG({ locale })`). */
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly format: typeof cbFormat;
+    /** El flujo: nodos y conexiones. */
+    readonly flow: _angular_core.ModelSignal<CbFlow>;
+    /** Solo lectura: se puede recorrer, desplazar y ampliar, pero no editar. Intro abre el nodo (`nodeOpen`). */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Rejilla en px: los nodos se ajustan a ella al moverlos (1 la desactiva). */
+    readonly gridSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Zoom (1 = 100 %). */
+    readonly zoom: _angular_core.ModelSignal<number>;
+    /** Diagrama o lista (alternativa sin lienzo, para teclado y lector de pantalla). */
+    readonly view: _angular_core.ModelSignal<"diagram" | "list">;
+    /** Nodo o conexión seleccionada (su `id`). */
+    readonly selected: _angular_core.ModelSignal<string | null>;
+    /** Muestra los problemas del flujo bajo el editor. */
+    readonly showValidation: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Ajusta el zoom para ver todo el flujo al cargarlo. */
+    readonly fitOnLoad: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nombre accesible (por defecto, "Editor de flujo"). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Se abrió un nodo: doble clic, o Intro en solo lectura. */
+    readonly nodeOpen: _angular_core.OutputEmitterRef<CbFlowNode>;
+    protected readonly uid: string;
+    protected readonly types: readonly CbFlowNodeType[];
+    protected readonly sizes: Readonly<Record<CbFlowNodeType, {
+        readonly w: number;
+        readonly h: number;
+    }>>;
+    protected readonly minZoom = 0.25;
+    protected readonly maxZoom = 2;
+    protected readonly step = 1.2;
+    private readonly host;
+    private readonly injector;
+    private readonly viewport;
+    private readonly editor;
+    /** Desplazamiento del lienzo (px de pantalla). */
+    protected readonly pan: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    }>;
+    protected readonly panning: _angular_core.WritableSignal<boolean>;
+    /** Posición provisional de un nodo mientras se arrastra. */
+    private readonly dragPos;
+    /** Nodo desde el que se conecta (con el teclado o con el botón Conectar). */
+    protected readonly connectFrom: _angular_core.WritableSignal<string | null>;
+    /** Conexión que se arrastra desde un tirador, hasta el puntero (coordenadas del lienzo). */
+    private readonly linkDrag;
+    protected readonly editing: _angular_core.WritableSignal<Editing | null>;
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    private announceFlip;
+    private fitted;
+    /** Problemas del flujo (los mismos que muestra el editor). */
+    readonly issues: _angular_core.Signal<CbFlowIssue[]>;
+    protected readonly nodes: _angular_core.Signal<readonly CbFlowNode[]>;
+    private readonly nodeMap;
+    protected readonly outgoing: _angular_core.Signal<Map<string, CbFlowEdge[]>>;
+    protected readonly issuesByNode: _angular_core.Signal<Map<string, CbFlowIssue[]>>;
+    protected readonly edgeViews: _angular_core.Signal<EdgeView[]>;
+    /** Caja del SVG de conexiones: la de los nodos con margen para las curvas que rodean. */
+    protected readonly svgBox: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    protected readonly tempLine: _angular_core.Signal<string>;
+    protected readonly worldTransform: _angular_core.Signal<string>;
+    protected readonly gridBackground: _angular_core.Signal<{
+        size: string;
+        position: string;
+    }>;
+    protected readonly percent: _angular_core.Signal<string>;
+    protected readonly ordered: _angular_core.Signal<CbFlowNode[]>;
+    protected readonly selectedNode: _angular_core.Signal<CbFlowNode | null>;
+    protected readonly selectedExists: _angular_core.Signal<boolean>;
+    /** Caja del campo de edición en línea (sobre el nodo o en el punto medio de la conexión). */
+    protected readonly editorBox: _angular_core.Signal<{
+        x: number;
+        y: number;
+        w: number;
+        label: string;
+    } | null>;
+    constructor();
+    /** Añade un nodo. Con un nodo seleccionado, lo pone debajo y lo conecta desde él; después abre su nombre. */
+    addNode(type: CbFlowNodeType): CbFlowNode;
+    /** Conecta dos nodos (si se puede: no consigo mismo, no repetida, no hacia un inicio ni desde un fin). */
+    connect(from: string, to: string, label?: string): CbFlowEdge | null;
+    removeNode(id: string): void;
+    removeEdge(id: string): void;
+    rename(id: string, label: string): void;
+    relabel(id: string, label: string): void;
+    /** Coloca los nodos por niveles de arriba abajo y ajusta la vista. */
+    layout(): void;
+    /** Ajusta zoom y desplazamiento para ver todo el flujo. */
+    fit(): void;
+    /** Multiplica el zoom por `factor` alrededor del centro de la vista (o del punto `at`, en px de la vista). */
+    zoomBy(factor: number, at?: {
+        x: number;
+        y: number;
+    }): void;
+    protected toggleConnect(): void;
+    protected deleteSelected(): void;
+    protected connectFromList(from: string, select: HTMLSelectElement): void;
+    protected reveal(id: string): void;
+    protected onNodeKeydown(event: KeyboardEvent, rendered: CbFlowNode): void;
+    protected onEdgeKeydown(event: KeyboardEvent, edge: CbFlowEdge): void;
+    protected onHostKeydown(event: KeyboardEvent): void;
+    protected startEdit(id: string, kind: 'node' | 'edge'): void;
+    protected onEditorKeydown(event: KeyboardEvent): void;
+    /** Guarda lo escrito (al pulsar Intro o al salir del campo). */
+    protected commitEdit(refocus?: boolean): void;
+    private cancelEdit;
+    private focusItem;
+    protected onNodePointerDown(event: PointerEvent, node: CbFlowNode): void;
+    protected onNodeDblClick(node: CbFlowNode): void;
+    /** Arrastrar desde el tirador crea una conexión con el nodo donde se suelta. */
+    protected onHandlePointerDown(event: PointerEvent, node: CbFlowNode): void;
+    protected onEdgePointerDown(event: PointerEvent, edge: CbFlowEdge): void;
+    /** Arrastrar el fondo desplaza el lienzo; un clic sin moverse quita la selección. */
+    protected onBackgroundPointerDown(event: PointerEvent): void;
+    /** Rueda: desplaza; con Ctrl (o el gesto de pellizcar del panel táctil), amplía alrededor del puntero. */
+    protected onWheel(event: WheelEvent): void;
+    private track;
+    private beginConnect;
+    private cancelConnect;
+    private moveNode;
+    private newEdge;
+    /** Coordenadas del lienzo bajo el puntero. */
+    private toWorld;
+    /** Desplaza el lienzo lo justo para que se vea el nodo. */
+    private ensureVisible;
+    private focusNode;
+    private focusAfterRemoval;
+    protected nodeLabel(n: CbFlowNode): string;
+    protected typeLabel(type: CbFlowNodeType): string;
+    protected nameOf(id: string): string;
+    /** Destinos posibles en la lista: todos menos él mismo, los inicios y los ya conectados. */
+    protected targetsFor(node: CbFlowNode): CbFlowNode[];
+    protected issueText(issue: CbFlowIssue): string;
+    protected diamond(type: CbFlowNodeType): string;
+    private announce;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbFlowEditor, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbFlowEditor, "cb-flow-editor", never, { "flow": { "alias": "flow"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "gridSize": { "alias": "gridSize"; "required": false; "isSignal": true; }; "zoom": { "alias": "zoom"; "required": false; "isSignal": true; }; "view": { "alias": "view"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "showValidation": { "alias": "showValidation"; "required": false; "isSignal": true; }; "fitOnLoad": { "alias": "fitOnLoad"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "flow": "flowChange"; "zoom": "zoomChange"; "view": "viewChange"; "selected": "selectedChange"; "nodeOpen": "nodeOpen"; }, never, never, true, never>;
+}
+
+export { CB_FLOW_NODE_SIZE, CbFlowEditor, cbLayoutFlow, cbValidateFlow };
+export type { CbFlow, CbFlowEdge, CbFlowIssue, CbFlowIssueCode, CbFlowNode, CbFlowNodeType };
+//# sourceMappingURL=caribeng-ui-flow.d.ts.map

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

@@ -1,7 +1,7 @@
 import * as i0 from '@angular/core';
 
 /**
- * Footer de Caribe Design: pie de página con texto de copyright y una zona de
+ * Footer: pie de página con texto de copyright y una zona de
  * enlaces o acciones proyectadas.
  *
  * @example
@@ -17,4 +17,4 @@ declare class CbFooter {
 }
 
 export { CbFooter };
-//# sourceMappingURL=caribeng-ui-caribe-footer.d.ts.map
+//# sourceMappingURL=caribeng-ui-footer.d.ts.map

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

@@ -0,0 +1,244 @@
+import * as _angular_core from '@angular/core';
+import * as _caribeng_ui from '@caribeng/ui';
+import { cbFormat } from '@caribeng/ui';
+
+/**
+ * Modelo del diagrama de Gantt: fechas, árbol de tareas, grupos calculados,
+ * dependencias (fin → inicio) y planificación automática. Funciones puras: el
+ * componente las usa y los tests las prueban sin DOM.
+ */
+/** Tarea del diagrama. Las fechas son días (`'AAAA-MM-DD'` o `Date`); el fin es inclusivo. */
+interface CbGanttTask {
+    readonly id: string;
+    readonly name: string;
+    readonly start: string | Date;
+    readonly end: string | Date;
+    /** Avance de 0 a 100. En los grupos se calcula con el de sus tareas. */
+    readonly progress?: number;
+    /** Tarea que la contiene (grupo). */
+    readonly parent?: string | null;
+    /** Tareas que deben terminar antes de que esta empiece (fin → inicio). */
+    readonly dependencies?: readonly string[];
+    /** `milestone` es un hito (un solo día, rombo); `group` agrupa tareas (sus fechas se calculan). */
+    readonly type?: 'task' | 'milestone' | 'group';
+    /** Color de la barra. */
+    readonly color?: string;
+    /** Texto de la columna Responsable. */
+    readonly assignee?: string;
+}
+/** Escala del diagrama: un día, una semana o un mes por columna. */
+type CbGanttScale = 'day' | 'week' | 'month';
+/** Columnas de la tabla de la izquierda. */
+type CbGanttColumn = 'name' | 'start' | 'end' | 'duration' | 'progress' | 'assignee';
+/** Una tarea cambió (al arrastrar, con el teclado o por la planificación automática). */
+interface CbGanttChange {
+    readonly task: CbGanttTask;
+    readonly previous: CbGanttTask;
+    readonly reason: 'move' | 'resize' | 'progress' | 'schedule';
+}
+/** Dependencia creada o quitada: `to` depende de `from`. */
+interface CbGanttLink {
+    readonly from: string;
+    readonly to: string;
+}
+/** Tarea con sus fechas ya resueltas (en los grupos, calculadas con sus tareas). */
+interface ResolvedTask {
+    readonly task: CbGanttTask;
+    readonly start: Date;
+    readonly end: Date;
+    readonly progress: number;
+    readonly level: number;
+    readonly isGroup: boolean;
+    readonly isMilestone: boolean;
+    readonly children: readonly string[];
+}
+/** ¿Se puede crear la dependencia `from` → `to`? (sin repetir, sin ciclos ni grupos que se contienen). */
+declare function canLink(tasks: readonly CbGanttTask[], from: string, to: string): boolean;
+/**
+ * Planificación automática: cada tarea empieza como pronto el día siguiente al
+ * fin de sus predecesoras; si no, se desplaza conservando su duración. Devuelve
+ * las tareas cambiadas (las de grupos se resuelven con sus hijas).
+ */
+declare function autoSchedule(tasks: readonly CbGanttTask[]): CbGanttTask[];
+
+type DragMode = 'move' | 'start' | 'end' | 'progress' | 'link';
+interface Preview {
+    readonly id: string;
+    readonly mode: DragMode;
+    /** Días desplazados (mover / cambiar inicio o fin). */
+    readonly delta: number;
+    /** Avance nuevo (al arrastrar el avance). */
+    readonly progress: number;
+    /** Punto del puntero en el diagrama (al crear una dependencia). */
+    readonly point: {
+        x: number;
+        y: number;
+    } | null;
+}
+interface Bar {
+    readonly row: ResolvedTask;
+    readonly index: number;
+    readonly x: number;
+    readonly width: number;
+    readonly y: number;
+    readonly start: Date;
+    readonly end: Date;
+    readonly progress: number;
+}
+interface Unit {
+    readonly key: string;
+    readonly label: string;
+    readonly x: number;
+    readonly width: number;
+    readonly weekend?: boolean;
+}
+/**
+ * Diagrama de Gantt de CaribeNG: tabla de tareas en árbol (grupos plegables) y
+ * barras en el tiempo, con escalas de día, semana y mes.
+ *
+ * - Arrastra una barra para moverla, sus bordes para cambiar inicio o fin, el
+ *   tirador inferior para el avance y el punto de la derecha hasta otra tarea
+ *   para crear una dependencia (fin → inicio).
+ * - Con `autoSchedule`, al retrasar una tarea se desplazan las que dependen de ella.
+ * - Los grupos abarcan a sus tareas y promedian su avance; los hitos son rombos.
+ * - Con el teclado, cada barra es un botón: flechas mueven, Mayús + flechas cambian
+ *   el fin, Alt + flechas el inicio, + / − el avance, Supr quita sus dependencias
+ *   y Enter abre la tarea. Cada cambio se anuncia.
+ *
+ * @example
+ * ```html
+ * <cb-gantt [(tasks)]="tareas" [(scale)]="escala" (taskChange)="guardar($event)" />
+ * ```
+ */
+declare class CbGantt {
+    /** Textos de interfaz en el idioma activo (`provideCaribeNG({ locale })`). */
+    protected readonly t: _angular_core.Signal<_caribeng_ui.CbTranslation>;
+    protected readonly fmt: typeof cbFormat;
+    private readonly injector;
+    private readonly host;
+    protected readonly uid: string;
+    protected readonly row = 40;
+    protected readonly scales: readonly CbGanttScale[];
+    /** Tareas (bidireccional: se actualiza al arrastrar, con el teclado y al planificar). */
+    readonly tasks: _angular_core.ModelSignal<readonly CbGanttTask[]>;
+    /** Escala: un día, una semana o un mes por columna. */
+    readonly scale: _angular_core.ModelSignal<CbGanttScale>;
+    /** Columnas de la tabla de la izquierda y su orden. */
+    readonly columns: _angular_core.InputSignal<readonly CbGanttColumn[]>;
+    /** Ancho de la tabla de la izquierda; por defecto, el de sus columnas (como mucho, el 60 % del componente). */
+    readonly gridWidth: _angular_core.InputSignal<string>;
+    /** Alto del componente (con scroll). */
+    readonly height: _angular_core.InputSignal<string>;
+    /** Al retrasar una tarea, desplaza las que dependen de ella (fin → inicio). */
+    readonly autoSchedule: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Sin edición: no se arrastra ni se crean dependencias. */
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Barra con la escala y el botón Hoy. */
+    readonly showToolbar: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Texto sin tareas. Por defecto, "Sin datos". */
+    readonly emptyMessage: _angular_core.InputSignal<string | undefined>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    /** Una tarea cambió de fechas o de avance (también las desplazadas por la planificación). */
+    readonly taskChange: _angular_core.OutputEmitterRef<CbGanttChange>;
+    /** Doble clic o Enter sobre una tarea. */
+    readonly taskOpen: _angular_core.OutputEmitterRef<CbGanttTask>;
+    /** Dependencia creada (`to` depende de `from`). */
+    readonly linkAdd: _angular_core.OutputEmitterRef<CbGanttLink>;
+    /** Dependencia quitada. */
+    readonly linkRemove: _angular_core.OutputEmitterRef<CbGanttLink>;
+    protected readonly collapsed: _angular_core.WritableSignal<ReadonlySet<string>>;
+    protected readonly selected: _angular_core.WritableSignal<string | null>;
+    protected readonly selectedLink: _angular_core.WritableSignal<{
+        key: string;
+        from: string;
+        to: string;
+        fromName: string;
+        toName: string;
+        mid: {
+            x: number;
+            y: number;
+        };
+    } | null>;
+    protected readonly preview: _angular_core.WritableSignal<Preview | null>;
+    protected readonly announcement: _angular_core.WritableSignal<string>;
+    private drag;
+    private readonly scroller;
+    private readonly chart;
+    private readonly resolved;
+    /** Ancho de la tabla: el indicado o el nombre (14rem) más el de cada columna. */
+    protected readonly gridSize: _angular_core.Signal<string>;
+    protected readonly rows: _angular_core.Signal<ResolvedTask[]>;
+    protected readonly dayWidth: _angular_core.Signal<number>;
+    /** Primer y último día del diagrama (con margen, alineados a la unidad de la escala). */
+    protected readonly range: _angular_core.Signal<{
+        start: Date;
+        end: Date;
+        days: number;
+    }>;
+    protected readonly chartWidth: _angular_core.Signal<number>;
+    private x;
+    /** Unidades de la escala (fila inferior de la cabecera y columnas del fondo). */
+    protected readonly units: _angular_core.Signal<Unit[]>;
+    /** Fila superior de la cabecera: meses (día y semana) o años (mes). */
+    protected readonly topUnits: _angular_core.Signal<Unit[]>;
+    protected readonly todayX: _angular_core.Signal<number | null>;
+    /** Geometría de las barras (con la vista previa del arrastre). */
+    protected readonly bars: _angular_core.Signal<Bar[]>;
+    /** Flechas de dependencias entre barras visibles. */
+    protected readonly links: _angular_core.Signal<{
+        key: string;
+        from: string;
+        to: string;
+        fromName: string;
+        toName: string;
+        path: string;
+        mid: {
+            x: number;
+            y: number;
+        };
+    }[]>;
+    /** Línea provisional al crear una dependencia. */
+    protected readonly linkLine: _angular_core.Signal<string | null>;
+    protected scaleLabel(s: CbGanttScale): string;
+    protected columnLabel(col: CbGanttColumn): string;
+    private dateText;
+    protected cellText(r: ResolvedTask, col: CbGanttColumn): string;
+    protected barLabel(b: Bar): string;
+    protected toggle(id: string): void;
+    /** Selecciona la tarea, lleva su barra a la vista y le da el foco. */
+    focusBar(id: string): void;
+    /** Desplaza el diagrama hasta hoy (centrado en la parte visible). */
+    scrollToToday(smooth?: boolean): void;
+    constructor();
+    private barEl;
+    /** Aplica un cambio a una tarea (y a las desplazadas por la planificación) y lo emite. */
+    private apply;
+    private commit;
+    private resolveFresh;
+    /** Crea la dependencia `from` → `to` (si no forma un ciclo). */
+    addLink(from: string, to: string): boolean;
+    /** Quita la dependencia `from` → `to`. */
+    removeLink(from: string, to: string): void;
+    protected selectLink(link: {
+        key: string;
+        from: string;
+        to: string;
+        fromName: string;
+        toName: string;
+        mid: {
+            x: number;
+            y: number;
+        };
+    }): void;
+    protected onPointerDown(event: PointerEvent, bar: Bar): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    protected cancelDrag(): void;
+    protected onBarKeydown(event: KeyboardEvent, r: ResolvedTask): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CbGantt, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CbGantt, "cb-gantt", never, { "tasks": { "alias": "tasks"; "required": false; "isSignal": true; }; "scale": { "alias": "scale"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "gridWidth": { "alias": "gridWidth"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "autoSchedule": { "alias": "autoSchedule"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "showToolbar": { "alias": "showToolbar"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "tasks": "tasksChange"; "scale": "scaleChange"; "taskChange": "taskChange"; "taskOpen": "taskOpen"; "linkAdd": "linkAdd"; "linkRemove": "linkRemove"; }, never, never, true, never>;
+}
+
+export { CbGantt, autoSchedule as cbGanttAutoSchedule, canLink as cbGanttCanLink };
+export type { CbGanttChange, CbGanttColumn, CbGanttLink, CbGanttScale, CbGanttTask };
+//# sourceMappingURL=caribeng-ui-gantt.d.ts.map

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

@@ -2,7 +2,7 @@ import * as _angular_core from '@angular/core';
 import * as _caribeng_ui from '@caribeng/ui';
 
 /**
- * Header de Caribe Design: cabecera de pantalla con título, subtítulo opcional,
+ * Header: cabecera de pantalla con título, subtítulo opcional,
  * botón de retroceso y una zona de acciones proyectadas.
  *
  * @example
@@ -26,4 +26,4 @@ declare class CbHeader {
 }
 
 export { CbHeader };
-//# sourceMappingURL=caribeng-ui-caribe-header.d.ts.map
+//# sourceMappingURL=caribeng-ui-header.d.ts.map

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

@@ -2,7 +2,7 @@ import * as _angular_core from '@angular/core';
 import * as _caribeng_ui from '@caribeng/ui';
 
 /**
- * Icon-button de Caribe Design: botón circular con un único icono. Útil para
+ * Icon-button: botón circular con un único icono. Útil para
  * acciones compactas en barras y cabeceras.
  *
  * @example
@@ -28,4 +28,4 @@ declare class CbIconButton {
 }
 
 export { CbIconButton };
-//# sourceMappingURL=caribeng-ui-caribe-icon-button.d.ts.map
+//# sourceMappingURL=caribeng-ui-icon-button.d.ts.map

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

@@ -12,4 +12,4 @@ declare class CbIllustration {
 }
 
 export { CbIllustration };
-//# sourceMappingURL=caribeng-ui-caribe-illustration.d.ts.map
+//# sourceMappingURL=caribeng-ui-illustration.d.ts.map