@cbm-common/cbm-types 0.0.366 → 0.0.367

package/lib/components/document-editor/clipboard/document-editor-node-ids.d.ts

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

package/lib/components/document-editor/clipboard/document-editor-paste.d.ts

@@ -0,0 +1,3 @@
+import { Extension } from '@tiptap/core';
+export declare const removeImages: (html: string) => string;
+export declare const DocumentPaste: Extension<any, any>;

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

@@ -0,0 +1,421 @@
+import { DestroyRef, ElementRef, Injector } from '@angular/core';
+import { ControlValueAccessor, FormControl, FormGroup } from '@angular/forms';
+import { CbmNotificationService } from '../../domain/services/notification/notification.service';
+import { AteEditorConfig, AteI18nService } from '@flogeez/angular-tiptap-editor';
+import { Editor, type ChainedCommands } from '@tiptap/core';
+import { DocumentCapturedFormat, DocumentTextCase } from './format/document-editor-commands';
+import { DocumentDefaults } from './format/document-editor-defaults';
+import { DocumentBlockStyle, DocumentFormatState, DocumentTableFloat, DocumentTextAlign } from './format/document-editor-format-state';
+import { DocumentListPanelMode } from './lists/list-panel/document-editor-list-panel';
+import { DocumentListCollection, DocumentVariable, DocumentVariablesCatalog } from './nodes/document-editor-node-types';
+import { DocumentSchemaCategorySource, DocumentVariablesConfig, DocumentVariablesStatus } from './variables/document-editor-schema';
+import { DocumentBorderLineStyle, DocumentBorderPen, DocumentBorderTarget } from './tables/borders/document-editor-table-borders';
+import { DocumentCellMarginsRequest } from './tables/layout/cell-margins-menu/document-editor-cell-margins-menu';
+import { DocumentCellAlignmentChoice, DocumentTableAutofit, DocumentTableLayoutState } from './tables/layout/document-editor-table-layout';
+import { DocumentTableSelectPart } from './tables/document-editor-table-select';
+import { TableLookFlag } from './tables/styles/document-editor-table-styles';
+import { DocumentFieldKind, DocumentRegionKind } from './page/document-editor-page-nodes';
+import { DocumentSpinnerCommit } from './ribbon/spinner/document-editor-spinner';
+import { DocumentTableRequest } from './tables/table-dialog/document-editor-table-dialog';
+import { DocumentMarginPreset, DocumentPageMarginSide, DocumentPageMargins, DocumentPageOrientation, DocumentPageSize } from './page/document-editor-pages';
+type DocumentRibbonTab = 'home' | 'insert' | 'layout' | 'tableDesign' | 'tableLayout';
+interface DocumentRibbonTabOption {
+    value: DocumentRibbonTab;
+    label: string;
+    contextual: boolean;
+}
+type DocumentRibbonCommand = 'undo' | 'redo' | 'bold' | 'italic' | 'underline' | 'strike' | 'subscript' | 'superscript' | 'bulletList' | 'orderedList' | 'horizontalRule' | 'addRowBefore' | 'addRowAfter' | 'addColumnBefore' | 'addColumnAfter' | 'deleteRow' | 'deleteColumn' | 'deleteTable' | 'mergeCells' | 'splitCell';
+/**
+ * Editor de documentos (HTML), usable con `[formControl]`.
+ *
+ * Objetivo: que sea un editor tipo Word (documento con formato completo). La base es Tiptap OSS
+ * (`@flogeez/angular-tiptap-editor`) y se irá adaptando a nuestras necesidades: de momento este
+ * componente es solo una envoltura — el valor del control es el HTML del documento y el
+ * comportamiento lo resuelve la librería, que aún NO cubre lo propio de Word (páginas con saltos,
+ * reglas, márgenes, encabezado y pie, tamaño de hoja).
+ * Las pantallas consumen únicamente `<document-editor>` y sus inputs: cada adaptación (extensiones
+ * de Tiptap, toolbar, estilos) se agrega aquí adentro, sin tocar a los consumidores.
+ */
+export declare class CbmDocumentEditorComponent implements ControlValueAccessor {
+    private readonly destroyRef;
+    private readonly host;
+    private readonly injector;
+    private readonly i18nService;
+    private readonly notificationService;
+    constructor(destroyRef: DestroyRef, host: ElementRef<HTMLElement>, injector: Injector, i18nService: AteI18nService, notificationService: CbmNotificationService);
+    placeholder: import("@angular/core").InputSignal<string>;
+    /** Alto mínimo y máximo (px) de la ventana del lienzo; la hoja se desplaza dentro de ella. */
+    minHeight: import("@angular/core").InputSignal<number>;
+    maxHeight: import("@angular/core").InputSignal<number>;
+    /** Muestra en la cinta (pestaña "Disposición") el tamaño, la orientación y los márgenes de la hoja. */
+    showPageSetup: import("@angular/core").InputSignal<boolean>;
+    /** Ancho (px) del panel lateral cuando está desplegado; el lienzo ocupa el resto. */
+    sidePanelWidth: import("@angular/core").InputSignal<number>;
+    /** Activa el menú de clic derecho sobre el texto seleccionado, con la opción "Convertir a nodo". */
+    enableNodeConversion: import("@angular/core").InputSignal<boolean>;
+    /** Muestra las herramientas de edición (pestañas "Inicio", "Insertar", "Diseño de tabla" y "Disposición de tabla" de la cinta, menús y asas de tabla). Con `false` queda solo el lienzo. */
+    showTools: import("@angular/core").InputSignal<boolean>;
+    /** Muestra el botón para importar un documento de Word (.docx) al editor. Requiere `showTools`. */
+    enableWordImport: import("@angular/core").InputSignal<boolean>;
+    /** Sobrescribe la configuración estándar del editor (se aplica encima de los valores por defecto). */
+    config: import("@angular/core").InputSignal<AteEditorConfig>;
+    /**
+     * Variables tal como las entrega el backend del consumidor (categorías con campos o subcategorías); el editor las
+     * normaliza con `variablesConfig`. `null`/`undefined`: todavía no llegan. `[]`: llegaron y no hay ninguna.
+     */
+    variables: import("@angular/core").InputSignal<readonly DocumentSchemaCategorySource[] | null | undefined>;
+    /** Estado de la carga de `variables`, que lleva el consumidor. Sin enlazar se deduce de `variables`. */
+    variablesStatus: import("@angular/core").InputSignal<DocumentVariablesStatus | null | undefined>;
+    /**
+     * Reglas para normalizar `variables`: cada clave que se pasa reemplaza entera a la de `DEFAULT_DOCUMENT_VARIABLES_CONFIG`.
+     * Debe ser una referencia estable (una constante), no un objeto nuevo en cada detección de cambios.
+     */
+    variablesConfig: import("@angular/core").InputSignal<Partial<DocumentVariablesConfig> | null | undefined>;
+    sidePanelOpen: import("@angular/core").ModelSignal<boolean>;
+    fullscreen: import("@angular/core").ModelSignal<boolean>;
+    pageSize: import("@angular/core").ModelSignal<DocumentPageSize>;
+    orientation: import("@angular/core").ModelSignal<DocumentPageOrientation>;
+    margins: import("@angular/core").ModelSignal<DocumentPageMargins>;
+    defaults: import("@angular/core").ModelSignal<DocumentDefaults>;
+    /**
+     * El editor necesita que se vuelvan a pedir las variables: se pulsó "Reintentar" en un panel o se pidió la vista
+     * previa después de una carga fallida. El consumidor las pide y actualiza `variables` y `variablesStatus`.
+     */
+    variablesRetry: import("@angular/core").OutputEmitterRef<void>;
+    readonly zoomMin = 25;
+    readonly zoomMax = 200;
+    private readonly editorId;
+    readonly fontFamilyInputId: string;
+    readonly fontSizeInputId: string;
+    readonly marginsPopoverId: string;
+    readonly blockStyleInputId: string;
+    readonly ribbonPanelId: string;
+    readonly popoverIds: {
+        readonly textCase: `document-editor-text-case-${number}`;
+        readonly highlight: `document-editor-highlight-${number}`;
+        readonly fontColor: `document-editor-font-color-${number}`;
+        readonly lineSpacing: `document-editor-line-spacing-${number}`;
+        readonly table: `document-editor-table-${number}`;
+        readonly link: `document-editor-link-${number}`;
+        readonly symbol: `document-editor-symbol-${number}`;
+        readonly tableDelete: `document-editor-table-delete-${number}`;
+        readonly shading: `document-editor-shading-${number}`;
+        readonly borders: `document-editor-borders-${number}`;
+        readonly tableStyles: `document-editor-table-styles-${number}`;
+        readonly borderStyle: `document-editor-border-style-${number}`;
+        readonly borderWeight: `document-editor-border-weight-${number}`;
+        readonly borderColor: `document-editor-border-color-${number}`;
+        readonly tableAutofit: `document-editor-table-autofit-${number}`;
+        readonly tableWrap: `document-editor-table-wrap-${number}`;
+        readonly tableSelect: `document-editor-table-select-${number}`;
+        readonly cellMargins: `document-editor-cell-margins-${number}`;
+        readonly orientation: `document-editor-orientation-${number}`;
+        readonly pageSize: `document-editor-page-size-menu-${number}`;
+        readonly breaks: `document-editor-breaks-${number}`;
+    };
+    readonly tableLookOptions: readonly {
+        flag: TableLookFlag;
+        label: string;
+    }[];
+    readonly autofitModes: readonly {
+        value: DocumentTableAutofit;
+        label: string;
+        hint: string;
+        icon: string;
+    }[];
+    readonly tableSelectOptions: readonly import("./tables/document-editor-table-select").DocumentTableSelectOption[];
+    readonly tableWrapOptions: ReadonlyArray<{
+        value: DocumentTableFloat | null;
+        label: string;
+        icon: string;
+        hint: string;
+    }>;
+    readonly wordImportAccept = ".docx,.dotx,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.openxmlformats-officedocument.wordprocessingml.template";
+    readonly fonts: readonly import("./format/document-editor-typography").DocumentFont[];
+    readonly fontSizes: readonly number[];
+    readonly blockStyles: readonly {
+        value: DocumentBlockStyle;
+        label: string;
+        fontSize: string;
+        fontWeight: number;
+    }[];
+    readonly textCases: readonly {
+        value: DocumentTextCase;
+        label: string;
+    }[];
+    readonly lineSpacings: readonly {
+        value: number;
+        label: string;
+    }[];
+    readonly marginFields: readonly {
+        side: DocumentPageMarginSide;
+        label: string;
+    }[];
+    readonly marginPresets: {
+        hint: string;
+        value: string;
+        label: string;
+        margins: DocumentPageMargins;
+    }[];
+    readonly pageSizeMenu: {
+        value: DocumentPageSize;
+        label: string;
+        dimensions: string;
+    }[];
+    private readonly menuElement;
+    private readonly marginsElement;
+    private readonly modalConfirm;
+    private readonly tableDialog;
+    protected readonly theme: import("@angular/core").WritableSignal<"light" | "dark">;
+    /** Zoom de la hoja en % (solo de vista: no se guarda con el documento). */
+    zoom: import("@angular/core").WritableSignal<number>;
+    /** Editor Tiptap ya creado (lo necesita el panel de nodos para leer y modificar el documento). */
+    tiptap: import("@angular/core").WritableSignal<Editor | null>;
+    /** Nodo cuyas propiedades muestra el panel lateral. */
+    activeNodeId: import("@angular/core").WritableSignal<string | null>;
+    /** Tabla de listado que muestra el panel lateral (en lugar de un nodo): asistente o fila repetible. */
+    listPanel: import("@angular/core").WritableSignal<{
+        mode: DocumentListPanelMode;
+        position: number;
+        collection: DocumentListCollection | null;
+    } | null>;
+    /** El clic derecho fue dentro de una fila de tabla (se ofrece "Fila repetible"). */
+    menuInTableRow: import("@angular/core").WritableSignal<boolean>;
+    /** Vista previa: la hoja de solo lectura llena con datos de ejemplo, en lugar del lienzo. */
+    previewOpen: import("@angular/core").WritableSignal<boolean>;
+    /** HTML de la vista previa (la plantilla ya llena). */
+    previewHtml: import("@angular/core").WritableSignal<string>;
+    /** Menú de clic derecho: "insert" (submenú Nodos) o "remove" (sobre un nodo existente). */
+    menuMode: import("@angular/core").WritableSignal<"remove" | "insert">;
+    /** Hay un texto seleccionado que se puede convertir en nodo de texto. */
+    menuCanConvertText: import("@angular/core").WritableSignal<boolean>;
+    submenuOpen: import("@angular/core").WritableSignal<boolean>;
+    submenuSide: import("@angular/core").WritableSignal<"left" | "right">;
+    /** Lista de márgenes de la barra desplegada (para `aria-expanded` del botón). */
+    marginsOpen: import("@angular/core").WritableSignal<boolean>;
+    /** Fuente del texto donde está el cursor cuando no es ninguna de la lista (se muestra como sugerencia). */
+    unknownFontName: import("@angular/core").WritableSignal<string | null>;
+    /** Se está leyendo un documento de Word para importarlo. */
+    importing: import("@angular/core").WritableSignal<boolean>;
+    /** El formulario deshabilitó el editor: no se puede importar. */
+    formDisabled: import("@angular/core").WritableSignal<boolean>;
+    /** El documento tiene encabezado / pie de página. */
+    hasHeader: import("@angular/core").WritableSignal<boolean>;
+    hasFooter: import("@angular/core").WritableSignal<boolean>;
+    /** El cursor está dentro del encabezado o del pie (donde se pueden insertar los campos de página). */
+    inRegion: import("@angular/core").WritableSignal<boolean>;
+    /** Páginas que ocuparía el documento (aproximado: la hoja no se pagina, ver `observePageCount`). */
+    pageCount: import("@angular/core").WritableSignal<number>;
+    /** Formato del texto donde está el cursor: marca los botones activos de la cinta (como en Word). */
+    formatState: import("@angular/core").WritableSignal<DocumentFormatState>;
+    private readonly selectedTab;
+    /** Menú desplegable de la cinta abierto (para `aria-expanded` y el resaltado de su botón). */
+    openPopover: import("@angular/core").WritableSignal<string | null>;
+    lastFontColor: import("@angular/core").WritableSignal<string>;
+    lastHighlight: import("@angular/core").WritableSignal<string>;
+    lastShading: import("@angular/core").WritableSignal<string>;
+    /** Pluma de los bordes (estilo, grosor y color de la línea): la usan el menú "Bordes" y "Copiar borde". Persiste hasta que se elija otra. */
+    borderPen: import("@angular/core").WritableSignal<DocumentBorderPen>;
+    /** "Copiar borde" activo: cada clic sobre el borde de una celda le pone la pluma (lo apaga Esc o volver a pulsar el botón). */
+    borderPainterActive: import("@angular/core").WritableSignal<boolean>;
+    /**
+     * Disposición de la tabla del cursor (alto, ancho, alineación, márgenes…) para los campos de "Disposición de tabla".
+     * Aparte de `formatState`: es un objeto anidado, que su igualdad por `===` redibujaría en cada transacción, y solo se
+     * lee con esa pestaña a la vista (recorre las celdas y mide columnas del DOM).
+     */
+    tableLayout: import("@angular/core").WritableSignal<DocumentTableLayoutState>;
+    /** "Copiar formato" activo: el formato copiado, que se aplica al próximo texto que se seleccione. */
+    painting: import("@angular/core").WritableSignal<DocumentCapturedFormat | null>;
+    /** El panel lateral muestra "Buscar y reemplazar" (en lugar de un nodo o una tabla de listado). */
+    findPanelOpen: import("@angular/core").WritableSignal<boolean>;
+    /** Categoría de la fila repetible donde está el cursor (el panel de variables lo avisa en su grupo). */
+    cursorRowCollection: import("@angular/core").WritableSignal<string | null>;
+    private menuPosition;
+    private removeNodeId;
+    pageDimensions: import("@angular/core").Signal<{
+        width: number;
+        height: number;
+    }>;
+    fontSizeCss: import("@angular/core").Signal<string>;
+    spaceAfterCss: import("@angular/core").Signal<string>;
+    lineHeightCss: import("@angular/core").Signal<number>;
+    sheetMargins: import("@angular/core").Signal<DocumentPageMargins>;
+    activeMarginPreset: import("@angular/core").Signal<string | null>;
+    private readonly inTable;
+    ribbonTabs: import("@angular/core").Signal<readonly DocumentRibbonTabOption[]>;
+    activeTab: import("@angular/core").Signal<DocumentRibbonTab | null>;
+    currentLineSpacing: import("@angular/core").Signal<number>;
+    currentSpaceBefore: import("@angular/core").Signal<number>;
+    currentSpaceAfter: import("@angular/core").Signal<number>;
+    indentLeftCm: import("@angular/core").Signal<number>;
+    indentRightCm: import("@angular/core").Signal<number>;
+    sheetTextWidthCm: import("@angular/core").Signal<number>;
+    tableHasStyle: import("@angular/core").Signal<boolean>;
+    tableWrap: import("@angular/core").Signal<{
+        value: DocumentTableFloat | null;
+        label: string;
+        icon: string;
+        hint: string;
+    }>;
+    textDirection: import("@angular/core").Signal<{
+        value: import("./tables/layout/document-editor-table-layout").DocumentCellTextDirection;
+        label: string;
+        icon: string;
+    }>;
+    private readonly tiptapExtensions;
+    editorConfig: import("@angular/core").Signal<AteEditorConfig>;
+    previewConfig: import("@angular/core").Signal<AteEditorConfig>;
+    private readonly resolvedVariablesConfig;
+    protected readonly catalog: import("@angular/core").Signal<DocumentVariablesCatalog>;
+    protected readonly resolvedVariablesStatus: import("@angular/core").Signal<DocumentVariablesStatus>;
+    editorControl: FormControl<string>;
+    fontFamilyControl: FormControl<string | null>;
+    fontSizeControl: FormControl<number | null>;
+    blockStyleControl: FormControl<DocumentBlockStyle | null>;
+    marginsForm: FormGroup<{
+        top: FormControl<string>;
+        right: FormControl<string>;
+        bottom: FormControl<string>;
+        left: FormControl<string>;
+    }>;
+    private readonly _lockPageScrollEffect;
+    private readonly _syncMarginsFormEffect;
+    private readonly _remeasurePagesEffect;
+    private variablesPanelStarted;
+    private readonly _openVariablesPanelEffect;
+    private readonly _resetFindPanelEffect;
+    private readonly _resetPopoversEffect;
+    private readonly _stopBorderPainterEffect;
+    private readonly _syncTableLayoutEffect;
+    private onChange;
+    onTouched: () => void;
+    writeValue(value: string | null): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    setZoom(value: number): void;
+    zoomOut(): void;
+    zoomIn(): void;
+    onZoomInput(event: Event): void;
+    selectTab(tab: DocumentRibbonTab): void;
+    ribbonTabId(tab: DocumentRibbonTab): string;
+    onRibbonTabKeydown(event: KeyboardEvent): void;
+    keepEditorFocus(event: MouseEvent): void;
+    run(command: (chain: ChainedCommands) => ChainedCommands): void;
+    exec(command: DocumentRibbonCommand): void;
+    align(value: DocumentTextAlign): void;
+    private withEditor;
+    growFont(): void;
+    shrinkFont(): void;
+    applyTextCase(mode: DocumentTextCase): void;
+    clearFormat(): void;
+    togglePainter(): void;
+    onEditorMouseUp(): void;
+    applyHighlight(color: string | null): void;
+    applyFontColor(color: string | null): void;
+    increaseIndent(): void;
+    decreaseIndent(): void;
+    applyLineSpacing(multiple: number): void;
+    isCurrentLineSpacing(multiple: number): boolean;
+    setIndent(side: 'left' | 'right', { value, returnFocus }: DocumentSpinnerCommit): void;
+    setSpacing(side: 'before' | 'after', { value, returnFocus }: DocumentSpinnerCommit): void;
+    toggleParagraphSpace(side: 'before' | 'after'): void;
+    insertTable({ rows, cols }: {
+        rows: number;
+        cols: number;
+    }): void;
+    openTableDialog(): void;
+    insertCustomTable({ rows, cols, options }: DocumentTableRequest): void;
+    insertSymbol(symbol: string): void;
+    applyLink(value: string): boolean;
+    removeLink(): void;
+    applyShading(color: string | null): void;
+    pickTableStyle(styleId: string | null): void;
+    reapplyTableStyle(): void;
+    setTableLook(flag: TableLookFlag, event: Event): void;
+    setBorderStyle(style: DocumentBorderLineStyle): void;
+    setBorderWidth(width: number): void;
+    setBorderColor(color: string | null): void;
+    private updateBorderPen;
+    applyBorders(target: DocumentBorderTarget): void;
+    toggleBorderPainter(): void;
+    setAutofit(mode: DocumentTableAutofit): void;
+    selectPart(part: DocumentTableSelectPart): void;
+    setRowHeightCm({ value, returnFocus }: DocumentSpinnerCommit): void;
+    setColumnWidthCm({ value, returnFocus }: DocumentSpinnerCommit): void;
+    distributeSelectedRows(): void;
+    distributeSelectedColumns(): void;
+    pickAlignment({ vertical, horizontal }: DocumentCellAlignmentChoice): void;
+    cycleTextDirection(): void;
+    applyCellMargins({ margins, scope }: DocumentCellMarginsRequest): void;
+    applyTableWrap(float: DocumentTableFloat | null): void;
+    setTableOffset({ value, returnFocus }: DocumentSpinnerCommit): void;
+    onEditorContextMenu(event: MouseEvent): void;
+    private showMenuAt;
+    private closeMenu;
+    toggleSubmenu(): void;
+    onEditorCreated(editor: Editor): void;
+    private syncFormatState;
+    private syncTableLayout;
+    private syncBorderPainter;
+    private syncRowCollection;
+    private syncRegionState;
+    goToRegion(kind: DocumentRegionKind): void;
+    deleteRegion(kind: DocumentRegionKind): void;
+    addPageBreak(): void;
+    addPageField(field: DocumentFieldKind): void;
+    private pageObserver;
+    private observePageCount;
+    private measurePageCount;
+    private syncFontControls;
+    private applyFontFamily;
+    private applyFontSize;
+    readonly addFontSize: (term: string) => number | null;
+    readonly fontSizeTerm: import("@angular/core").WritableSignal<string>;
+    readonly isFontSizeTermValid: import("@angular/core").Signal<boolean>;
+    onWordFileSelected(event: Event): Promise<void>;
+    private applyWordImport;
+    private importSnapshot;
+    private readSheet;
+    private syncSheetWithHistory;
+    applyMarginPreset(preset: DocumentMarginPreset): void;
+    commitMargins(): void;
+    private fitMarginAxis;
+    onMarginsBeforeToggle(event: Event, trigger: HTMLElement): void;
+    positionPopover(event: Event, trigger: HTMLElement, menu: HTMLElement): void;
+    private writeMarginsForm;
+    private toCentimeters;
+    private describeMargins;
+    addTextNode(): void;
+    private blockImageFiles;
+    addListTable(): void;
+    editRowRepeat(): void;
+    openListTable(collection?: DocumentListCollection | null): void;
+    openRowRepeat(): void;
+    private showNode;
+    private showListPanel;
+    openFind(): void;
+    closeFind(): void;
+    onListPanelDone(): void;
+    backToVariables(): void;
+    /** El panel lateral muestra las variables (y no un nodo, una tabla de listado ni la búsqueda). */
+    variablesVisible: import("@angular/core").Signal<boolean>;
+    toggleVariables(): void;
+    insertVariableFromPanel(variable: DocumentVariable): void;
+    reloadVariables(): void;
+    insertListTableFromPanel(collection: DocumentListCollection): void;
+    chooseListColumns(collection: DocumentListCollection): void;
+    togglePreview(): void;
+    removeNode(): void;
+    private variablesReady;
+    onEditorMouseDown(event: MouseEvent): void;
+    onDocumentMouseDown(event: MouseEvent): void;
+    toggleFullscreen(): void;
+    onEscape(): void;
+    fitToWidth(): void;
+    private toCm;
+    onContentChange(html: string): void;
+    private detectTheme;
+    private observeShellTheme;
+}
+export {};

package/lib/components/document-editor/find/document-editor-search.d.ts

@@ -0,0 +1,23 @@
+import { Editor, Extension } from '@tiptap/core';
+export interface DocumentSearchMatch {
+    from: number;
+    to: number;
+}
+export interface DocumentSearchState {
+    query: string;
+    caseSensitive: boolean;
+    matches: DocumentSearchMatch[];
+    /** Índice de la coincidencia actual (0 si no hay ninguna). */
+    current: number;
+}
+export interface DocumentSearchOptions {
+    /** Se llama con Ctrl+F (Cmd+F) en el lienzo; sin él el atajo queda para el navegador. */
+    onOpen: (() => void) | null;
+}
+export declare const DocumentSearch: Extension<DocumentSearchOptions, any>;
+export declare function getSearchState(editor: Editor): DocumentSearchState;
+export declare function setSearchQuery(editor: Editor, query: string, caseSensitive: boolean): void;
+export declare function goToMatch(editor: Editor, direction: 1 | -1): void;
+export declare function replaceCurrentMatch(editor: Editor, replacement: string): void;
+export declare function replaceAllMatches(editor: Editor, replacement: string): number;
+export declare function clearSearch(editor: Editor): void;

package/lib/components/document-editor/find/find-panel/document-editor-find-panel.d.ts

@@ -0,0 +1,45 @@
+import { DestroyRef, ElementRef } from '@angular/core';
+import { FormControl, FormGroup } from '@angular/forms';
+import { Editor } from '@tiptap/core';
+import { DocumentSearchState } from '../document-editor-search';
+/**
+ * Contenido del panel lateral de `document-editor` para buscar y reemplazar (Ctrl+F). Busca mientras se escribe,
+ * resalta todas las coincidencias en el lienzo y marca la actual; Intro pasa a la siguiente y Mayús+Intro a la
+ * anterior, sin sacar el foco del campo. Al cerrarse (o destruirse) se quita el resaltado.
+ */
+export declare class DocumentEditorFindPanel {
+    private readonly destroyRef;
+    private readonly host;
+    constructor(destroyRef: DestroyRef, host: ElementRef<HTMLElement>);
+    editor: import("@angular/core").InputSignal<Editor>;
+    /** Se pidió cerrar el panel (botón Cerrar o Esc). */
+    closed: import("@angular/core").OutputEmitterRef<void>;
+    private readonly panelId;
+    readonly queryInputId: string;
+    readonly caseSensitiveInputId: string;
+    readonly replacementInputId: string;
+    private readonly queryInput;
+    searchState: import("@angular/core").WritableSignal<DocumentSearchState>;
+    /** Cuántas coincidencias cambió "Reemplazar todo"; se muestra hasta la siguiente búsqueda. */
+    replacedCount: import("@angular/core").WritableSignal<number | null>;
+    hasMatches: import("@angular/core").Signal<boolean>;
+    status: import("@angular/core").Signal<string | null>;
+    form: FormGroup<{
+        query: FormControl<string>;
+        caseSensitive: FormControl<boolean>;
+        replacement: FormControl<string>;
+    }>;
+    private readonly _syncWithEditorEffect;
+    private keepTypedText;
+    private search;
+    private prefillFromSelection;
+    private focusQuery;
+    previous(): void;
+    next(): void;
+    replace(): void;
+    replaceAll(): void;
+    close(): void;
+    onQueryKeydown(event: KeyboardEvent): void;
+    onReplacementKeydown(event: KeyboardEvent): void;
+    onKeydown(event: KeyboardEvent): void;
+}

package/lib/components/document-editor/format/document-editor-commands.d.ts

@@ -0,0 +1,38 @@
+import { type Editor } from '@tiptap/core';
+import type { Mark as ProseMirrorMark } from '@tiptap/pm/model';
+import { type Transaction } from '@tiptap/pm/state';
+import { type DocumentBlockStyle, type DocumentTableFloat } from './document-editor-format-state';
+export type DocumentTextCase = 'sentence' | 'lower' | 'upper' | 'title' | 'toggle';
+export interface DocumentCapturedFormat {
+    /** Marcas del texto (negrita, fuente, tamaño, color…), sin nodos de datos ni enlaces. */
+    marks: readonly ProseMirrorMark[];
+    /** Formato del párrafo: alineación, interlineado, espaciado y sangrías. */
+    blockAttrs: Record<string, unknown>;
+}
+export declare const DOCUMENT_TABLE_BORDER_STYLE = "border: 0.5pt solid #000000";
+export declare function runInTransaction(editor: Editor, edit: (tr: Transaction) => void, focus?: boolean): void;
+export declare function clearFormatting(editor: Editor): void;
+export declare function changeTextCase(editor: Editor, mode: DocumentTextCase): void;
+export declare function stepFontSize(current: number | null, direction: 1 | -1): number;
+export declare function setLineSpacing(editor: Editor, wordMultiple: number | null): void;
+export declare function setParagraphSpacing(editor: Editor, side: 'before' | 'after', points: number | null, focus?: boolean): void;
+export declare function setParagraphIndent(editor: Editor, side: 'left' | 'right', points: number | null, focus?: boolean): void;
+export declare function changeIndent(editor: Editor, direction: 1 | -1): void;
+export declare function setBlockStyle(editor: Editor, style: DocumentBlockStyle): void;
+export declare function captureFormat(editor: Editor): DocumentCapturedFormat;
+export declare function applyFormat(editor: Editor, format: DocumentCapturedFormat): void;
+export declare function setCellShading(editor: Editor, color: string | null): void;
+export declare function setTableFloat(editor: Editor, float: DocumentTableFloat | null): void;
+export declare function setTableFloatOffset(editor: Editor, centimeters: number, focus?: boolean): void;
+export type DocumentTableWidthMode = 'window' | 'fixed' | 'content';
+export interface DocumentTableOptions {
+    widthMode: DocumentTableWidthMode;
+    /** Ancho de cada columna (px); solo con `fixed`. */
+    columnWidth: number;
+    /** La primera fila es de encabezado (celdas `th`, en negrita). */
+    headerRow: boolean;
+}
+export declare function insertBorderedTable(editor: Editor, rows: number, cols: number, options?: DocumentTableOptions | null): void;
+export declare function normalizeHref(value: string): string | null;
+export declare function setLink(editor: Editor, href: string): void;
+export declare function unsetLink(editor: Editor): void;

package/lib/components/document-editor/format/document-editor-defaults.d.ts

@@ -0,0 +1,14 @@
+export interface DocumentDefaults {
+    /** Lista de fuentes CSS del texto base. */
+    fontFamily: string;
+    /** Tamaño del texto base, en puntos. */
+    fontSize: number;
+    /** Interlineado como múltiplo del sencillo de Word (1 = sencillo, 1,15, 2…). */
+    lineHeight: number;
+    /** Espacio (pt) que hay debajo de cada párrafo. */
+    spaceAfter: number;
+}
+export declare const DEFAULT_DOCUMENT_DEFAULTS: DocumentDefaults;
+export declare const WORD_SINGLE_LINE_FACTOR = 1.2;
+export declare const toCssLineHeight: (wordMultiple: number) => number;
+export declare function toDocumentDefaults(value: Partial<DocumentDefaults> | null | undefined): DocumentDefaults;

package/lib/components/document-editor/format/document-editor-format-state.d.ts

@@ -0,0 +1,62 @@
+import type { Editor } from '@tiptap/core';
+import { type TableLook } from '../tables/styles/document-editor-table-styles';
+export type DocumentBlockStyle = 'paragraph' | 'heading1' | 'heading2' | 'heading3';
+export type DocumentTextAlign = 'left' | 'center' | 'right' | 'justify';
+/** Lado hacia el que flota una tabla (el texto la rodea por el otro lado). */
+export type DocumentTableFloat = 'left' | 'right';
+export declare const POINTS_PER_CM: number;
+export interface DocumentFormatState {
+    bold: boolean;
+    italic: boolean;
+    underline: boolean;
+    strike: boolean;
+    superscript: boolean;
+    subscript: boolean;
+    bulletList: boolean;
+    orderedList: boolean;
+    textAlign: DocumentTextAlign;
+    /** Estilo del bloque del cursor; `null` si es otro (un título 4, por ejemplo). */
+    blockStyle: DocumentBlockStyle | null;
+    /** Color del texto guardado en el documento (`null`: automático). */
+    color: string | null;
+    /** Color de resaltado (fondo del texto). */
+    backgroundColor: string | null;
+    /** Interlineado del párrafo como múltiplo de Word (1, 1.15…); `null` si usa el de la hoja. */
+    lineSpacing: number | null;
+    /** Espacio antes y después del párrafo en puntos; `null` si usa el de la hoja. */
+    spaceBefore: number | null;
+    spaceAfter: number | null;
+    /** Sangría izquierda y derecha del párrafo en puntos; `null` si no tiene. */
+    indentLeft: number | null;
+    indentRight: number | null;
+    linkHref: string | null;
+    hasSelection: boolean;
+    inTable: boolean;
+    /** Sombreado de la celda del cursor como `#RRGGBB` (`null`: sin color o fuera de una tabla). */
+    cellShading: string | null;
+    /** Ajuste del texto de la tabla del cursor (la más interna): lado hacia el que flota, o `null` si va en línea. */
+    tableFloat: DocumentTableFloat | null;
+    /** Distancia (cm) de la tabla flotante al borde del lado hacia el que flota; `null` si no flota. */
+    tableFloatOffsetCm: number | null;
+    /** Código del estilo de tabla aplicado a la tabla del cursor (ver `DOCUMENT_TABLE_STYLES`); `null` si no tiene o fuera de una tabla. */
+    tableStyle: string | null;
+    /** Opciones de estilo de la tabla del cursor (fila de encabezado, filas con bandas…); todas apagadas si no tiene estilo. */
+    tableLook: TableLook;
+    canUndo: boolean;
+    canRedo: boolean;
+    canMergeCells: boolean;
+    canSplitCell: boolean;
+}
+export declare const EMPTY_FORMAT_STATE: DocumentFormatState;
+export interface DocumentTableFloatMargins {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface DocumentTableFloatStyle {
+    float: DocumentTableFloat;
+    margins: DocumentTableFloatMargins;
+}
+export declare function readTableFloat(style: unknown): DocumentTableFloatStyle | null;
+export declare function readFormatState(editor: Editor): DocumentFormatState;

package/lib/components/document-editor/format/document-editor-format.d.ts

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

package/lib/components/document-editor/format/document-editor-typography.d.ts

@@ -0,0 +1,26 @@
+import type { Editor } from '@tiptap/core';
+export interface DocumentFont {
+    /** Nombre que ve el usuario y con el que se reconoce la fuente en el documento. */
+    name: string;
+    /** Lista de fuentes CSS que se guarda en el HTML: la elegida y sus alternativas si no está instalada. */
+    family: string;
+}
+export declare const DEFAULT_DOCUMENT_FONT: DocumentFont;
+export declare const DEFAULT_DOCUMENT_FONT_SIZE = 11;
+export declare const DOCUMENT_FONTS: readonly DocumentFont[];
+export declare const DOCUMENT_FONT_SIZES: readonly number[];
+export declare const formatFontSize: (points: number) => string;
+export declare function firstFontFamily(css: string | null | undefined): string | null;
+export declare function findDocumentFont(css: string | null | undefined): DocumentFont | undefined;
+export declare function toFontSizePoints(css: string | null | undefined): number | null;
+export declare function parseFontSizeTerm(term: string): number | null;
+export interface DocumentSelectionFont {
+    /**
+     * Primera fuente de la lista CSS (puede no estar en `DOCUMENT_FONTS`); `null` si no se pudo leer o si la
+     * selección mezcla varias fuentes.
+     */
+    family: string | null;
+    /** Tamaño en puntos; `null` si la selección mezcla varios tamaños. */
+    size: number | null;
+}
+export declare function readSelectionFont(editor: Editor, baseSize?: number): DocumentSelectionFont;

package/lib/components/document-editor/i18n/document-editor-i18n.d.ts

@@ -0,0 +1,2 @@
+import { AteI18nService } from '@flogeez/angular-tiptap-editor';
+export declare function registerDocumentEditorI18n(i18n: AteI18nService): void;