@cbm-common/cbm-types 0.0.365 → 0.0.367

package/lib/components/document-editor/tables/document-editor-table-selection.d.ts

@@ -0,0 +1,47 @@
+import { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { Selection } from '@tiptap/pm/state';
+import { TableMap } from '@tiptap/pm/tables';
+export interface TableCellInfo {
+    /** Posición del nodo de la celda en el documento. */
+    position: number;
+    node: ProseMirrorNode;
+    /** Primera fila y columna que ocupa (0 es la primera) y cuántas abarca. */
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+}
+export interface TableContext {
+    /** Posición del nodo de la tabla en el documento. */
+    tablePosition: number;
+    table: ProseMirrorNode;
+    map: TableMap;
+    /** Todas las celdas de la tabla, en orden de documento. */
+    cells: TableCellInfo[];
+    /** Las celdas seleccionadas o, con el cursor suelto, la celda donde está. Vacío si el cursor no está en una celda. */
+    selected: TableCellInfo[];
+}
+/** Un estado del editor (`editor.state`) o una transacción: cualquier cosa con `selection`. */
+interface SelectionHolder {
+    selection: Selection;
+}
+export declare const isCellNode: (node: ProseMirrorNode) => boolean;
+/**
+ * Mapa y celdas (en orden de documento, con su lugar en la cuadrícula) de la tabla que empieza en `tablePosition`, o
+ * `null` si está a medio armar (sin filas completas no tiene mapa).
+ */
+export declare function describeTable(tablePosition: number, table: ProseMirrorNode): {
+    map: TableMap;
+    cells: TableCellInfo[];
+} | null;
+/**
+ * Tabla más interna alrededor de la selección con sus celdas (ver `TableContext`), o `null` si la selección no está
+ * en una tabla. Con una selección de celdas la tabla es la de esas celdas.
+ */
+export declare function findTableContext({ selection }: SelectionHolder): TableContext | null;
+/**
+ * Reescribe un estilo en línea con la API de estilos del navegador (entiende los atajos `border`, `background`…).
+ * `edit` cambia el `CSSStyleDeclaration`; devuelve el estilo nuevo, o `null` si queda vacío.
+ */
+export declare function editInlineStyle(current: unknown, edit: (style: CSSStyleDeclaration) => void): string | null;
+export {};

package/lib/components/document-editor/tables/document-editor-table.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const DocumentTableFormat: Extension<any, any>;

package/lib/components/document-editor/tables/handles/document-editor-table-handles-commands.d.ts

@@ -0,0 +1,46 @@
+import type { Editor } from '@tiptap/core';
+import { type FloatPlacement, type TableMeasures } from './document-editor-table-handles-geometry';
+/**
+ * Selecciona la tabla entera (todas sus celdas) y devuelve el foco a la hoja, como el asa de mover de Word: la cinta
+ * muestra entonces las herramientas de tabla y el sombreado, los bordes… alcanzan a todas las celdas. Si la librería
+ * no pudiera hacerlo, selecciona el nodo de la tabla.
+ */
+export declare function selectTable(editor: Editor, tablePosition: number): boolean;
+/** Dónde queda una tabla flotante: el lado y la distancia al borde de ese lado (ver `floatPlacement`). */
+export type TableFloatPlacement = FloatPlacement;
+export interface TableMove {
+    /** Posición del nodo de la tabla. */
+    tablePosition: number;
+    /** Delante de qué hijo de su contenedor queda (el número de hijos es "al final"), contando la tabla que se mueve. */
+    index: number;
+    /** Lado y distancia nuevos de una tabla con ajuste de texto; `null` si va en línea. */
+    float: TableFloatPlacement | null;
+}
+/**
+ * Mueve la tabla delante del hijo `index` de su contenedor (el documento, o la celda donde está anidada) en un solo
+ * paso. Una tabla con ajuste de texto cambia además de lado y de distancia al borde (`move.float`). Deja una línea
+ * vacía entre la tabla y un bloque que no sea un texto, y la tabla seleccionada. Si el resultado no fuera válido
+ * (el hueco no admite una tabla) no cambia nada. Devuelve si hizo algo o ya estaba así.
+ */
+export declare function moveTable(editor: Editor, move: TableMove): boolean;
+export interface TableResize {
+    /** Posición del nodo de la tabla. */
+    tablePosition: number;
+    /** Medidas de la tabla antes del cambio (px CSS de la hoja): lo que se escala. */
+    measures: TableMeasures;
+    /** Ancho nuevo de la tabla (px CSS); `null` si no cambia. */
+    width: number | null;
+    /** Alto nuevo de la tabla (px CSS); `null` si no cambia. */
+    height: number | null;
+}
+/**
+ * Cambia el tamaño de la tabla en un solo paso. El ancho escala el de cada columna (`colwidth` de cada celda, mínimo
+ * 10 px) y la tabla queda con un ancho fijo en píxeles, la suma de las columnas. El alto escala el de cada fila: se
+ * guarda como `height` en puntos en las celdas de la fila (una fila no baja de lo que pide su contenido). Devuelve
+ * si cambió algo.
+ */
+export declare function resizeTable(editor: Editor, resize: TableResize): boolean;
+/** Inserta una fila delante de la fila `index` de la tabla (el número de filas la agrega al final). */
+export declare function insertTableRow(editor: Editor, tablePosition: number, index: number): boolean;
+/** Inserta una columna delante de la columna `index` de la tabla (el número de columnas la agrega al final). */
+export declare function insertTableColumn(editor: Editor, tablePosition: number, index: number): boolean;

package/lib/components/document-editor/tables/handles/document-editor-table-handles-dom.d.ts

@@ -0,0 +1,23 @@
+/** Atributo que identifica cada asa que atiende la capa: `move`, `resize` o `insert`. */
+export declare const HANDLE_ATTRIBUTE = "data-table-handle";
+export interface TableHandleElements {
+    /** Capa `.document-editor__table-handles`: contiene todo lo demás y no recibe el puntero. */
+    layer: HTMLElement;
+    /** Asa de mover, arriba a la izquierda de la tabla. */
+    move: HTMLButtonElement;
+    /** Asa de cambiar el tamaño, abajo a la derecha. */
+    resize: HTMLElement;
+    /** Botón redondo "+" entre dos filas o dos columnas. */
+    marker: HTMLButtonElement;
+    /** Línea que marca por dónde se inserta la fila o la columna. */
+    guide: HTMLElement;
+    /** Línea de inserción al arrastrar la tabla entre bloques. */
+    dropLine: HTMLElement;
+    /** Contorno de la tabla al arrastrarla o al cambiar su tamaño. */
+    ghost: HTMLElement;
+}
+export declare function createHandleElements(): TableHandleElements;
+/** Coloca un elemento de la capa (px de la capa); con tamaño, también lo dimensiona. */
+export declare function placeElement(element: HTMLElement, left: number, top: number, width?: number, height?: number): void;
+/** Texto del marcador "+" según lo que inserta. */
+export declare function describeMarker(marker: HTMLButtonElement, kind: 'row' | 'column'): void;

package/lib/components/document-editor/tables/handles/document-editor-table-handles-geometry.d.ts

@@ -0,0 +1,104 @@
+import { type Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { EditorView } from '@tiptap/pm/view';
+export declare const TABLE_NODE_NAME = "table";
+/** Clase del contenedor que dibuja cada tabla (lo crea `TableView`, ver `document-editor-table.ts`). */
+export declare const TABLE_WRAPPER_CLASS = "tableWrapper";
+/** Ancho mínimo de una columna (px CSS): el mismo que `document-editor-table.ts` fija a la librería. */
+export declare const MIN_COLUMN_WIDTH = 10;
+export interface Box {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+export interface Point {
+    x: number;
+    y: number;
+}
+/** Posición en pantalla del origen de la capa (cambia al desplazar el contenedor). */
+export type LayerOrigin = Point;
+export declare function readLayerOrigin(container: HTMLElement): LayerOrigin;
+export declare function toLayerBox(rect: Box, origin: LayerOrigin): Box;
+/** Zoom de la hoja (1 = 100 %): lo que separa los píxeles de pantalla de los CSS de la hoja. */
+export declare function readSheetZoom(sheet: HTMLElement): number;
+export interface TableEntry {
+    /** Posición del nodo de la tabla en el documento. */
+    position: number;
+    node: ProseMirrorNode;
+    /** Contenedor (`.tableWrapper`) que dibuja la tabla en la vista. */
+    wrapper: HTMLElement;
+    table: HTMLElement;
+    /** Tabla dentro del encabezado o del pie de página: no lleva asas. */
+    inRegion: boolean;
+}
+/** Todas las tablas del documento (también las anidadas en celdas) que la vista ya dibujó. */
+export declare function collectTables(view: EditorView): TableEntry[];
+/** Líneas de la cuadrícula de una tabla en la capa: una más que columnas (x) y que filas (y). */
+export interface TableGrid {
+    columnEdges: number[];
+    rowEdges: number[];
+}
+/**
+ * Líneas de la cuadrícula de la tabla, medidas con sus celdas: una celda que abarca varias columnas o filas aporta
+ * sus bordes a las líneas de los extremos. `null` si la tabla está mal formada.
+ */
+export declare function readTableGrid(view: EditorView, entry: TableEntry, box: Box, origin: LayerOrigin): TableGrid | null;
+export interface BoundaryHit {
+    kind: 'row' | 'column';
+    /** Fila o columna delante de la que se inserta (el número de filas o de columnas es "al final"). */
+    index: number;
+    /** Línea de la cuadrícula en la capa: `y` para una fila, `x` para una columna. */
+    edge: number;
+}
+/**
+ * Línea entre dos filas (puntero a la izquierda de la tabla) o entre dos columnas (puntero encima) más cercana al
+ * puntero. La primera línea (el borde de la tabla) no se ofrece: ahí está el asa de mover.
+ */
+export declare function findBoundary(point: Point, box: Box, grid: TableGrid): BoundaryHit | null;
+/** Medidas de una tabla en píxeles CSS de la hoja (lo que el cambio de tamaño escala). */
+export interface TableMeasures {
+    width: number;
+    height: number;
+    /** Ancho de cada columna de la cuadrícula. */
+    columnWidths: number[];
+    /** Alto de cada fila. */
+    rowHeights: number[];
+}
+/** Medidas actuales de la tabla (px CSS de la hoja), o `null` si está mal formada o no se dibujó. */
+export declare function measureTable(view: EditorView, entry: TableEntry, zoom: number): TableMeasures | null;
+/** Hueco entre dos hijos de un contenedor donde puede quedar la tabla. */
+export interface DropTarget {
+    /** Delante de qué hijo del contenedor queda (el número de hijos es "al final"), contando la tabla que se mueve. */
+    index: number;
+    /** Altura de la línea de inserción en la capa. */
+    y: number;
+    /** Ancho útil del contenedor en la capa: por donde va la línea y dentro de lo que flota una tabla con ajuste. */
+    span: {
+        left: number;
+        right: number;
+    };
+}
+/** Ancho útil (sin borde ni relleno) del contenedor de la tabla, en pantalla. */
+export declare function readParentSpan(view: EditorView, entry: TableEntry, zoom: number): {
+    left: number;
+    right: number;
+};
+/**
+ * Hueco entre los hermanos de la tabla (los hijos de su contenedor) más cercano a la altura del puntero. Antes del
+ * encabezado y después del pie de página no se puede soltar. `null` si no hay ninguno válido.
+ */
+export declare function findDropTarget(view: EditorView, entry: TableEntry, pointerY: number, origin: LayerOrigin, zoom: number): DropTarget | null;
+export interface FloatPlacement {
+    /** Lado hacia el que flota: la mitad del contenedor en la que queda el centro de la tabla. */
+    side: 'left' | 'right';
+    /** Distancia (pt) entre la tabla y el borde del contenedor del lado hacia el que flota. */
+    distance: number;
+}
+/**
+ * Lado y distancia al borde de una tabla flotante que se suelta con su esquina superior izquierda en `tableLeft` (capa).
+ * `tableWidth` y `span` son de la capa; el zoom pasa la distancia a los píxeles CSS de la hoja.
+ */
+export declare function floatPlacement(tableLeft: number, tableWidth: number, span: {
+    left: number;
+    right: number;
+}, zoom: number): FloatPlacement;

package/lib/components/document-editor/tables/handles/document-editor-table-handles.d.ts

@@ -0,0 +1,14 @@
+import { Extension } from '@tiptap/core';
+export interface DocumentTableHandlesOptions {
+    /**
+     * Selector del contenedor con desplazamiento donde se montan las asas. Se busca desde el DOM de la hoja hacia
+     * arriba; por defecto el lienzo de la librería (`.ate-content`).
+     */
+    containerSelector: string;
+    /**
+     * Dice si las asas se ofrecen ahora (por defecto siempre). Se consulta en cada dibujo y no vuelve a crear el editor al
+     * cambiar: el componente lo apaga con `showTools` en `false`, que deja solo el lienzo.
+     */
+    isEnabled: () => boolean;
+}
+export declare const DocumentTableHandles: Extension<DocumentTableHandlesOptions, any>;

package/lib/components/document-editor/tables/layout/alignment-grid/document-editor-alignment-grid.d.ts

@@ -0,0 +1,32 @@
+import { ElementRef } from '@angular/core';
+import type { DocumentCellAlignment, DocumentCellAlignmentChoice } from '../document-editor-table-layout';
+/** Posición de la cuadrícula: la alineación que aplica y su nombre para el `title` y el `aria-label`. */
+interface AlignmentOption extends DocumentCellAlignmentChoice {
+    label: string;
+}
+/**
+ * Cuadrícula de 3 × 3 botones con la alineación de las celdas (la de Word en el grupo "Alineación" de la pestaña Disposición
+ * de tabla): cada botón dibuja un bloque de texto en la posición que aplica. Se pone directamente en la cinta; no se abre ni se
+ * cierra, solo avisa la posición elegida. Ningún botón toma el foco al pulsarlo, así el editor conserva la selección; con el
+ * teclado las flechas, Inicio y Fin mueven el foco dentro de la cuadrícula (una sola posición es tabulable).
+ */
+export declare class DocumentEditorAlignmentGrid {
+    private readonly host;
+    constructor(host: ElementRef<HTMLElement>);
+    /** Alineación de las celdas seleccionadas; su posición se marca como activa. `null` fuera de una tabla. */
+    current: import("@angular/core").InputSignal<DocumentCellAlignment | null>;
+    picked: import("@angular/core").OutputEmitterRef<DocumentCellAlignmentChoice>;
+    readonly options: readonly AlignmentOption[];
+    /** Posición con el foco del teclado; `null` cuando el foco está fuera de la cuadrícula. */
+    private readonly focused;
+    /** Posición que corresponde a la alineación actual; -1 si las celdas no coinciden en alguno de los ejes. */
+    activeIndex: import("@angular/core").Signal<number>;
+    /** Posición que recibe el foco con Tab (tabulación itinerante): la del teclado, si no la activa y, si no, la primera. */
+    tabbableIndex: import("@angular/core").Signal<number>;
+    pick(option: AlignmentOption): void;
+    focusCell(index: number): void;
+    onFocusOut(event: FocusEvent): void;
+    /** Flechas, Inicio y Fin mueven el foco sin salir de la cuadrícula. */
+    onKeydown(event: KeyboardEvent): void;
+}
+export {};

package/lib/components/document-editor/tables/layout/cell-margins-menu/document-editor-cell-margins-menu.d.ts

@@ -0,0 +1,50 @@
+import { type DocumentSpinnerCommit } from '../../../ribbon/spinner/document-editor-spinner';
+import { type DocumentCellMarginScope, type DocumentCellMargins } from '../document-editor-table-layout';
+/** Lo que se aplica al aceptar el menú: los márgenes (cm) y dónde se aplican. */
+export interface DocumentCellMarginsRequest {
+    margins: DocumentCellMargins;
+    scope: DocumentCellMarginScope;
+}
+type MarginSide = keyof DocumentCellMargins;
+/**
+ * Contenido del menú "Márgenes de celda" de `document-editor` (el "Opciones de celda" de Word): los cuatro márgenes internos
+ * de las celdas, en cm, y si se aplican a las celdas seleccionadas o a toda la tabla. Se dibuja dentro de un `popover` del
+ * editor: no se abre ni se cierra solo, solo avisa lo elegido al aceptar (quien lo usa lo aplica y cierra el menú). Los
+ * campos se editan en un borrador: nada cambia en el documento hasta pulsar "Aceptar" (o Enter en un campo).
+ */
+export declare class DocumentEditorCellMarginsMenu {
+    /** Márgenes (cm) de las celdas seleccionadas; `null` si no declaran márgenes propios (el menú parte de los de Word). */
+    margins: import("@angular/core").InputSignal<DocumentCellMargins | null>;
+    applied: import("@angular/core").OutputEmitterRef<DocumentCellMarginsRequest>;
+    private readonly spinners;
+    private readonly menuId;
+    readonly titleId: string;
+    readonly scopeId: string;
+    readonly maxMargin = 5;
+    readonly fields: readonly {
+        side: MarginSide;
+        label: string;
+        icon: string;
+    }[];
+    /** Márgenes que muestran los campos (cm): los de la selección más lo que se escribió y confirmó en ellos. */
+    draft: import("@angular/core").WritableSignal<DocumentCellMargins>;
+    /** "Aplicar a toda la tabla". */
+    applyToTable: import("@angular/core").WritableSignal<boolean>;
+    private readonly current;
+    private readonly _syncDraftEffect;
+    onCommitted(side: MarginSide, { value, returnFocus }: DocumentSpinnerCommit): void;
+    onScopeChange(event: Event): void;
+    /** Vuelve el borrador a los márgenes por defecto de Word (no cambia el documento hasta aceptar). */
+    resetDefaults(): void;
+    /**
+     * Descarta lo que se editó sin aceptar: los campos vuelven a mostrar los márgenes de la selección y el ámbito, a las
+     * celdas seleccionadas. Quien abre y cierra el menú lo llama en cada cambio (`beforetoggle`): sin esto, lo escrito y
+     * confirmado en un campo se vería al volver a abrirlo aunque no se hubiera aplicado.
+     */
+    reset(): void;
+    private showDraft;
+    /** "Aceptar". */
+    apply(): void;
+    private emitApplied;
+}
+export {};

package/lib/components/document-editor/tables/layout/document-editor-table-layout.d.ts

@@ -0,0 +1,92 @@
+import type { Editor } from '@tiptap/core';
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { EditorState } from '@tiptap/pm/state';
+import type { EditorView } from '@tiptap/pm/view';
+import { type DocumentTableWidthMode } from '../../format/document-editor-commands';
+/** Cómo se reparte el ancho de la tabla (el "Autoajustar" de Word); los mismos valores que "Insertar tabla…". */
+export type DocumentTableAutofit = DocumentTableWidthMode;
+export type DocumentCellVerticalAlign = 'top' | 'middle' | 'bottom';
+export type DocumentCellHorizontalAlign = 'left' | 'center' | 'right';
+export type DocumentCellTextDirection = 'horizontal' | 'rotate90' | 'rotate270';
+/** Dónde se aplican los márgenes de celda: a las celdas seleccionadas o a todas las de la tabla. */
+export type DocumentCellMarginScope = 'selection' | 'table';
+/** Alineación elegida en la cuadrícula de 9 posiciones. */
+export interface DocumentCellAlignmentChoice {
+    vertical: DocumentCellVerticalAlign;
+    horizontal: DocumentCellHorizontalAlign;
+}
+/** Alineación de las celdas seleccionadas; un eje es `null` si las celdas no coinciden en él (o, el horizontal, si es "justificado"). */
+export interface DocumentCellAlignment {
+    vertical: DocumentCellVerticalAlign | null;
+    horizontal: DocumentCellHorizontalAlign | null;
+}
+/** Márgenes internos de una celda, en cm. */
+export interface DocumentCellMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+/**
+ * Disposición de la tabla donde está la selección. Es un objeto aparte del estado de la cinta (`DocumentFormatState`):
+ * éste se compara campo a campo con `===` y un objeto nuevo en cada transacción la redibujaría siempre. Se compara con
+ * `sameTableLayoutState`.
+ */
+export interface DocumentTableLayoutState {
+    /** Alto (cm) de las filas que toca la selección; `null` si no declaran uno (alto automático) o no coinciden. */
+    rowHeightCm: number | null;
+    /** Ancho (cm) de las columnas que toca la selección; `null` si no se conoce o no coinciden. */
+    columnWidthCm: number | null;
+    alignment: DocumentCellAlignment | null;
+    textDirection: DocumentCellTextDirection | null;
+    /** Márgenes (cm) de las celdas seleccionadas; `null` si no declaran márgenes propios o no coinciden. */
+    margins: DocumentCellMargins | null;
+    /** Autoajuste de la tabla; `null` fuera de una tabla. */
+    autofit: DocumentTableAutofit | null;
+}
+export declare const EMPTY_TABLE_LAYOUT_STATE: DocumentTableLayoutState;
+/** Márgenes por defecto de una celda de Word: 0 arriba y abajo, 0,19 cm a los lados. */
+export declare const DEFAULT_CELL_MARGINS_CM: DocumentCellMargins;
+/** Opciones del menú "Autoajustar" de la cinta (texto e icono de Material Symbols). */
+export declare const DOCUMENT_TABLE_AUTOFIT_MODES: readonly {
+    value: DocumentTableAutofit;
+    label: string;
+    hint: string;
+    icon: string;
+}[];
+/** Opciones de "Dirección del texto" (el botón de la cinta las recorre en este orden con `nextTextDirection`). */
+export declare const DOCUMENT_CELL_TEXT_DIRECTIONS: readonly {
+    value: DocumentCellTextDirection;
+    label: string;
+    icon: string;
+}[];
+export declare function sameMargins(a: DocumentCellMargins | null, b: DocumentCellMargins | null): boolean;
+/** Igualdad de dos disposiciones, para el `equal` de la señal que las guarda (ver `DocumentTableLayoutState`). */
+export declare function sameTableLayoutState(a: DocumentTableLayoutState, b: DocumentTableLayoutState): boolean;
+/** Siguiente dirección del texto al pulsar el botón: horizontal → 90° → 270° → horizontal (con celdas distintas, 90°). */
+export declare function nextTextDirection(current: DocumentCellTextDirection | null): DocumentCellTextDirection;
+/**
+ * Quita de las `<col>` de la vista de una tabla el `width` de las columnas que ya no tienen `colwidth`. La vista de la
+ * librería (`TableView`) solo escribe el ancho de una columna con ancho y, cuando deja de tenerlo, escribe el mínimo pero no
+ * borra el ancho anterior: la tabla seguiría dibujándose con las columnas de antes (al pasar a "Autoajustar al contenido" o
+ * al deshacer un cambio de ancho). `wrapper` es el contenedor de la vista de la tabla (`view.nodeDOM(posición)`) y `table`
+ * su nodo. Solo cambia el DOM de la vista: el documento y el HTML guardado no se tocan. La llaman los comandos de este
+ * archivo y debería llamarla también `syncTableStyle` (`document-editor-table.ts`) en cada cambio del documento, para cubrir
+ * deshacer y rehacer.
+ */
+export declare function removeStaleColumnWidths(wrapper: HTMLElement, table: ProseMirrorNode): void;
+export declare function setTableAutofit(editor: Editor, mode: DocumentTableAutofit, focus?: boolean): void;
+export declare function setColumnWidth(editor: Editor, centimeters: number, focus?: boolean): void;
+export declare function distributeColumns(editor: Editor, focus?: boolean): void;
+export declare function setRowHeight(editor: Editor, centimeters: number, focus?: boolean): void;
+export declare function distributeRows(editor: Editor, focus?: boolean): void;
+export declare function setCellAlignment(editor: Editor, vertical: DocumentCellVerticalAlign, horizontal: DocumentCellHorizontalAlign, focus?: boolean): void;
+export declare function setCellTextDirection(editor: Editor, direction: DocumentCellTextDirection, focus?: boolean): void;
+export declare function setCellMargins(editor: Editor, margins: DocumentCellMargins, scope?: DocumentCellMarginScope, focus?: boolean): void;
+/**
+ * Disposición de la tabla donde está la selección (ver `DocumentTableLayoutState`). Corre en cada cambio de selección, así
+ * que solo lee estilos en línea; recorre las celdas de la tabla, por lo que conviene llamarla solo con el cursor en una tabla.
+ * Con `view` (la del mismo documento) se mide además el ancho con que se dibujan las columnas que no declaran uno: eso lee el
+ * DOM y puede forzar un reflujo, úsese solo mientras se ve la pestaña de la tabla.
+ */
+export declare function readTableLayoutState(state: EditorState, view?: EditorView): DocumentTableLayoutState;

package/lib/components/document-editor/tables/styles/document-editor-table-design-extension.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const DocumentTableDesign: Extension<any, any>;

package/lib/components/document-editor/tables/styles/document-editor-table-design-state.d.ts

@@ -0,0 +1,23 @@
+import type { Node as ProseMirrorNode } from '@tiptap/pm/model';
+import type { Selection } from '@tiptap/pm/state';
+import { type TableLook } from './document-editor-table-styles';
+export interface TableDesignState {
+    /** Código del estilo aplicado (ver `DOCUMENT_TABLE_STYLES`); `null` si la tabla no tiene o el cursor no está en una. */
+    tableStyle: string | null;
+    /** Opciones de estilo; todas apagadas si la tabla no tiene estilo o el cursor no está en una tabla. */
+    look: TableLook;
+}
+/** Estado fuera de una tabla (o de una tabla sin estilo). */
+export declare const EMPTY_TABLE_DESIGN_STATE: TableDesignState;
+/**
+ * Tabla más interna alrededor de la selección: la del cursor o, con celdas seleccionadas, la de esas celdas.
+ * Se lee el nodo por nombre, nunca con `instanceof` (la aplicación y la librería cargan copias distintas de
+ * ProseMirror).
+ */
+export declare function findInnermostTable({ $from }: Selection): ProseMirrorNode | null;
+/** Estilo y opciones que guarda una tabla en sus atributos. */
+export declare function readTableDesign(table: ProseMirrorNode): TableDesignState;
+/** Estilo de tabla y opciones de estilo de la tabla del cursor (la más interna), o el estado vacío fuera de una tabla. */
+export declare function readTableDesignState({ selection }: {
+    selection: Selection;
+}): TableDesignState;

package/lib/components/document-editor/tables/styles/document-editor-table-design.d.ts

@@ -0,0 +1,39 @@
+import type { Editor } from '@tiptap/core';
+import type { EditorState, Transaction } from '@tiptap/pm/state';
+import { type TableLook, type TableLookFlag } from './document-editor-table-styles';
+/**
+ * Aplica el estilo `styleId` (un código de `DOCUMENT_TABLE_STYLES`) a la tabla más interna alrededor de la selección,
+ * dentro de la transacción `tr` (para encadenarlo con otros pasos). `null` quita el estilo: las celdas quedan sin
+ * bordes ni relleno y se quitan los atributos `tableStyle` y `tableLook`. Un código que no está en el catálogo no hace
+ * nada. Sin `look` se conservan las opciones de la tabla (o, si no tenía estilo, las de Word: encabezado y filas con
+ * bandas). Pisa el formato propio de las celdas. Si nada cambia no agrega pasos a la transacción.
+ */
+export declare function applyTableStyleToTransaction(tr: Transaction, styleId: string | null, look?: TableLook): void;
+/**
+ * Aplica un estilo de tabla (ver `applyTableStyleToTransaction`) a la tabla donde está el cursor, en un solo paso al
+ * deshacer. `null` es "Sin estilo".
+ */
+export declare function applyTableStyle(editor: Editor, styleId: string | null, look?: TableLook): void;
+/**
+ * Activa o desactiva una opción de estilo de tabla (fila de encabezado, filas con bandas…) y vuelve a aplicar el
+ * estilo de la tabla con las opciones nuevas. Una opción solo se ve a través de un estilo: si la tabla no tiene
+ * estilo (o tiene uno que ya no existe) no se puede cambiar y no hace nada (la cinta deshabilita las casillas). Solo
+ * se reescriben las celdas que todavía llevan el formato del estilo: lo puesto a mano en otras se conserva.
+ */
+export declare function setTableLookOption(editor: Editor, flag: TableLookFlag, enabled: boolean): void;
+/**
+ * Vuelve a aplicar a la tabla del cursor su propio estilo y opciones en todas sus celdas (es lo que hace "Volver a
+ * aplicar el estilo": quita el sombreado y los bordes puestos a mano). Sin estilo no hace nada. Las filas y columnas
+ * nuevas no lo necesitan: el estilo se mantiene solo (ver `restyleResizedTables`).
+ */
+export declare function refreshTableStyle(editor: Editor): void;
+/**
+ * Mantiene el estilo de las tablas cuando cambia su número de filas o de columnas: cada fila o columna que se agrega
+ * o se quita, sea desde la cinta, los "+" de las asas, Tab en la última celda, los menús de la librería o al deshacer,
+ * corre las bandas y los bordes del estilo, y las celdas nuevas nacen con el formato de una vecina (la de un
+ * encabezado, por ejemplo). Es el `appendTransaction` de `documentTableDesign` (ver
+ * `document-editor-table-design-extension.ts`): la transacción que devuelve va en el mismo paso al deshacer.
+ * Solo se reescriben las celdas nuevas y las que todavía llevan el formato del estilo antes del cambio (el sombreado y
+ * los bordes puestos a mano en otras se conservan). Una tabla sin estilo (o con uno que ya no existe) no se toca.
+ */
+export declare function restyleResizedTables(transactions: readonly Transaction[], oldState: EditorState, newState: EditorState): Transaction | null;

package/lib/components/document-editor/tables/styles/document-editor-table-styles.d.ts

@@ -0,0 +1,114 @@
+/** Atributos HTML con los que la tabla guarda el código de su estilo y sus opciones (ver `document-editor-table-design-extension.ts`). */
+export declare const TABLE_STYLE_ATTRIBUTE = "data-table-style";
+export declare const TABLE_LOOK_ATTRIBUTE = "data-table-look";
+/** Las seis opciones de estilo de tabla de Word ("Fila de encabezado", "Filas con bandas"…). */
+export type TableLookFlag = 'headerRow' | 'totalRow' | 'bandedRows' | 'firstColumn' | 'lastColumn' | 'bandedColumns';
+export interface TableLook {
+    readonly headerRow: boolean;
+    readonly totalRow: boolean;
+    readonly bandedRows: boolean;
+    readonly firstColumn: boolean;
+    readonly lastColumn: boolean;
+    readonly bandedColumns: boolean;
+}
+/** Opciones en el orden de Word, con su texto para la cinta. */
+export declare const TABLE_LOOK_OPTIONS: readonly {
+    flag: TableLookFlag;
+    label: string;
+}[];
+/** Todas las opciones apagadas: lo que tiene una tabla sin estilo. */
+export declare const NO_TABLE_LOOK: TableLook;
+/** Opciones con las que se aplica un estilo a una tabla que no tenía: las de Word (encabezado y filas con bandas). */
+export declare const DEFAULT_TABLE_LOOK: TableLook;
+/** Lee el atributo `tableLook` (`hr,br`); lo que falta o no se entiende cuenta como apagado. */
+export declare function parseTableLook(value: unknown): TableLook;
+/** Escribe las opciones activas como lista de códigos, siempre en el mismo orden (`hr,br,fc`); sin ninguna, vacío. */
+export declare function serializeTableLook(look: TableLook): string;
+/** Borde de una orilla de celda: grosor en puntos y color `#RRGGBB`. Sin borde se usa `null`. */
+export interface TableBorderSpec {
+    width: number;
+    color: string;
+}
+/** Contorno de la tabla: sus cuatro orillas exteriores. */
+export interface TableOutline {
+    top: TableBorderSpec | null;
+    right: TableBorderSpec | null;
+    bottom: TableBorderSpec | null;
+    left: TableBorderSpec | null;
+}
+/** Formato que una parte de la tabla (encabezado, totales, primera o última columna) suma al de la tabla. */
+export interface TableStylePart {
+    /** Relleno `#RRGGBB`. */
+    fill?: string;
+    /** Color del texto `#RRGGBB`. */
+    color?: string;
+    bold?: boolean;
+}
+export interface TableStylePreset {
+    /** Código interno; es lo que se guarda en el atributo `tableStyle` de la tabla. */
+    id: string;
+    label: string;
+    outline: TableOutline;
+    /** Líneas entre filas y entre columnas. */
+    insideH: TableBorderSpec | null;
+    insideV: TableBorderSpec | null;
+    /** Línea bajo la fila de encabezado y sobre la fila de totales; sin ella (`undefined`) valen las de `insideH`. */
+    headerBottom?: TableBorderSpec | null;
+    totalTop?: TableBorderSpec | null;
+    /** Relleno de las bandas (filas y columnas alternas, empezando por la primera tras el encabezado); `null`: sin. */
+    band: string | null;
+    header: TableStylePart;
+    total: TableStylePart;
+    firstColumn: TableStylePart;
+    lastColumn: TableStylePart;
+}
+export declare const DOCUMENT_TABLE_STYLES: readonly TableStylePreset[];
+/** Estilo del catálogo con ese código, o `null` si no existe (o no hay código). */
+export declare function findTableStylePreset(id: string | null | undefined): TableStylePreset | null;
+/** Dónde está una celda en la cuadrícula de la tabla (0 es la primera fila y columna) y cuántas abarca. */
+export interface TableCellPosition {
+    row: number;
+    column: number;
+    rowSpan: number;
+    colSpan: number;
+}
+export interface TableGridSize {
+    rows: number;
+    columns: number;
+}
+/** Formato que un estilo da a una celda: lo único que el estilo escribe en ella. */
+export interface ResolvedTableCellStyle {
+    top: TableBorderSpec | null;
+    right: TableBorderSpec | null;
+    bottom: TableBorderSpec | null;
+    left: TableBorderSpec | null;
+    /** Relleno `#RRGGBB`; `null` sin relleno. */
+    background: string | null;
+    /** Color del texto `#RRGGBB`; `null` el automático. */
+    color: string | null;
+    bold: boolean;
+}
+/** Declaración CSS de un borde (`0.5pt solid #000000`) o `none`. */
+export declare function tableBorderToCss(border: TableBorderSpec | null): string;
+/**
+ * Cómo queda una celda con `preset` y las opciones `look`. Las capas se aplican de menor a mayor prioridad, como las
+ * partes condicionales de un estilo de Word: tabla entera, columnas con bandas, filas con bandas, primera columna,
+ * última columna, fila de encabezado y fila de totales. Las bandas de filas cuentan desde la primera fila después
+ * del encabezado, y las de columnas desde la primera después de la primera columna; la primera, la última columna y
+ * las filas de encabezado y de totales no llevan banda.
+ * Los bordes salen de la orilla de la tabla donde está cada lado de la celda, así las dos celdas que comparten una
+ * orilla (aunque estén combinadas) dibujan el mismo borde.
+ */
+export declare function resolveTableCellStyle(preset: TableStylePreset, look: TableLook, cell: TableCellPosition, grid: TableGridSize): ResolvedTableCellStyle;
+/** Filas y columnas de la tabla pequeña que dibuja la miniatura de la galería. */
+export declare const TABLE_STYLE_PREVIEW_ROWS = 4;
+export declare const TABLE_STYLE_PREVIEW_COLUMNS = 5;
+/** Formato de cada celda de una tabla de muestra (4 × 5) con `preset` y `look`, para dibujar la miniatura. */
+export declare function buildTableStylePreview(preset: TableStylePreset, look: TableLook): ResolvedTableCellStyle[][];
+/** Contraste mínimo (WCAG, texto grande) entre el color de una letra y el relleno de su celda para dejarla como está. */
+export declare const MIN_TEXT_CONTRAST = 3;
+/**
+ * Contraste (de 1 a 21) entre el color de una letra y un relleno, ambos `#RGB`, `#RRGGBB` o `rgb(…)`; `null` si alguno no
+ * se entiende (en ese caso no se puede decir que la letra no se lea).
+ */
+export declare function contrastRatio(foreground: string, background: string): number | null;