Artículo técnico

Ciclo completo de XLSX sin pérdidas en Delphi

Un trabajo de facturación abre una plantilla de cliente, escribe 42750 en B3, y guarda. Haga un diff de los paquetes descomprimidos después y la lista de cambios es mucho más larga que una celda: xl/theme/theme1.xml ahora contiene la paleta estándar de Office en lugar del verde azulado y el gris pizarra del cliente, el <extLst> al final del XML de la hoja perdió el grupo de sparklines y una regla de formato condicional más nueva, y xl/calcChain.xml falta por completo. Excel abre el resultado, ofrece una reparación, y los colores de la marca se fueron. El código tocó una celda. Todo lo demás cambió porque el guardado reconstruyó el paquete a partir de lo que el modelo en memoria conocía, y tres partes de una plantilla típica quedan fuera de lo que un modelo de hoja de cálculo normalmente contiene

Tres mecanismos detrás de un ciclo de ida y vuelta XLSX sin pérdidas de HotXLS en Delphi: xl/theme/theme1.xml en caché como bytes crudos y reescrito sin cambios salvo las anulaciones de slots ThemeColor, bloques extLst ajenos capturados de eventos XML y reproducidos, y un calcChain.xml nuevo válido según la especificación emitido en cada guardado con fórmulas
Cada parte preservada sigue su propio camino durante el guardado — bytes del theme literales, replay de extLst a nivel de evento y una cadena de cálculo regenerada — mientras que el XML de la hoja y los estilos se reconstruyen desde el modelo

Por qué una edición de una celda reescribe todo el paquete XLSX

Un archivo .xlsx es un ZIP de partes XML: xl/workbook.xml, un xl/worksheets/sheetN.xml por hoja, xl/styles.xml, xl/sharedStrings.xml, el theme, la cadena de cálculo, y los drawings, tablas y cachés de pivote que el libro traiga. Una biblioteca que lee valores y fórmulas en objetos y regenera cada parte desde esos objetos al guardar tiene un punto débil. Todo lo que el modelo de objetos no tenga dónde guardar nunca llega a memoria, así que la parte regenerada sale sin ello. Nadie tiene que borrar las sparklines; simplemente no tienen dónde vivir entre Open y SaveAs

El ECMA-376 vio venir la mitad de esto. SpreadsheetML reserva extLst (ECMA-376 Parte 1, §18.2.10 para el elemento a nivel de libro, con elementos equivalentes en hojas, estilos y formatos condicionales) como área de almacenamiento de características futuras. Un productor más nuevo envuelve cada característica en un elemento <ext> cuyo atributo uri nombra la característica, y se espera que un consumidor más antiguo transporte lo que no entiende. Las sparklines, las listas de slicers, las opciones más nuevas de data bar e icon sets, y la validación de datos extendida viajan así en los archivos que Excel escribe hoy. Descartar bloques <ext> desconocidos por lo tanto rompe el contrato de compatibilidad hacia adelante sobre el que se construyó el formato, y el daño solo aparece cuando el cliente reabre el archivo en Excel

El theme y la cadena de cálculo fallan por razones distintas, así que cada uno necesita su propio tratamiento. El resto de este artículo recorre cómo maneja HotXLS los tres, qué puede observar y verificar un caller Delphi, y dónde termina la garantía

Mantener un theme1.xml personalizado intacto en Delphi

HotXLS conserva el theme de un libro reteniendo los bytes originales de xl/theme/theme1.xml del paquete abierto y escribiendo esa parte tal cual en SaveAs. La parte del theme (ECMA-376 Parte 1, §14.2.7) es DrawingML: un esquema de color con doce slots, un esquema de fuentes, un esquema de formato de rellenos, líneas y efectos. Los estilos de celda apuntan a él con <color theme="4"/> y referencias similares, así que el motor de hojas de cálculo solo necesita resolver slots, nunca entender gradientes ni estilos de efecto. Regenerar un theme de Office fijo en cada guardado es exactamente lo que convierte el verde azulado del cliente en azul de Office. Un libro creado desde cero, sin theme que transportar, recibe en cambio el theme integrado de Office

HotXLS pone en caché los bytes crudos de xl/theme/theme1.xml al abrir y los reescribe idénticos byte a byte al guardar, mientras una biblioteca que reconstruye desde el modelo regenera un tema Office estándar y revierte los colores de marca del cliente
Almacenar theme1.xml en caché de forma literal no necesita ningún modelo de theme, y ThemeMajorFont con ThemeMinorFont solo aplican estilo a libros que no traen un theme capturado

El caso cotidiano no necesita ningún código de theme. Note el índice de hoja: Sheets es base 1 en el motor XLSX, y Cells[3, 2] es fila 3, columna 2, que es B3

var
  Book: TXLSXWorkbook;
begin
  Book := TXLSXWorkbook.Create;
  try
    Book.Open('branded-invoice.xlsx');
    Book.Sheets[1].Cells[3, 2].Value := 42750.00;  // la única edición
    Book.SaveAs('branded-invoice-out.xlsx');
    // xl/theme/theme1.xml en la salida lleva el theme de la propia plantilla
  finally
    Book.Free;
  end;
end;

Los bytes crudos son la máxima fidelidad que se puede obtener para una parte así: sin análisis, sin re-serialización, nada que se desvíe. Cuando el guardado escribe Strict OOXML en lugar del dialecto transicional, el theme capturado pasa por el traductor de namespaces en lugar de copiarse, porque una copia de bytes dejaría URIs de namespace transicionales dentro de un paquete Strict

La trampa está del lado de la API. TXLSXWorkbook expone ThemeMajorFont y ThemeMinorFont, y después de Open reportan los tipos de letra de encabezado y cuerpo parseados del esquema de fuentes de la plantilla. Configurarlos parece la forma natural de cambiar fuentes, pero solo dan forma al theme de Office integrado que reciben los libros nuevos. En un libro que trajo su propio theme, la parte capturada gana y esos dos setters no cambian nada en el archivo guardado. Los colores se manejan distinto: ThemeColor[Slot] direcciona los doce slots de clrScheme, y una anulación se escribe en el theme preservado reemplazando solo el color de ese slot, dejando el esquema de fuentes, el esquema de formato y cualquier extensión del theme intactos

Book.Open('branded-invoice.xlsx');
// Sin efecto en el archivo guardado: el theme de la propia plantilla se preserva
Book.ThemeMajorFont := 'Segoe UI Semibold';
// Sí llega al archivo: solo el slot accent1 dentro de theme1.xml cambia
Book.ThemeColor[xlsxThemeAccent1] := $FF0F7B6C;  // $AARRGGBB
Book.SaveAs('rebranded.xlsx');

Esa división es deliberada. Una anulación de color es una edición angosta y bien definida de un elemento, así que el resto del theme de un diseñador puede quedarse exactamente como estaba. Una reescritura del esquema de fuentes tocaría listas de fuentes por alfabeto que una API orientada a datos no tiene buena forma de expresar. Si una plantilla necesita un tipo de letra nuevo, cámbielo en Excel y distribuya la plantilla nueva; eso mantiene el theme en manos de quien posee la marca

¿Qué sucede con los bloques extLst desconocidos al guardar?

HotXLS captura cada bloque <ext> a nivel de hoja que no modela de forma nativa y lo reproduce dentro del extLst de la hoja guardada. Los bloques que sí modela se parsean en objetos tipados y se reconstruyen desde ellos: los grupos de sparklines van a SparklineGroups, la extensión de validación de datos x14 se lee en la colección de validación de datos, y las listas de slicers las vuelve a emitir el modelo de slicers. Todo lo demás aterriza, un fragmento XML por bloque, en la lista de cadenas de solo lectura RawWorksheetExts de cada TXLSXWorksheet, lo que significa que una prueba puede inspeccionar exactamente qué se va a transportar

var
  Book: TXLSXWorkbook;
  Sheet: TXLSXWorksheet;
  i: Integer;
begin
  Book := TXLSXWorkbook.Create;
  try
    Book.Open('from-newer-excel.xlsx');
    Sheet := Book.Sheets[1];
    WriteLn(Format('%d foreign ext block(s), %d sparkline group(s)',
      [Sheet.RawWorksheetExts.Count, Sheet.SparklineGroups.Count]));
    for i := 0 to Sheet.RawWorksheetExts.Count - 1 do
      WriteLn(Copy(Sheet.RawWorksheetExts[i], 1, 100)); // la etiqueta de apertura muestra el uri
    // Declaraciones de namespaces que los fragmentos tomaron prestadas de la raíz <worksheet>
    WriteLn(Sheet.RawExtNamespaceDecls);
  finally
    Book.Free;
  end;
end;

La captura funciona desde el stream de eventos XML, porque un lector de flujo entrega elementos, texto y etiquetas de cierre pero ningún desplazamiento de bytes hacia la fuente. Cada subárbol desconocido se reconstruye a partir de esos eventos a medida que pasan. Un contador de profundidad ingenuo se rompe aquí: incrementa en cada etiqueta de apertura y decrementa en cada etiqueta de cierre, y un hijo de autocierre como <x14:cfvo type="min"/> llega como un solo evento de apertura marcado como vacío sin etiqueta de cierre que lo siga. Contarlo como elemento abierto y el contador nunca vuelve a cero, así que la captura se traga el resto de la hoja. El bucle de captura en HotXLS solo incrementa la profundidad para una etiqueta de apertura que no esté vacía, y un <ext/> que esté vacío en sí mismo se almacena inmediatamente como un fragmento de una línea

Reconstruir desde eventos tiene un efecto secundario visible. Las comillas de atributos, el espacio en blanco entre elementos y la elección entre <a></a> y <a/> regresan normalizados, así que un fragmento es equivalente en significado al original pero no idéntico byte a byte. Excel parsea el XML; no compara bytes. Una herramienta de diff que compara texto va a marcar el cambio, eso sí, y conviene saberlo antes de que alguien lo registre como regresión

Los namespaces son lo segundo que puede salir mal con un fragmento reproducido. Excel normalmente declara los prefijos que necesita en el propio elemento <ext>, lo que hace el fragmento autocontenido, pero un bloque también puede apoyarse en un prefijo como x14ac o xr que se declaró una vez en la raíz <worksheet> de la fuente. Reproduzca ese fragmento en una hoja sin la declaración y el XML guardado no está bien formado respecto a namespaces. HotXLS escanea cada fragmento capturado buscando prefijos que usa pero no declara, registra las declaraciones correspondientes de la fuente en RawExtNamespaceDecls, y las escribe en la raíz de la hoja guardada. Como los fragmentos son cadenas simples, duplicar una hoja dentro o entre libros también puede transportarlos a la hoja nueva

Escribir calcChain.xml para que Excel confíe en sus fórmulas

HotXLS escribe xl/calcChain.xml (la parte de la cadena de cálculo, ECMA-376 Parte 1, §12.3.1) siempre que el libro guardado contenga al menos una celda con fórmula, junto con su override de content-type y su relación del libro. Cada entrada es un elemento <c r="D10" i="1"/>: la referencia de celda más el índice de hoja base 1, que el writer emite en cada entrada aunque el esquema permita que una racha de entradas de la misma hoja lo omita. Lo explícito es más simple y igual de válido

El orden depende de lo que el libro ya conoce. Cuando el grafo de dependencias de fórmulas existe y está actualizado, que es el estado justo después de Recalculate, la cadena sigue un orden topológico completo: cada fórmula después de las celdas de las que depende, con los miembros de referencias circulares agregados al final para que la cadena aún liste cada celda con fórmula. Cuando el grafo está desactualizado o nunca se construyó, las celdas con fórmula se listan en orden de documento, hoja por hoja. Ambos son legales. Las notas de implementación de Microsoft para el formato, [MS-XLSX], describen la cadena como una sugerencia que Excel verifica y reordena mientras calcula, así que un listado completo en cualquier orden carga limpiamente

HotXLS emite xl/calcChain.xml en orden topológico cuando Recalculate ha construido el grafo de dependencias, y en orden de documento de lo contrario; Excel trata cualquier listado completo como una pista y lo reordena durante la carga
Ambos órdenes permanecen legales porque Excel reverifica la cadena al cargar, y HotXLS nunca fuerza dentro de SaveAs la construcción del grafo de costo cuadrático
Book.Open('model.xlsx');
Book.Sheets[1].Cells[10, 4].Formula := '=SUM(D2:D9)';
// Guardar aquí lista las celdas con fórmula en orden de documento, porque cambiar
// una fórmula invalidó el grafo de dependencias.
Book.Recalculate;   // reconstruye el grafo y refresca los valores en caché
Book.SaveAs('model-out.xlsx');
// calcChain.xml ahora sigue el orden de dependencias: D10 después de D2:D9

SaveAs no construye el grafo por iniciativa propia. Una construcción completa de dependencias significa resolver cada referencia en cada fórmula, lo que en un modelo grande es trabajo real que un caller que solo quería escribir un archivo nunca pidió. Si los valores en caché de la salida le importan, y normalmente le importan para cualquier cosa que un sistema aguas abajo lee sin abrir Excel, llame a Recalculate antes de guardar de todos modos; la cadena ordenada por dependencias viene gratis

¿Por qué emitir una parte que Excel trata como consultiva? Porque su ausencia se nota. Las heurísticas de reparación, los visores de terceros y las herramientas de diff esperan que un libro con fórmulas lleve una cadena de cálculo, y un paquete sin ella se ve distinto a cualquier cosa que el propio Excel produce. Escribir una cadena válida mantiene la salida dentro de la forma contra la que el resto del ecosistema ha sido ejercitado, y cuesta una pasada sobre las celdas con fórmula

Dónde termina el ciclo completo sin pérdidas

HotXLS no copia todo el paquete byte a byte, y la salida no debe juzgarse de esa forma. El XML de hoja, styles.xml, las cadenas compartidas y la parte del libro se regeneran desde el modelo parseado, así que son fieles en contenido pero no idénticos en binario a la entrada. Solo los encabezados locales de ZIP llevan marcas de tiempo frescas. Los fragmentos <ext> capturados regresan normalizados, como se describió arriba. ThemeMajorFont y ThemeMinorFont se quedan fuera de un theme preservado, mientras que las anulaciones de ThemeColor entran en él slot por slot

La red de preservación tiene una forma definida: las características que el motor modela de forma nativa, como las sparklines y la validación de datos extendida, que se parsean y reescriben; el contenido <ext> ajeno a nivel de hoja, que se reproduce; y la parte del theme, que se transporta tal como se capturó. Los proyectos VBA y las referencias a libros externos atraviesan el guardado con el mismo enfoque de conservar lo que no se modela, cubierto en el artículo complementario sobre preservación de VBA y enlaces externos, y las propiedades de documento en docProps tienen su propia API de lectura y escritura. Una parte de un add-in exótico que no esté modelada ni dentro de un punto de extensión queda fuera de los tres mecanismos cubiertos aquí

La verificación que importa usa sus propios archivos. Abra una plantilla de producción rica en características, cambie un valor, guarde, descomprima ambos paquetes, y haga diff parte por parte. Espere diferencias en la hoja que editó, en styles.xml y en el formato de atributos dentro del extLst; la parte del theme debería coincidir con la entrada, los elementos <ext> deberían listar los mismos valores de uri, y calcChain.xml debería nombrar cada celda con fórmula. Cualquier cosa más allá de esa lista vale la pena perseguirla antes de que la plantilla entre en producción

La preservación del theme, el replay de extLst ajeno y la salida de la cadena de cálculo son parte del motor XLSX en el HotXLS Delphi Excel Component; la página del producto lista el resto de lo que lee y escribe para proyectos Delphi y C++Builder