@cbm-common/cbm-types 0.0.366 → 0.0.368

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

@@ -0,0 +1,65 @@
+import { ElementRef } from '@angular/core';
+import { type TableLook } from '../document-editor-table-styles';
+/** Celda de una miniatura: sus bordes y su fondo ya como CSS, y el color de la barra que hace de texto. */
+export interface TableStyleThumbnailCell {
+    borderTop: string;
+    borderRight: string;
+    borderBottom: string;
+    borderLeft: string;
+    background: string;
+    barColor: string;
+    bold: boolean;
+}
+/** Una opción de la galería: un estilo del catálogo o "Sin estilo" (`id` nulo). */
+interface TableStyleGalleryEntry {
+    id: string | null;
+    label: string;
+    rows: readonly (readonly TableStyleThumbnailCell[])[];
+}
+/**
+ * Galería de estilos de tabla de `document-editor` (el "Estilos de tabla" de la pestaña Diseño de Word): una
+ * miniatura por estilo del catálogo, dibujada con las mismas reglas con las que se aplica el estilo a la tabla. Se
+ * dibuja dentro de un `popover` del editor (de unos 340 px, con desplazamiento si hace falta) o, con `limit`, en una
+ * fila de miniaturas dentro de un grupo de la cinta. No se abre ni se cierra sola ni toca el editor: solo avisa el
+ * estilo elegido (`null` = "Sin estilo"). Ningún botón toma el foco con el ratón, así el editor conserva la selección;
+ * con el teclado se recorre con las flechas, Inicio y Fin.
+ */
+export declare class DocumentEditorTableStyleGallery {
+    private readonly host;
+    constructor(host: ElementRef<HTMLElement>);
+    /** Código del estilo aplicado a la tabla (`null`: sin estilo). Su miniatura se marca como activa. */
+    current: import("@angular/core").InputSignal<string | null>;
+    /**
+     * Opciones de estilo de la tabla, con las que se dibujan las miniaturas (con "Fila de encabezado" se ve el
+     * encabezado, con "Filas con bandas" las bandas…). Una tabla sin estilo, o `null`, se dibuja con las opciones con
+     * las que se aplicaría un estilo nuevo (encabezado y filas con bandas).
+     */
+    look: import("@angular/core").InputSignal<TableLook | null>;
+    /** Cuántas miniaturas de estilos se muestran (las primeras del catálogo); `null` las muestra todas. */
+    limit: import("@angular/core").InputSignal<number | null>;
+    /** Muestra la opción "Sin estilo" al principio (no cuenta para `limit`). */
+    showNone: import("@angular/core").InputSignal<boolean>;
+    /** Muestra el botón "Limpiar" debajo, que también quita el estilo (útil en la fila corta, sin "Sin estilo"). */
+    showClear: import("@angular/core").InputSignal<boolean>;
+    /** Código del estilo elegido, o `null` para quitar el estilo ("Sin estilo" y "Limpiar"). */
+    picked: import("@angular/core").OutputEmitterRef<string | null>;
+    /** Texto de la opción señalada con el ratón o el teclado; `null` cuando no hay ninguna. */
+    hovered: import("@angular/core").WritableSignal<string | null>;
+    /** Opción que tomó el foco con el teclado: es la que recibe Tab (tabulación itinerante). */
+    private readonly focusedIndex;
+    /** Con `limit` la galería va en fila, sin ancho fijo ni título. */
+    compact: import("@angular/core").Signal<boolean>;
+    private readonly previewLook;
+    entries: import("@angular/core").Signal<readonly TableStyleGalleryEntry[]>;
+    /** Título: la opción señalada o, si no hay, el estilo aplicado. */
+    caption: import("@angular/core").Signal<string>;
+    /** Opción que recibe el foco con Tab: la última que lo tuvo o, al entrar, la del estilo aplicado (o la primera). */
+    tabStop: import("@angular/core").Signal<number>;
+    pick(id: string | null): void;
+    hover(label: string): void;
+    clearHover(): void;
+    focusEntry(index: number, label: string): void;
+    /** Flechas, Inicio y Fin mueven el foco entre las miniaturas (arriba y abajo saltan una fila). */
+    onKeydown(event: KeyboardEvent): void;
+}
+export {};

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

@@ -0,0 +1,54 @@
+import { FormControl, FormGroup } from '@angular/forms';
+import { DocumentTableOptions, DocumentTableWidthMode } from '../../format/document-editor-commands';
+/** Lo que se inserta al aceptar el modal: tamaño de la tabla y su autoajuste. */
+export interface DocumentTableRequest {
+    rows: number;
+    cols: number;
+    options: DocumentTableOptions;
+}
+export declare const TABLE_DIALOG_MAX_COLUMNS = 63;
+export declare const TABLE_DIALOG_MAX_ROWS = 100;
+/**
+ * Modal "Insertar tabla" de `document-editor`, como el de Word: número de columnas y de filas, cómo se ajusta el
+ * ancho (ancho de columna fijo, al contenido o a la ventana) y si la primera fila es de encabezado. Usa el elemento
+ * `<dialog>` del navegador (capa superior: queda por encima de la pantalla completa del editor y se cierra con Esc).
+ */
+export declare class DocumentEditorTableDialog {
+    confirmed: import("@angular/core").OutputEmitterRef<DocumentTableRequest>;
+    private readonly dialog;
+    private readonly dialogId;
+    readonly titleId: string;
+    readonly colsId: string;
+    readonly rowsId: string;
+    readonly widthId: string;
+    readonly widthModeName: string;
+    readonly maxColumns = 63;
+    readonly maxRows = 100;
+    readonly widthModes: readonly {
+        value: DocumentTableWidthMode;
+        label: string;
+        hint: string;
+    }[];
+    form: FormGroup<{
+        cols: FormControl<string>;
+        rows: FormControl<string>;
+        widthMode: FormControl<DocumentTableWidthMode>;
+        columnWidth: FormControl<string>;
+        headerRow: FormControl<boolean>;
+        remember: FormControl<boolean>;
+    }>;
+    /** Ancho útil de la hoja (cm): una tabla de ancho fijo no puede pasarse de él. */
+    private readonly maxWidthCm;
+    private readonly value;
+    private readonly parsed;
+    colsError: import("@angular/core").Signal<"Indique un número de columnas entre 1 y 63." | null>;
+    rowsError: import("@angular/core").Signal<"Indique un número de filas entre 1 y 100." | null>;
+    widthError: import("@angular/core").Signal<string | null>;
+    valid: import("@angular/core").Signal<boolean>;
+    fixedWidth: import("@angular/core").Signal<boolean>;
+    /** Abre el modal. `maxWidthCm` es el ancho útil de la hoja (sin márgenes). */
+    open(maxWidthCm: number): void;
+    close(): void;
+    onDialogClick(event: MouseEvent): void;
+    accept(event: Event): void;
+}

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

@@ -0,0 +1,31 @@
+import { ElementRef } from '@angular/core';
+/** Tamaño de tabla elegido en la cuadrícula. */
+export interface DocumentTableSize {
+    rows: number;
+    cols: number;
+}
+/**
+ * Contenido del menú "Insertar tabla" de `document-editor`: cuadrícula al estilo de Word donde se marca,
+ * con el ratón o con las flechas, el rectángulo desde la primera celda hasta la señalada. Se dibuja dentro
+ * de un `popover` del editor: no se abre ni se cierra solo, solo avisa el tamaño elegido.
+ */
+export declare class DocumentEditorTableGridMenu {
+    private readonly host;
+    constructor(host: ElementRef<HTMLElement>);
+    picked: import("@angular/core").OutputEmitterRef<DocumentTableSize>;
+    /** "Insertar tabla…": abre el modal para elegir las columnas, las filas y el autoajuste a mano. */
+    customRequested: import("@angular/core").OutputEmitterRef<void>;
+    readonly rows: number[];
+    readonly cols: number[];
+    /** Celda señalada (con el ratón o el teclado); `null` cuando no hay ninguna. */
+    hovered: import("@angular/core").WritableSignal<DocumentTableSize | null>;
+    title: import("@angular/core").Signal<string>;
+    /** Celda que recibe el foco con Tab (tabulación itinerante: una sola celda de la cuadrícula es tabulable). */
+    focusCell: import("@angular/core").Signal<DocumentTableSize>;
+    hover(rows: number, cols: number): void;
+    clearHover(): void;
+    pick(rows: number, cols: number): void;
+    requestCustom(): void;
+    /** Flechas, Inicio y Fin mueven la celda señalada sin salir de la cuadrícula. */
+    onKeydown(event: KeyboardEvent): void;
+}

package/lib/components/document-editor/variables/document-editor-sample-data.d.ts

@@ -0,0 +1,4 @@
+import { DocumentTemplateData } from './document-editor-template';
+import { DocumentSchemaCategory } from './document-editor-schema';
+/** Datos de ejemplo de las categorías que recibe: un valor por campo y tres ítems por listado. */
+export declare function buildSampleData(categories: readonly DocumentSchemaCategory[] | null | undefined): DocumentTemplateData;

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

@@ -0,0 +1,85 @@
+/** Campo de una categoría en la respuesta del backend. */
+export interface DocumentSchemaFieldSource {
+    name: string;
+    /** `String`, `Number`, `Boolean`, `Date`, `Array` o `Mixed`. */
+    type?: string | null;
+    description?: string | null;
+}
+/** Categoría de la respuesta del backend; sus `fields` pueden ser campos o subcategorías (`vehicle_reception`). */
+export interface DocumentSchemaCategorySource {
+    name: string;
+    description?: string | null;
+    fields: readonly (DocumentSchemaFieldSource | DocumentSchemaCategorySource)[];
+}
+/** Para qué sirve el dato: define el ejemplo que se muestra en la vista previa. */
+export type DocumentFieldKind = 'text' | 'number' | 'date' | 'boolean' | 'list';
+export interface DocumentSchemaField {
+    /** Nombre del campo tal como lo lee el backend (`client_business_name`): va en `data-node-value`. */
+    name: string;
+    /** Descripción en español (si el backend no la trae, el nombre del campo). */
+    label: string;
+    kind: DocumentFieldKind;
+}
+export interface DocumentSchemaCategory {
+    /** Nombre de la categoría (`client`; una subcategoría, `vehicle_reception.client`): va en `data-node-type`. */
+    name: string;
+    /** Descripción en español de la categoría (si el backend no la trae, su nombre). */
+    label: string;
+    /** Nombre corto para la etiqueta de la variable en el documento (`Cliente`, `Vehículo`…). */
+    shortLabel: string;
+    fields: DocumentSchemaField[];
+}
+/** Un campo identificado por lo que guarda el documento. */
+export interface DocumentVariablesHiddenField {
+    /**
+     * Nombre de la categoría tal como va en `data-node-type` (`client`; una subcategoría, `vehicle_reception.client`).
+     * Exacto.
+     */
+    category: string;
+    /** Nombre del campo tal como va en `data-node-value` (`client_business_name`). Exacto. */
+    field: string;
+}
+/** Reglas con las que el editor convierte las variables del backend en lo que ofrece. */
+export interface DocumentVariablesConfig {
+    /** Los campos cuyo NOMBRE coincide no se ofrecen (imágenes: el documento no las admite). `null`: sin filtro. */
+    readonly imageFieldPattern: RegExp | null;
+    /** Campos que el backend entrega pero el editor no debe ofrecer, por nombre de categoría + nombre de campo. */
+    readonly hiddenFields: readonly DocumentVariablesHiddenField[];
+    /**
+     * Descripciones que cuentan como ausentes (se comparan sin espacios ni mayúsculas): se muestra el nombre. La vacía
+     * siempre cuenta.
+     */
+    readonly missingDescriptions: readonly string[];
+    /**
+     * Palabras iniciales que se quitan de la descripción de una categoría para su nombre corto ("Datos del cliente" →
+     * "Cliente"). `null`: ninguna. Cambiarla cambia las etiquetas generadas.
+     */
+    readonly leadingWordsPattern: RegExp | null;
+    /** Tipo del backend (en minúsculas) → para qué sirve el dato. Un tipo que no esté es `'text'`. */
+    readonly fieldKinds: Readonly<Record<string, DocumentFieldKind>>;
+    /** Un campo `'number'` cuyo último tramo del nombre coincide es una fecha. `null`: nunca. */
+    readonly dateFieldPattern: RegExp | null;
+    /**
+     * Cuántos campos (los primeros de la categoría) marca de inicio el asistente "Tabla de listado" y usa
+     * "Insertar tabla". Mínimo 1.
+     */
+    readonly defaultListColumns: number;
+}
+/**
+ * Reglas de inicio. Están congeladas: el módulo se evalúa una sola vez por página y lo comparten todos los proyectos
+ * que usan el editor, así que ninguno debe poder cambiarlas para los demás (cada uno pasa las suyas en
+ * `[variablesConfig]`).
+ */
+export declare const DEFAULT_DOCUMENT_VARIABLES_CONFIG: DocumentVariablesConfig;
+/**
+ * `{ ...DEFAULT, ...config }`: cada clave que se pasa reemplaza entera a la de inicio. Una clave en `undefined` cuenta
+ * como no pasada; `null` es un valor.
+ */
+export declare function resolveDocumentVariablesConfig(config?: Partial<DocumentVariablesConfig> | null): DocumentVariablesConfig;
+/**
+ * Convierte la respuesta del backend en las categorías que ofrece el editor: aplana las subcategorías (la subcategoría
+ * `client` de `vehicle_reception` pasa a ser `vehicle_reception.client`), quita los campos de imagen, los que el
+ * consumidor oculta y las categorías que se quedan sin campos, y cambia las descripciones que faltan por el nombre. Las
+ * reglas son las de `config` sobre las de inicio (ver `resolveDocumentVariablesConfig`).
+ */
+export declare function toDocumentSchemaCategories(source: readonly DocumentSchemaCategorySource[] | null | undefined, config?: Partial<DocumentVariablesConfig> | null): DocumentSchemaCategory[];

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

@@ -0,0 +1,9 @@
+import { DocumentListCollection } from '../nodes/document-editor-node-types';
+export type DocumentTemplateValues = Record<string, string>;
+export interface DocumentTemplateData {
+    /** Valores de los nodos fijos, por categoría y luego por campo (`values.client.client_business_name`). */
+    values: Partial<Record<string, DocumentTemplateValues>>;
+    /** Ítems de cada listado, por categoría (`lists.items[0].items_name`). */
+    lists: Partial<Record<DocumentListCollection, DocumentTemplateValues[]>>;
+}
+export declare function fillDocumentTemplate(html: string, data: DocumentTemplateData): string;

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

@@ -0,0 +1,40 @@
+import { IGeneral } from '../../../../domain/models/general.domain.model';
+import { DocumentListCollection, DocumentVariable, DocumentVariableGroup, DocumentVariablesCatalog } from '../../nodes/document-editor-node-types';
+/**
+ * Contenido del panel lateral de `document-editor` cuando no hay un nodo, una tabla de listado ni la búsqueda a la
+ * vista: las variables que se pueden poner en el documento, agrupadas por categoría tal como las entrega el backend.
+ * Una variable se inserta con un clic (en el cursor) o arrastrándola al documento. Cualquier categoría puede ser un
+ * listado: "Insertar tabla" arma una tabla con una fila repetible de esa categoría.
+ */
+export declare class DocumentEditorVariablesPanel {
+    /** Categoría de la fila repetible donde está el cursor (`null` si no está en una). */
+    rowCollection: import("@angular/core").InputSignal<string | null>;
+    /** Catálogo del editor que contiene el panel. */
+    catalog: import("@angular/core").InputSignal<DocumentVariablesCatalog>;
+    /** Estado de la carga de las variables (las entrega el backend). */
+    status: import("@angular/core").InputSignal<IGeneral.STATUS>;
+    insert: import("@angular/core").OutputEmitterRef<DocumentVariable>;
+    insertTable: import("@angular/core").OutputEmitterRef<string>;
+    chooseColumns: import("@angular/core").OutputEmitterRef<string>;
+    /** Volver a pedir las variables al backend (la carga falló). */
+    retry: import("@angular/core").OutputEmitterRef<void>;
+    readonly searchId: string;
+    readonly skeletonRows: readonly null[];
+    query: import("@angular/core").WritableSignal<string>;
+    /** Grupo desplegado (uno a la vez; al buscar se despliegan todos los que tienen resultados). `undefined`: el primero. */
+    openGroup: import("@angular/core").WritableSignal<string | null | undefined>;
+    searching: import("@angular/core").Signal<boolean>;
+    loading: import("@angular/core").Signal<boolean>;
+    loadFailed: import("@angular/core").Signal<boolean>;
+    groups: import("@angular/core").Signal<DocumentVariableGroup[]>;
+    /** El backend respondió pero no entregó ninguna variable. */
+    noVariables: import("@angular/core").Signal<boolean>;
+    noResults: import("@angular/core").Signal<boolean>;
+    onSearch(event: Event): void;
+    private currentOpen;
+    toggleGroup(key: string): void;
+    isOpen(key: string): boolean;
+    groupLabel(collection: DocumentListCollection): string;
+    onDragStart(event: DragEvent, variable: DocumentVariable): void;
+    private filter;
+}

package/lib/components/document-editor/word-import/document-editor-word-flatten.d.ts

@@ -0,0 +1,7 @@
+import type { WordPageGeometry } from './document-editor-word-page';
+import { WordStyles } from './document-editor-word-styles';
+/**
+ * Escribe el formato de la parte en el XML. Devuelve `null` si el XML no se puede leer. Con la hoja del
+ * documento (solo el cuerpo la tiene) también coloca sus tablas flotantes; sin ella, quedan como tablas normales.
+ */
+export declare function flattenWordXml(xml: string, styles: WordStyles, page?: WordPageGeometry | null): string | null;

package/lib/components/document-editor/word-import/document-editor-word-float.d.ts

@@ -0,0 +1,23 @@
+import type { WordPageGeometry } from './document-editor-word-page';
+import { Context } from './document-editor-word-styles';
+/** Resultado de analizar una tabla con `w:tblpPr`. */
+export interface FloatingTablePlan {
+    table: Element;
+    /** Declaraciones CSS del nivel de la tabla: `float` y `margin` (o los márgenes automáticos si va centrada). */
+    css: string[];
+    /** ¿Flota? Una tabla centrada no: se queda donde está, como bloque. */
+    floating: boolean;
+    /** Bloque del cuerpo delante del que se coloca la tabla; `null`, al final del cuerpo. */
+    before: Element | null;
+}
+/**
+ * Analiza las tablas del cuerpo que traen `w:tblpPr` y calcula su CSS y el bloque delante del que van. No
+ * modifica el XML: la colocación la hace `placeFloatingTables`, cuando el resto del formato ya se calculó.
+ */
+export declare function planFloatingTables(document: Document, context: Context, page: WordPageGeometry): FloatingTablePlan[];
+/**
+ * Coloca las tablas flotantes delante de su bloque, en el orden del plan (el de los bloques y, en un mismo bloque,
+ * de fuera adentro en cada lado). Todas se sacan primero del cuerpo y se vuelven a meter, así las que caen en el
+ * mismo bloque lo conservan. Si el bloque empieza con un salto de página, la tabla va después de él.
+ */
+export declare function placeFloatingTables(plans: readonly FloatingTablePlan[]): void;

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

@@ -0,0 +1,17 @@
+/** Datos de una marca: el estilo CSS y, en las de celda, el ancho de sus columnas y el estilo de la tabla. */
+export interface WordMarkPayload {
+    st?: string;
+    /** Solo celdas: ancho (px) de cada columna que ocupa. */
+    w?: number[];
+    /** Solo la primera celda de una tabla: estilo de la tabla. */
+    t?: string;
+}
+export declare const runMarkStart: (payload: WordMarkPayload) => string;
+export declare const runMarkEnd: () => string;
+export declare const paragraphMark: (payload: WordMarkPayload) => string;
+export declare const cellMark: (payload: WordMarkPayload) => string;
+export declare const fieldMark: (field: "page" | "pages") => string;
+export declare function replaceSimplePageFields(xml: string): string;
+export declare const stripMarks: (text: string) => string;
+export declare function applyWordFormatting(html: string): string;
+export declare function hoistPageBreaks(html: string): string;

package/lib/components/document-editor/word-import/document-editor-word-images.d.ts

@@ -0,0 +1,24 @@
+/** Imagen tal como la entrega `mammoth` (solo lo que se usa). */
+export interface WordImage {
+    contentType: string;
+    /** Texto alternativo del dibujo; incluye la marca de tamaño que agrega `embedImageSizes`. */
+    altText?: string | null;
+    readAsArrayBuffer(): Promise<ArrayBuffer>;
+    readAsBase64String(): Promise<string>;
+}
+/** Atributos del `<img>` que se genera; `src` vacío con `data-dx-skip` marca una imagen omitida. */
+export interface WordImageAttributes {
+    src: string;
+    [attribute: string]: string;
+}
+export declare const SKIPPED_IMAGE_MARKER = "data-dx-skip";
+export interface WordImageConverter {
+    convert: (image: WordImage) => Promise<WordImageAttributes>;
+    /** Cuántas imágenes se omitieron hasta ahora. */
+    skipped: () => number;
+}
+export declare function embedImageSizes(documentXml: string): string;
+/**
+ * @param maxDisplayWidth ancho máximo (px) con el que se dibuja una imagen: el del área de texto de la hoja.
+ */
+export declare function createWordImageConverter(maxDisplayWidth: number): WordImageConverter;

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

@@ -0,0 +1,20 @@
+import { DocumentDefaults } from '../format/document-editor-defaults';
+import { WordImportPage } from './document-editor-word-page';
+export declare const WORD_IMPORT_ACCEPT = ".docx,.dotx,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.openxmlformats-officedocument.wordprocessingml.template";
+/** Error esperado de la importación: su mensaje ya está listo para mostrárselo al usuario. */
+export declare class WordImportError extends Error {
+    constructor(message: string, options?: {
+        cause?: unknown;
+    });
+}
+export interface WordImportResult {
+    /** HTML del documento, listo para cargarlo en el editor (con su encabezado y pie, si los trae). */
+    html: string;
+    /** Hoja del documento (tamaño, orientación, márgenes), o `null` si no se pudo leer. */
+    page: WordImportPage | null;
+    /** Formato base del documento: el de su estilo `Normal`. */
+    defaults: DocumentDefaults;
+    /** Avisos para el usuario: cosas que el documento traía y no se importaron. */
+    warnings: string[];
+}
+export declare function importWordDocument(file: File): Promise<WordImportResult>;

package/lib/components/document-editor/word-import/document-editor-word-page.d.ts

@@ -0,0 +1,57 @@
+import type JSZip from 'jszip';
+import { DocumentPageMargins, DocumentPageOrientation, DocumentPageSize } from '../page/document-editor-pages';
+/** Hoja de un documento de Word, en milímetros; cada dato puede faltar. */
+export interface WordSection {
+    widthMm: number | null;
+    heightMm: number | null;
+    margins: DocumentPageMargins | null;
+}
+/** Lo que se aplica al editor: `null` en un dato que el documento no trae. */
+export interface WordImportPage {
+    size: DocumentPageSize | null;
+    orientation: DocumentPageOrientation | null;
+    margins: DocumentPageMargins | null;
+    /** El documento trae un tamaño de hoja que el editor no tiene (medidas en mm), para avisar al usuario. */
+    unsupportedSize: {
+        widthMm: number;
+        heightMm: number;
+    } | null;
+}
+export declare function readMainDocumentXml(zip: JSZip): Promise<{
+    path: string;
+    xml: string;
+} | null>;
+export declare function readWordSection(documentXml: string): WordSection | null;
+export declare function toWordImportPage(section: WordSection | null): WordImportPage | null;
+export declare function contentWidthMm(section: WordSection | null): number | null;
+/** Medidas de la hoja del documento, en puntos, que necesita la colocación de las tablas flotantes. */
+export interface WordPageGeometry {
+    /** Ancho del área de texto (la hoja menos sus márgenes izquierdo y derecho). */
+    contentWidth: number;
+    /** Margen izquierdo de la hoja. */
+    leftMargin: number;
+    /** Margen superior de la hoja. */
+    topMargin: number;
+    /** Alto del área de texto de una hoja (la hoja menos sus márgenes superior e inferior); `null` si no se sabe. */
+    bodyHeight: number | null;
+}
+export declare function readWordPageGeometry(documentXml: string): WordPageGeometry | null;
+export interface WordRelationship {
+    type: string;
+    target: string;
+}
+export declare function readRelationships(zip: JSZip, ownerPath: string): Promise<{
+    map: Map<string, WordRelationship>;
+    xml: string | null;
+}>;
+export declare function readRelatedPart(zip: JSZip, relationships: Map<string, WordRelationship>, typeSuffix: string, fallbackPath: string): Promise<string | null>;
+export interface WordHeaderFooter {
+    /** Ruta del encabezado y del pie predeterminados de la sección (si los tiene). */
+    headerPath: string | null;
+    footerPath: string | null;
+    /** La sección usa un encabezado o pie distinto en la primera página o en las pares (no se importan). */
+    hasVariants: boolean;
+    /** Cantidad de secciones del documento (de la hoja solo se importa la de la última). */
+    sectionCount: number;
+}
+export declare function findHeaderFooter(documentXml: string, relationships: Map<string, WordRelationship>): WordHeaderFooter;

package/lib/components/document-editor/word-import/document-editor-word-styles.d.ts

@@ -0,0 +1,143 @@
+import { DocumentDefaults } from '../format/document-editor-defaults';
+export declare const W_NS = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
+/** Un borde: `null` es "sin borde" explícito; `undefined`, que no se indicó (se hereda). */
+export interface WordBorder {
+    width: number;
+    style: string;
+    color: string;
+}
+export type Border = WordBorder | null;
+export interface Sides<T> {
+    top?: T;
+    right?: T;
+    bottom?: T;
+    left?: T;
+}
+export interface Borders extends Sides<Border> {
+    insideH?: Border;
+    insideV?: Border;
+}
+export interface RunProps {
+    font?: string;
+    /** Puntos. */
+    size?: number;
+    /** `null`: color automático (anula el color heredado de un estilo). */
+    color?: string | null;
+    /** `null`: sin resaltado (anula el heredado). */
+    highlight?: string | null;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strike?: boolean;
+    caps?: boolean;
+    smallCaps?: boolean;
+}
+export type LineRule = 'auto' | 'exact' | 'atLeast';
+/** Interlineado: múltiplo del sencillo (`auto`) o puntos (`exact` y `atLeast`). Se guarda entero para que un nivel posterior lo reemplace. */
+export interface LineSpacing {
+    rule: LineRule;
+    value: number;
+}
+export interface ParaProps {
+    align?: string;
+    /** Puntos. */
+    before?: number;
+    after?: number;
+    lineSpacing?: LineSpacing;
+    left?: number;
+    right?: number;
+    /** Sangría de primera línea (negativa si es francesa). */
+    firstLine?: number;
+    pageBreakBefore?: boolean;
+    /** "No agregar espacio entre párrafos del mismo estilo". */
+    contextual?: boolean;
+}
+export interface TableProps {
+    borders?: Borders;
+    /** Márgenes internos de las celdas, en puntos. */
+    cellMargins?: Sides<number>;
+    align?: string;
+    /** Sangría de la tabla, en puntos. */
+    indent?: number;
+}
+/** Formato de una parte de la tabla (`w:tblStylePr`): la primera fila, las bandas, la primera columna… */
+export interface TableCondition {
+    run: RunProps;
+    para: ParaProps;
+    fill?: string;
+    borders?: Borders;
+    vAlign?: string;
+}
+interface StyleDef {
+    id: string;
+    type: string;
+    name: string | null;
+    basedOn: string | null;
+    run: RunProps;
+    para: ParaProps;
+    table: TableProps;
+    /** Solo estilos de tabla: formato por parte de la tabla, según el tipo (`firstRow`, `band1Horz`…). */
+    conditions: Map<string, TableCondition>;
+    rowBand: number | null;
+    colBand: number | null;
+}
+export interface WordStyles {
+    defaultRun: RunProps;
+    defaultPara: ParaProps;
+    styles: Map<string, StyleDef>;
+    defaultParagraphStyle: string | null;
+    defaultTableStyle: string | null;
+    themeFonts: {
+        major: string | null;
+        minor: string | null;
+    };
+    /** Documento de una versión anterior a Word 2013: la sangría de las tablas se mide hasta el texto. */
+    legacyTableIndent: boolean;
+}
+/** Dónde está un párrafo dentro de una tabla: su estilo y las partes de la tabla que afectan a su celda. */
+export interface TableScope {
+    style: string | null;
+    conditions: readonly string[];
+}
+export declare function childElements(element: Element, name: string): Element[];
+export declare function firstChild(element: Element | null | undefined, name: string): Element | null;
+export declare function structuralChildren(parent: Element, name: string): Element[];
+export declare function attr(element: Element | null | undefined, name: string): string | null;
+export declare const isOn: (value: string | null) => boolean;
+export declare function readRunProps(rPr: Element | null, theme: WordStyles['themeFonts']): RunProps;
+export declare function readParaProps(pPr: Element | null): ParaProps;
+export declare function readBorders(element: Element | null): Borders | undefined;
+export declare function readMargins(element: Element | null): Sides<number> | undefined;
+export declare function readTableProps(tblPr: Element | null): TableProps;
+export declare function merge<T extends object>(...items: Array<T | undefined>): T;
+export declare function mergeBorders(...items: Array<Borders | undefined>): Borders;
+export declare function mergeTable(...items: Array<TableProps | undefined>): TableProps;
+export declare function parseXml(xml: string): Document | null;
+export declare function parseWordStyles(stylesXml: string | null, themeXml: string | null, settingsXml?: string | null): WordStyles;
+export interface Context {
+    styles: WordStyles;
+    base: {
+        run: RunProps;
+        para: ParaProps;
+    };
+    cache: Map<string, unknown>;
+}
+export declare function stylePara(context: Context, paragraphStyle: string | null, table: TableScope | null): ParaProps;
+export declare function styleRun(context: Context, paragraphStyle: string | null, characterStyle: string | null, table: TableScope | null): RunProps;
+/** Formato de una tabla que viene de sus estilos: el del estilo (o el de tabla por defecto) y sus bases. */
+export declare function tableStyleProps(context: Context, tableStyle: string | null): TableProps;
+/** Formato de las partes de una tabla (`firstRow`, `band1Horz`…) que afectan a una celda. */
+export declare function tableConditionFor(context: Context, tableStyle: string | null, conditions: readonly string[]): TableCondition;
+/** Tamaño de las bandas (en filas y en columnas) de un estilo de tabla. */
+export declare function tableBandSizes(styles: WordStyles, tableStyle: string | null): {
+    rows: number;
+    columns: number;
+};
+/** Partes de la tabla ordenadas de menor a mayor prioridad (para aplicarlas en ese orden). */
+export declare const sortConditions: (kinds: readonly string[]) => string[];
+export declare function isHeadingStyle(styles: WordStyles, paragraphStyle: string | null): boolean;
+export declare function toFontStack(name: string): string | null;
+/** `line-height` CSS (sin unidad) de un interlineado de Word para texto de `size` puntos. */
+export declare function lineRatio(spacing: LineSpacing | undefined, size: number): number;
+export declare function readWordDefaults(styles: WordStyles): DocumentDefaults;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cbm-common/cbm-types",
-  "version": "0.0.366",
+  "version": "0.0.368",
   "main": "index.js",
   "types": "public-api.d.ts",
   "exports": {

package/public-api.d.ts

@@ -621,3 +621,6 @@ export * from './lib/components/brand-vehicle/add/add';
 // #region charges for order vehicle domain repository
 export * from './lib/domain/repositories/charges-for-order-vehicle.domain.repository';
 export * from './lib/domain/models/charges-for-order-vehicle.domain.model';
+
+//#region document editor
+export * from './lib/components/document-editor/public-api';