diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java
index 7ca1e25..98cc5cf 100644
--- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java
@@ -17,6 +17,7 @@ import ru.pjandro.wordpdf.internal.DependencyGuard;
import ru.pjandro.wordpdf.internal.DocxNormalizer;
import ru.pjandro.wordpdf.internal.DocxRewritePipeline;
import ru.pjandro.wordpdf.internal.doc.DocToDocx;
+import ru.pjandro.wordpdf.internal.xlsx.XlsxToDocx;
import ru.pjandro.wordpdf.internal.OleObjectNormalizer;
import ru.pjandro.wordpdf.internal.FopFallbackFonts;
import ru.pjandro.wordpdf.internal.LayoutPostRenderer;
@@ -124,14 +125,19 @@ public final class WordPdfConverter {
// лимита), затем для .docx — zip/контейнер/страницы, для .doc —
// страницы по чистому бинарному документу (до конвертации).
WordPdfValidator.validate(docxBytes, opts);
- // Бинарный .doc (Word 97–2003): мост internal.doc. Сгенерированный
+ // Роутинг мостов по классификации входа: бинарный .doc (CFB) — мост
+ // internal.doc; zip с манифестом spreadsheetml — мост internal.xlsx
+ // (оценка страниц уже сделана валидатором xlsx-путём). Сгенерированный
// .docx — собственный артефакт, его штатной валидацией входа не
- // проверяем (вход уже проверен по байтам .doc). Переиспользование слота
- // docxBytes: результат моста становится в тот же слот, и сырые байты
- // .doc сбрасываются в кадре на этом же месте — детерминированно, до
- // рендера (точные liveness-карты HotSpot строит только для
- // скомпилированных кадров; отдельное присваивание null не нужно).
- docxBytes = WordPdfValidator.isBinaryDoc(docxBytes) ? DocToDocx.convert(docxBytes) : docxBytes;
+ // проверяем (вход уже проверен по байтам оригинала). Переиспользование
+ // слота docxBytes: результат моста становится в тот же слот, и сырые
+ // байты оригинала сбрасываются в кадре на этом же месте —
+ // детерминированно, до рендера (точные liveness-карты HotSpot строит
+ // только для скомпилированных кадров; отдельное присваивание null не
+ // нужно).
+ docxBytes = WordPdfValidator.isBinaryDoc(docxBytes) ? DocToDocx.convert(docxBytes)
+ : WordPdfValidator.isSpreadsheet(docxBytes) ? XlsxToDocx.convert(docxBytes, opts)
+ : docxBytes;
ByteArrayOutputStream bos = new ByteArrayOutputStream(Math.max(1 << 16, docxBytes.length));
try {
convertToStream(docxBytes, title, opts, bos);
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java
new file mode 100644
index 0000000..0d8dcae
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java
@@ -0,0 +1,72 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+/**
+ * Цвет элемента {@code color} (ECMA-376 §18.8: CT_Color — атрибуты rgb,
+ * indexed, theme, auto, tint, shade). Разбор атрибутов отделён от
+ * вычисления: {@link ColorResolver} превращает спецификацию в
+ * {@code #RRGGBB} (theme → {@link ThemeModel}, indexed → палитра Excel 97,
+ * tint/shade → коррекция светлоты). Ни один атрибут не задан — auto
+ * ({@link #resolve} вернёт {@code null}, Word рисует «auto»).
+ *
+ * @param rgb ARGB-хеks (alpha отбрасывается при разборе) или null
+ * @param indexed значение {@code @indexed} или null
+ * @param theme значение {@code @theme} или null
+ * @param tint {@code @tint} ([-1..1]) или null
+ * @param shade {@code @shade} ([-1..1]) или null
+ */
+record ColorSpec(String rgb, Integer indexed, Integer theme, Double tint, Double shade) {
+
+ /** auto / не задан. */
+ static final ColorSpec AUTO = new ColorSpec(null, null, null, null, null);
+
+ /** Только rgb (без tint/shade) — синтетика генератора/тестов. */
+ static ColorSpec rgb(String hex) {
+ return new ColorSpec(hex, null, null, null, null);
+ }
+
+ /**
+ * Разбор атрибутов элемента {@code color} (CT_Color) с текущей позиции
+ * StAX-читателя: rgb/indexed/theme/tint/shade. Числовые значения,
+ * не парсящиеся как double, — null (битый атрибут не роняет документ).
+ */
+ static ColorSpec fromColorElement(javax.xml.stream.XMLStreamReader xr) {
+ String rgb = XlsxPackage.attr(xr, "rgb");
+ String indexed = XlsxPackage.attr(xr, "indexed");
+ String theme = XlsxPackage.attr(xr, "theme");
+ Double tint = parseDouble(XlsxPackage.attr(xr, "tint"));
+ Double shade = parseDouble(XlsxPackage.attr(xr, "shade"));
+ Integer idx = parseInt(indexed);
+ Integer th = parseInt(theme);
+ if (rgb == null && idx == null && th == null && tint == null && shade == null) {
+ return AUTO;
+ }
+ return new ColorSpec(rgb, idx, th, tint, shade);
+ }
+
+ static Integer parseInt(String s) {
+ if (s == null) {
+ return null;
+ }
+ try {
+ return Integer.valueOf(s);
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ static Double parseDouble(String s) {
+ if (s == null) {
+ return null;
+ }
+ try {
+ return Double.valueOf(s);
+ } catch (NumberFormatException e) {
+ return null;
+ }
+ }
+
+ /** Есть ли хоть один источник цвета. */
+ boolean isEmpty() {
+ return rgb == null && indexed == null && theme == null;
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java
new file mode 100644
index 0000000..993287c
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java
@@ -0,0 +1,109 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import ru.pjandro.wordpdf.fonts.BundledFonts;
+import ru.pjandro.wordpdf.fonts.GlyphFont;
+
+/**
+ * Метрики ширины столбцов .xlsx в пиксели/ twips. MDW (max digit width,
+ * ECMA-376 §18.3.1.13 note) — максимальная ширина цифры Normal-семейства
+ * (шрифт стиля Normal после алиасов бандла; дефолт Calibri→Carlito, 11 pt,
+ * 96 dpi, fontbox-движок {@link GlyphFont}; сбой чтения — 7 px, ровно
+ * Calibri 11).
+ *
+ *
Формула px (прямая инверсия {@code width}, MS-OI29500 §2.1.598-f и
+ * «Column Width» Office):
+ * {@code px = Truncate((256·w + Truncate(128/MDW)) / 256 · MDW) + 5} —
+ * +5 = 2×2 px полей + 1 px гридлайнов; при w=8.43, MDW=7 даёт канонические
+ * 64 px. Столбец без {@code @width} = {@code baseColWidth} + паддинг-часть
+ * (0.43 знака при MDW=7 — та же формула, решённая для ширины по умолчанию),
+ * {@code @hidden} — 0 px (скрытый столбец не печатается).
+ */
+final class Metrics {
+
+ /** Fallback MDW (px) при недоступности fontbox/шрифта. */
+ static final int FALLBACK_MDW = 7;
+ /** Epsilon ширины по умолчанию: паддинг 5 px в знаках при MDW=7. */
+ private static final double DEFAULT_WIDTH_PAD = 0.43;
+
+ private final int mdw;
+
+ private Metrics(int mdw) {
+ this.mdw = mdw;
+ }
+
+ /**
+ * MDW по семейству стиля Normal: имя → алиасы бандла (маленький регистр),
+ * отсутствующее семейство — Carlito (алиас Calibri).
+ */
+ static Metrics forNormalFamily(String familyName) {
+ int px;
+ try {
+ BundledFonts.init();
+ GlyphFont f = bundled(familyName);
+ double max = 0;
+ for (int d = '0'; d <= '9'; d++) {
+ max = Math.max(max, f.advance(String.valueOf((char) d), 11.0));
+ }
+ px = (int) Math.max(1, Math.round(max * 96.0 / 72.0));
+ } catch (RuntimeException e) {
+ px = FALLBACK_MDW;
+ }
+ return new Metrics(px);
+ }
+
+ /** Шрифт бандла по имени (lowercase) с фолбэком Carlito; null невозможен. */
+ private static GlyphFont bundled(String familyName) {
+ GlyphFont f = familyName == null ? null
+ : GlyphFont.of(familyName.toLowerCase(java.util.Locale.ROOT),
+ BundledFonts.V_REGULAR);
+ if (f == null) {
+ f = GlyphFont.of("carlito", BundledFonts.V_REGULAR);
+ }
+ if (f == null) {
+ throw new IllegalStateException("Бандл без Carlito");
+ }
+ return f;
+ }
+
+ /** MDW в px. */
+ int mdw() {
+ return mdw;
+ }
+
+ /**
+ * Ширина столбца в px: hidden — 0; {@code widthChars == null} —
+ * дефолт {@code baseColWidth + pad}.
+ */
+ int colWidthPx(Double widthChars, double baseColWidth, boolean hidden) {
+ if (hidden) {
+ return 0;
+ }
+ double w = widthChars == null ? baseColWidth + DEFAULT_WIDTH_PAD : widthChars;
+ return (int) Math.floor((256.0 * w + Math.floor(128.0 / mdw)) / 256.0 * mdw) + 5;
+ }
+
+ /** Дефолтная ширина столбца (px) — та же формула без {@code @width}. */
+ int defaultWidthPx(double baseColWidth) {
+ return colWidthPx(null, baseColWidth, false);
+ }
+
+ /** Пиксели в twips (96 dpi → 1/20 pt: 1 px = 15 twips). */
+ static int pxToTwips(int px) {
+ return px * 15;
+ }
+
+ /** Пиксели в EMU (1 px = 9525 EMU, ECMA-376 Part 1 §20.1.1.77-ish). */
+ static long pxToEmu(int px) {
+ return px * 9525L;
+ }
+
+ /** Пункты в twips. */
+ static int ptToTwips(double pt) {
+ return (int) Math.round(pt * 20.0);
+ }
+
+ /** Дюймы в twips. */
+ static int inchesToTwips(double inches) {
+ return (int) Math.round(inches * 1440.0);
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java
new file mode 100644
index 0000000..6632d2e
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java
@@ -0,0 +1,77 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+/**
+ * General-вывод значения ячейки (§18.8.30 примечания) и текстовые типы:
+ * число — кратчайкая round-trip запись без хвостовых нулей; |x| ≥ 1e10 или
+ * ≠0 и < 1e-9 — научный с 10 знаками (как Excel General). Полный
+ * движок форматных кодов — {@link NumberFormats}; здесь — то, что едет
+ * при {@code numFmt="General"} и в fallback'ах.
+ */
+final class NumberText {
+
+ private NumberText() {
+ }
+
+ /**
+ * Текст ячейки по типу {@code @t}: {@code b} — TRUE/FALSE, {@code e} —
+ * сырая ошибка, {@code str} — строка кэша формулы, число (null/"n") —
+ * General. {@code s}/{@code inlineStr} сюда не доходят (раны),
+ * {@code d} — ISO-строка как есть (парсинг дат — {@link NumberFormats}).
+ */
+ static String of(String raw, String type) {
+ if (raw == null) {
+ return "";
+ }
+ return switch (type == null ? "" : type) {
+ case "b" -> "1".equals(raw.trim()) ? "TRUE" : "FALSE";
+ case "e", "str", "d" -> raw;
+ default -> general(raw);
+ };
+ }
+
+ /** General по сырой строке {@code v}: парсится в double — форматим, нет — как есть. */
+ static String general(String raw) {
+ double value;
+ try {
+ value = Double.parseDouble(raw.trim());
+ } catch (NumberFormatException e) {
+ return raw;
+ }
+ if (value == Math.rint(value) && !Double.isInfinite(value)
+ && Math.abs(value) < 1e15) {
+ return Long.toString((long) value);
+ }
+ return decimalOrScientific(value);
+ }
+
+ /**
+ * Дробное: shortest round-trip без хвостовых нулей; диапазон — научный
+ * {@code 0.##########E+xx} (10 значащих знаков, экспонента с знаком и
+ * минимум двумя цифрами — Excel General).
+ */
+ static String decimalOrScientific(double value) {
+ double abs = Math.abs(value);
+ if (abs == 0 || abs < 1e10 && abs >= 1e-9) {
+ return shortestRepr(value);
+ }
+ String sci = String.format(java.util.Locale.ROOT, "%.9E", value);
+ int e = sci.indexOf('E');
+ double mantissa = Double.parseDouble(sci.substring(0, e));
+ int exponent = Integer.parseInt(sci.substring(e + 1));
+ String mant = shortestRepr(mantissa).replace("-", "-");
+ return mant + "E" + (exponent < 0 ? "-" : "+")
+ + String.format(java.util.Locale.ROOT, "%02d", Math.abs(exponent));
+ }
+
+ /** Кратчайая десятичная запись double без хвостового «.0». */
+ private static String shortestRepr(double value) {
+ String s = Double.toString(value);
+ if (s.indexOf('E') >= 0 || s.indexOf('e') >= 0) {
+ return s;
+ }
+ if (s.endsWith(".0")) {
+ return s.substring(0, s.length() - 2);
+ }
+ return s;
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java
new file mode 100644
index 0000000..3373de1
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java
@@ -0,0 +1,200 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * {@code xl/sharedStrings.xml} (ECMA-376 §18.5): таблица строк {@code sst},
+ * элемент {@code si} — plain-{@code t} или rich-раны {@code r} (§18.4.1:
+ * {@code r/t} + {@code rPr}). Ран сохраняется списком {@link Run} (стили
+ * не схлопываются — Word рисует rich-строку несколькими {@code w:r}).
+ * Фонетика {@code rPh} вырезается (как руби в правиле 10 — надстрочница
+ * в PDF не печатается).
+ *
+ * Тот же разбор {@code CT_Rst} используется для inlineStr-ячеек
+ * ( worksheet §18.3.1.53 {@code is} — та же структура), см.
+ * {@link #parseRst(XMLStreamReader, WarnOnce)}.
+ */
+final class SharedStrings {
+
+ /** Фрагмент rich-строки; {@code style == null} — стиль ячейки. */
+ record Run(String text, RunStyle style) {
+ }
+
+ /** Переопределение rPr rich-рана (ECMA-376 §18.4.8 CT_RPrElt). */
+ record RunStyle(Boolean bold, Boolean italic, String underline, Boolean strikeout,
+ Double sizePt, ColorSpec color, String fontName, String vertAlign) {
+
+ boolean isEmpty() {
+ return bold == null && italic == null && underline == null && strikeout == null
+ && sizePt == null && (color == null || color.isEmpty())
+ && fontName == null && vertAlign == null;
+ }
+ }
+
+ private static final Logger LOG = LoggerFactory.getLogger(SharedStrings.class);
+ private static final String SST_PART = "xl/sharedStrings.xml";
+ static final List NO_RUNS = List.of();
+
+ private final List> items;
+
+ private SharedStrings(List> items) {
+ this.items = items;
+ }
+
+ static SharedStrings read(XlsxPackage pkg, WarnOnce warn) throws IOException {
+ byte[] data = pkg.entry(SST_PART);
+ List> items = new ArrayList<>();
+ if (data == null) {
+ return new SharedStrings(items);
+ }
+ try {
+ XMLStreamReader xr = XlsxPackage.newSecureReader()
+ .createXMLStreamReader(new ByteArrayInputStream(data));
+ while (xr.hasNext()) {
+ if (xr.next() == XMLStreamReader.START_ELEMENT
+ && "si".equals(xr.getLocalName())) {
+ items.add(parseRst(xr, warn));
+ }
+ }
+ xr.close();
+ } catch (XMLStreamException e) {
+ throw new IOException("Не удалось разобрать xl/sharedStrings.xml", e);
+ }
+ return new SharedStrings(items);
+ }
+
+ /** Строка по индексу SST; индекс за таблицей — пусто + warn (§18.5). */
+ List at(int index, WarnOnce warn) {
+ if (index < 0 || index >= items.size()) {
+ warn.warn(LOG, "Индекс shared string {} вне таблицы ({} записей) — пустая строка",
+ index, items.size());
+ return NO_RUNS;
+ }
+ return items.get(index);
+ }
+
+ /**
+ * Разбор {@code CT_Rst} с текущей позиции (читатель стоит на START
+ * {@code si}/{@code is}): plain-{@code t}, ран {@code r} (текст + rPr),
+ * {@code rPh} — вырезается. Вызов потребляет элемент целиком.
+ */
+ static List parseRst(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException {
+ List runs = new ArrayList<>();
+ StringBuilder plain = new StringBuilder();
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "t" -> plain.append(xr.getElementText());
+ case "r" -> runs.add(parseRun(xr));
+ case "rPh" -> skipElement(xr);
+ default -> skipElement(xr);
+ }
+ }
+ if (plain.length() > 0) {
+ runs.add(0, new Run(plain.toString(), null));
+ }
+ return runs;
+ }
+
+ /** Ран {@code r}: текст из {@code t}, переопределения из {@code rPr}. */
+ private static Run parseRun(XMLStreamReader xr) throws XMLStreamException {
+ StringBuilder text = new StringBuilder();
+ RunStyle style = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ String name = xr.getLocalName();
+ switch (name) {
+ case "t" -> text.append(xr.getElementText());
+ case "rPr" -> style = parseRPr(xr);
+ default -> skipElement(xr);
+ }
+ }
+ return new Run(text.toString(), style != null && !style.isEmpty() ? style : null);
+ }
+
+ /** {@code CT_RPrElt}: b, i, u, strike, sz, color, vertAlign, rFont. */
+ private static RunStyle parseRPr(XMLStreamReader xr) throws XMLStreamException {
+ Boolean bold = null;
+ Boolean italic = null;
+ String underline = null;
+ Boolean strikeout = null;
+ Double size = null;
+ ColorSpec color = null;
+ String font = null;
+ String vertAlign = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "b" -> bold = boolVal(xr);
+ case "i" -> italic = boolVal(xr);
+ case "strike" -> strikeout = boolVal(xr);
+ case "u" -> {
+ String v = XlsxPackage.attr(xr, "val");
+ underline = v == null || "none".equals(v) ? null : v;
+ }
+ case "sz" -> size = ColorSpec.parseDouble(XlsxPackage.attr(xr, "val"));
+ case "color" -> color = ColorSpec.fromColorElement(xr);
+ case "vertAlign" -> {
+ String v = XlsxPackage.attr(xr, "val");
+ vertAlign = v == null || "baseline".equals(v) ? null : v;
+ }
+ case "rFont" -> font = XlsxPackage.attr(xr, "val");
+ default -> {
+ }
+ }
+ // дочерний листок (b/sz/color/…) обязан быть потреблён целиком,
+ // иначе его END досрочно прервёт разбор rPr
+ skipElement(xr);
+ }
+ return new RunStyle(bold, italic, underline, strikeout, size, color, font, vertAlign);
+ }
+
+ /** Три-state булева атрибута {@code @val}: absent — true, none/0/false — false. */
+ static Boolean boolVal(XMLStreamReader xr) {
+ String v = XlsxPackage.attr(xr, "val");
+ if (v == null) {
+ return Boolean.TRUE;
+ }
+ return !("0".equals(v) || "false".equalsIgnoreCase(v) || "none".equalsIgnoreCase(v));
+ }
+
+ /** Потребить элемент с текущей позиции (START) до его END. */
+ static void skipElement(XMLStreamReader xr) throws XMLStreamException {
+ int depth = 1;
+ while (xr.hasNext() && depth > 0) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.START_ELEMENT) {
+ depth++;
+ } else if (ev == XMLStreamConstants.END_ELEMENT) {
+ depth--;
+ }
+ }
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java
new file mode 100644
index 0000000..d10fdc3
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java
@@ -0,0 +1,500 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * One worksheet part (§18.3.1): структура листа целиком — колонки/строки/
+ * ячейки, merge'ы, внешние гиперссылки, ручные разрывы строк, page setup и
+ * ссылки на drawing/OLE. Разбор StAX; любые не разобранные части —
+ * «пустой лист»/игнор по деградационному контракту моста.
+ *
+ * Ячейка хранится СЫРОЙ строкой {@code v}/{@code is} + типом {@code @t}:
+ * форматирование чисел/дат — {@link NumberFormats} на этапе эмитта (формула
+ * без кэша {@code } — пустая ячейка + warn).
+ */
+final class SheetModel {
+
+ /** Колонка {@code cols/col} (range развёрнут по индексам). */
+ record ColDef(Double width, boolean hidden, Integer style) {
+ }
+
+ /** Ячейка {@code c} (§18.3.1.4): сырое значение, rich-раны, тип, индекс xf. */
+ record CellData(String raw, List runs, String type, Integer styleIdx) {
+ }
+
+ /** Строка {@code row} (§18.3.1.73): индекс 1-based {@code @r} → данные. */
+ record RowData(Double ht, boolean customHeight, boolean hidden, Integer styleIdx,
+ boolean customFormat, Map cells) {
+
+ /** Стиль строки, применяемый к ячейкам без своего (только при {@code @customFormat}). */
+ Integer effectiveStyle() {
+ return customFormat ? styleIdx : null;
+ }
+ }
+
+ /** Прямоугольник merge'а (§18.3.1.54), индексы 0-based включительно. */
+ record Merge(int row1, int row2, int col1, int col2) {
+ }
+
+ /** {@code pageSetup} (§18.3.1.63) + {@code pageSetUpPr/@fitToPage}. */
+ record PageSetup(int paperSize, boolean landscape, int scale, int fitToWidth,
+ int fitToHeight, boolean fitToPage) {
+ }
+
+ /** {@code pageMargins} в дюймах (§18.3.1.67). */
+ record Margins(double left, double right, double top, double bottom,
+ double header, double footer) {
+ }
+
+ private static final Logger LOG = LoggerFactory.getLogger(SheetModel.class);
+ private static final String REL_NS =
+ "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+ private static final String HYPERLINK_REL_TYPE =
+ "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink";
+ /** Дефициты pageMargins по §18.3.1.67. */
+ private static final double DEF_MARGIN_LR = 0.7;
+ private static final double DEF_MARGIN_TB = 0.75;
+ private static final double DEF_MARGIN_HF = 0.3;
+ /** Дефолт sheetFormatPr/@defaultRowHeight (pt) и @baseColWidth (знаков). */
+ private static final double DEF_ROW_HEIGHT = 15.0;
+ private static final double DEF_BASE_COL_WIDTH = 8.0;
+
+ private final TreeMap rows = new TreeMap<>();
+ private final Map cols = new HashMap<>();
+ private final List merges = new ArrayList<>();
+ private final Map externalLinks = new HashMap<>();
+ private final List rowBreaks = new ArrayList<>();
+ private double defaultRowHeight = DEF_ROW_HEIGHT;
+ private double baseColWidth = DEF_BASE_COL_WIDTH;
+ private PageSetup pageSetup = new PageSetup(9, false, 100, 1, 1, false);
+ private Margins margins = new Margins(DEF_MARGIN_LR, DEF_MARGIN_LR,
+ DEF_MARGIN_TB, DEF_MARGIN_TB, DEF_MARGIN_HF, DEF_MARGIN_HF);
+ private String drawingPath;
+ private boolean olePresent;
+ /** Максимальный использованный индекс колонки+1 (0 — ячеек нет). */
+ private int usedCols;
+
+ private SheetModel() {
+ }
+
+ TreeMap rows() {
+ return rows;
+ }
+
+ Map cols() {
+ return cols;
+ }
+
+ List merges() {
+ return merges;
+ }
+
+ Map externalLinks() {
+ return externalLinks;
+ }
+
+ List rowBreaks() {
+ return rowBreaks;
+ }
+
+ double defaultRowHeight() {
+ return defaultRowHeight;
+ }
+
+ double baseColWidth() {
+ return baseColWidth;
+ }
+
+ PageSetup pageSetup() {
+ return pageSetup;
+ }
+
+ Margins margins() {
+ return margins;
+ }
+
+ String drawingPath() {
+ return drawingPath;
+ }
+
+ boolean olePresent() {
+ return olePresent;
+ }
+
+ int usedCols() {
+ return usedCols;
+ }
+
+ ColDef col(int index) {
+ return cols.get(index);
+ }
+
+ /** Стиль колонки (индекс xf) или null. */
+ Integer colStyle(int index) {
+ ColDef c = cols.get(index);
+ return c == null ? null : c.style();
+ }
+
+ static SheetModel read(XlsxPackage pkg, WorkbookModel.Sheet sheet, WarnOnce warn)
+ throws IOException {
+ byte[] data = pkg.entry(sheet.partPath());
+ SheetModel model = new SheetModel();
+ if (data == null) {
+ warn.warn(LOG, "Часть листа {} отсутствует — пустой лист", sheet.partPath());
+ return model;
+ }
+ Map sheetLinks = hyperlinkTargets(pkg, sheet.partPath());
+ try {
+ XMLStreamReader xr = XlsxPackage.newSecureReader()
+ .createXMLStreamReader(new ByteArrayInputStream(data));
+ model.parse(xr, sheetLinks, warn, pkg, sheet.partPath());
+ xr.close();
+ } catch (XMLStreamException e) {
+ throw new IOException("Не удалось разобрать часть листа " + sheet.partPath(), e);
+ }
+ return model;
+ }
+
+ /** ref ячейки → внешний target гиперссылки (rel part-листа). */
+ private static Map hyperlinkTargets(XlsxPackage pkg, String sheetPart) {
+ Map byId = new HashMap<>();
+ for (XlsxPackage.Rel rel : pkg.rels(sheetPart)) {
+ if (HYPERLINK_REL_TYPE.equals(rel.type()) && rel.external()) {
+ byId.putIfAbsent(rel.id(), rel.target());
+ }
+ }
+ return byId;
+ }
+
+ private void parse(XMLStreamReader xr, Map sheetLinks, WarnOnce warn,
+ XlsxPackage pkg, String sheetPart) throws XMLStreamException {
+ boolean rootOpen = false;
+ while (!rootOpen && xr.hasNext()) {
+ // до START корня worksheet
+ rootOpen = xr.next() == XMLStreamConstants.START_ELEMENT;
+ }
+ // корень уже открыт — диспатчим только его детей (иначе default-skip
+ // проглотит весь документ)
+ while (xr.hasNext()) {
+ if (xr.next() != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "sheetPr" -> parseSheetPr(xr);
+ case "sheetFormatPr" -> parseSheetFormatPr(xr);
+ case "cols" -> parseCols(xr, warn);
+ case "sheetData" -> parseSheetData(xr, warn);
+ case "mergeCells" -> parseMergeCells(xr);
+ case "hyperlinks" -> parseHyperlinks(xr, sheetLinks);
+ case "drawing" -> {
+ String rid = XlsxPackage.attrNs(xr, REL_NS, "id");
+ drawingPath = rid == null ? null : pkg.relTargetPath(sheetPart, rid);
+ }
+ case "rowBreaks" -> parseRowBreaks(xr);
+ case "pageMargins" -> parsePageMargins(xr);
+ case "pageSetup" -> parsePageSetup(xr);
+ case "printOptions" -> parsePrintOptions(xr, warn);
+ case "legacyDrawing", "legacyDrawingHF", "oleObjects", "controls" ->
+ olePresent = true;
+ default -> SharedStrings.skipElement(xr);
+ }
+ }
+ }
+
+ private void parseSheetPr(XMLStreamReader xr) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT && "pageSetUpPr".equals(xr.getLocalName())) {
+ boolean fit = XlsxPackage.truthy(XlsxPackage.attr(xr, "fitToPage"));
+ pageSetup = new PageSetup(pageSetup.paperSize(), pageSetup.landscape(),
+ pageSetup.scale(), pageSetup.fitToWidth(), pageSetup.fitToHeight(), fit);
+ SharedStrings.skipElement(xr);
+ } else if (ev == XMLStreamConstants.START_ELEMENT) {
+ SharedStrings.skipElement(xr);
+ }
+ }
+ }
+
+ private void parseSheetFormatPr(XMLStreamReader xr) {
+ Double h = ColorSpec.parseDouble(XlsxPackage.attr(xr, "defaultRowHeight"));
+ if (h != null && h > 0) {
+ defaultRowHeight = h;
+ }
+ Double b = ColorSpec.parseDouble(XlsxPackage.attr(xr, "baseColWidth"));
+ if (b != null && b > 0) {
+ baseColWidth = b;
+ }
+ }
+
+ private void parseCols(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT || !"col".equals(xr.getLocalName())) {
+ continue;
+ }
+ Integer min = ColorSpec.parseInt(XlsxPackage.attr(xr, "min"));
+ Integer max = ColorSpec.parseInt(XlsxPackage.attr(xr, "max"));
+ Double width = ColorSpec.parseDouble(XlsxPackage.attr(xr, "width"));
+ boolean hidden = XlsxPackage.truthy(XlsxPackage.attr(xr, "hidden"));
+ Integer style = ColorSpec.parseInt(XlsxPackage.attr(xr, "style"));
+ SharedStrings.skipElement(xr); // листок col доедает свой END
+ if (min == null || min < 1) {
+ continue;
+ }
+ int hi = max == null || max < min ? min : max;
+ ColDef def = new ColDef(width, hidden, style);
+ for (int i = min - 1; i < hi; i++) {
+ // пересечение записей col — первая выигрывает (Excel пишет
+ // непересекающиеся; пересечение — брак генератора)
+ if (cols.putIfAbsent(i, def) == null) {
+ continue;
+ }
+ warn.warn(LOG, "Перекрывающаяся запись col для индекса {} — первая выигрывает", i);
+ }
+ }
+ }
+
+ private void parseSheetData(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT || !"row".equals(xr.getLocalName())) {
+ continue;
+ }
+ Integer r = ColorSpec.parseInt(XlsxPackage.attr(xr, "r"));
+ if (r == null || r < 1) {
+ continue;
+ }
+ Double ht = ColorSpec.parseDouble(XlsxPackage.attr(xr, "ht"));
+ boolean customHeight = XlsxPackage.truthy(XlsxPackage.attr(xr, "customHeight"));
+ boolean hidden = XlsxPackage.truthy(XlsxPackage.attr(xr, "hidden"));
+ Integer rowStyle = ColorSpec.parseInt(XlsxPackage.attr(xr, "s"));
+ boolean customFormat = XlsxPackage.truthy(XlsxPackage.attr(xr, "customFormat"));
+ Map cells = new HashMap<>();
+ parseCells(xr, cells, warn);
+ rows.put(r, new RowData(ht, customHeight, hidden, rowStyle, customFormat, cells));
+ }
+ }
+
+ /** Дочерние {@code c} текущей {@code row}; вызов на START row, выход на END row. */
+ private void parseCells(XMLStreamReader xr, Map cells, WarnOnce warn)
+ throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT || !"c".equals(xr.getLocalName())) {
+ continue;
+ }
+ String ref = XlsxPackage.attr(xr, "r");
+ Integer style = ColorSpec.parseInt(XlsxPackage.attr(xr, "s"));
+ String type = XlsxPackage.attr(xr, "t");
+ int[] rc = parseRef(ref);
+ int col = rc.length == 0 ? cells.size() : rc[1];
+ CellData cell = readCell(xr, type, style, warn);
+ cells.put(col, cell);
+ usedCols = Math.max(usedCols, col + 1);
+ }
+ }
+
+ /** Дети ячейки: v/is/f — вызов на START c. */
+ private CellData readCell(XMLStreamReader xr, String type, Integer style, WarnOnce warn)
+ throws XMLStreamException {
+ String v = null;
+ List runs = null;
+ boolean hasFormula = false;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "v" -> v = xr.getElementText();
+ case "is" -> runs = SharedStrings.parseRst(xr, warn);
+ case "f" -> {
+ hasFormula = true;
+ SharedStrings.skipElement(xr);
+ }
+ default -> SharedStrings.skipElement(xr); // r (formula2) — игнор
+ }
+ }
+ if (v == null && runs == null && hasFormula) {
+ warn.warn(LOG, "Формула без кэшированного значения — пустая ячейка");
+ }
+ return new CellData(v, runs, type, style);
+ }
+
+ private void parseMergeCells(XMLStreamReader xr) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT
+ && "mergeCell".equals(xr.getLocalName())) {
+ String ref = XlsxPackage.attr(xr, "ref");
+ SharedStrings.skipElement(xr);
+ int[] range = parseRange(ref);
+ if (range.length > 0) {
+ merges.add(new Merge(range[0], range[2], range[1], range[3]));
+ }
+ }
+ }
+ }
+
+ private void parseHyperlinks(XMLStreamReader xr, Map sheetLinks)
+ throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT
+ || !"hyperlink".equals(xr.getLocalName())) {
+ continue;
+ }
+ String ref = XlsxPackage.attr(xr, "ref");
+ String rid = XlsxPackage.attrNs(xr, REL_NS, "id");
+ SharedStrings.skipElement(xr);
+ // @location (внутренний переход) — бросается без warn: PDF-ссылок
+ // внутри документа мост не эмитит (деградация v1)
+ if (ref != null && rid != null) {
+ String target = sheetLinks.get(rid);
+ if (target != null) {
+ externalLinks.put(ref, target);
+ }
+ }
+ }
+ }
+
+ /** id ручных разрывов строк (1-based, семантика — см. SheetToTable). */
+ private void parseRowBreaks(XMLStreamReader xr) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT && "brk".equals(xr.getLocalName())) {
+ String man = XlsxPackage.attr(xr, "man");
+ Integer id = ColorSpec.parseInt(XlsxPackage.attr(xr, "id"));
+ SharedStrings.skipElement(xr);
+ // man absent/truthy — ручной; id — 1-based номер строки, после
+ // которой разрыв (POI setRowBreak(11) → id=12, фикстура xlsx-wide)
+ if (id != null && id >= 1
+ && !"0".equals(man) && !"false".equalsIgnoreCase(man)) {
+ rowBreaks.add(id);
+ }
+ }
+ }
+ }
+
+ private void parsePageMargins(XMLStreamReader xr) {
+ Double left = ColorSpec.parseDouble(XlsxPackage.attr(xr, "left"));
+ Double right = ColorSpec.parseDouble(XlsxPackage.attr(xr, "right"));
+ Double top = ColorSpec.parseDouble(XlsxPackage.attr(xr, "top"));
+ Double bottom = ColorSpec.parseDouble(XlsxPackage.attr(xr, "bottom"));
+ Double header = ColorSpec.parseDouble(XlsxPackage.attr(xr, "header"));
+ Double footer = ColorSpec.parseDouble(XlsxPackage.attr(xr, "footer"));
+ margins = new Margins(
+ left == null ? DEF_MARGIN_LR : left,
+ right == null ? DEF_MARGIN_LR : right,
+ top == null ? DEF_MARGIN_TB : top,
+ bottom == null ? DEF_MARGIN_TB : bottom,
+ header == null ? DEF_MARGIN_HF : header,
+ footer == null ? DEF_MARGIN_HF : footer);
+ }
+
+ private void parsePageSetup(XMLStreamReader xr) {
+ Integer paper = ColorSpec.parseInt(XlsxPackage.attr(xr, "paperSize"));
+ boolean landscape = "landscape".equals(XlsxPackage.attr(xr, "orientation"));
+ Integer scale = ColorSpec.parseInt(XlsxPackage.attr(xr, "scale"));
+ Integer fitW = ColorSpec.parseInt(XlsxPackage.attr(xr, "fitToWidth"));
+ Integer fitH = ColorSpec.parseInt(XlsxPackage.attr(xr, "fitToHeight"));
+ pageSetup = new PageSetup(paper == null ? 9 : paper, landscape,
+ scale == null ? 100 : scale,
+ fitW == null ? 1 : fitW, fitH == null ? 1 : fitH, pageSetup.fitToPage());
+ }
+
+ private void parsePrintOptions(XMLStreamReader xr, WarnOnce warn) {
+ if (XlsxPackage.truthy(XlsxPackage.attr(xr, "horizontalCentered"))
+ && !"0".equals(XlsxPackage.attr(xr, "horizontalCentered"))) {
+ warn.warn(LOG, "horizontalCentered игнорируется (центрирование страниц в v1 не эмитится)");
+ }
+ if (XlsxPackage.truthy(XlsxPackage.attr(xr, "verticalCentered"))
+ && !"0".equals(XlsxPackage.attr(xr, "verticalCentered"))) {
+ warn.warn(LOG, "verticalCentered игнорируется");
+ }
+ if (XlsxPackage.truthy(XlsxPackage.attr(xr, "gridLines"))
+ && !"0".equals(XlsxPackage.attr(xr, "gridLines"))) {
+ warn.warn(LOG, "gridLines при печати игнорируется (сетка ячеек не рисуется)");
+ }
+ }
+
+ /**
+ * ref ячейки/якоря {@code "AB12"} → {row, col} (0-based); битый ref —
+ * пустой массив (PMD: null-массивов нет).
+ */
+ static int[] parseRef(String ref) {
+ if (ref == null || ref.isEmpty()) {
+ return new int[0];
+ }
+ int letters = 0;
+ while (letters < ref.length() && Character.isLetter(ref.charAt(letters))) {
+ letters++;
+ }
+ if (letters == 0 || letters == ref.length()) {
+ return new int[0];
+ }
+ int col = 0;
+ for (int i = 0; i < letters; i++) {
+ col = col * 26 + Character.toUpperCase(ref.charAt(i)) - 'A' + 1;
+ }
+ Integer row = ColorSpec.parseInt(ref.substring(letters));
+ if (row == null || row < 1) {
+ return new int[0];
+ }
+ return new int[] {row - 1, col - 1};
+ }
+
+ /** Диапазон {@code "B2:D2"} → {r1,c1,r2,c2} (0-based); битый — пустой массив. */
+ static int[] parseRange(String range) {
+ if (range == null || range.isEmpty()) {
+ return new int[0];
+ }
+ String[] parts = range.split(":");
+ int[] a = parseRef(parts[0].trim());
+ if (a.length == 0) {
+ return new int[0];
+ }
+ int[] b = parts.length > 1 ? parseRef(parts[1].trim()) : a;
+ if (b.length == 0) {
+ b = a;
+ }
+ return new int[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]),
+ Math.max(a[0], b[0]), Math.max(a[1], b[1])};
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java
new file mode 100644
index 0000000..06eed24
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java
@@ -0,0 +1,426 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+import ru.pjandro.wordpdf.internal.DocxPackageWriter;
+
+/**
+ * Эмитт листа в Word-таблицу фиксированной сетки: одна {@code w:tbl} на лист
+ * (каркас v1 — шаг 4: значения, шрифт, jc, merge, скрытые строки/столбцы,
+ * внешние гиперссылки; полные границы/заливки/цвета/numFmt/vAlign — шаг 5,
+ * нарезка на срезы и секции — шаг 6).
+ *
+ * Разрывы строк {@code rowBreaks/@id}: семантика Excel — id это 1-based
+ * номер строки, ПОСЛЕ которой печатная страница обрывается (POI
+ * {@code setRowBreak(11)} пишет {@code id="12"}; фикстура xlsx-wide,
+ * регрессия — XlsxPdfConverterTest#rowBreak_pages). Резку выполняет
+ * планировщик блоков шага 6.
+ */
+final class SheetToTable {
+
+ /** Роль ячейки в merge-прямоугольнике. */
+ private enum MergeRole { NONE, ORIGIN, H_CONT, V_CONT }
+
+ /** Дефолт CT_Font/@sz при отсутствии таблицы шрифтов. */
+ private static final double DEFAULT_SIZE_PT = 11.0;
+
+ /** gridSpan одиночной ячейки не эмитится (§17.4.76: по умолчанию 1). */
+ private static final int SINGLE_CELL_SPAN = 1;
+
+ private SheetToTable() {
+ }
+
+ /**
+ * Фрагмент {@code } для листа: таблица (+ рисунки — шаг 7).
+ * Пустой лист — пустая строка (секция шага 6 даст свою страницу).
+ *
+ * @param hyperlinks дедуплицированный порядок targets внешних ссылок
+ * (id {@code hl0…} = позиция множества)
+ */
+ static String emit(SheetModel sheet, StylesModel styles, SharedStrings sst,
+ WorkbookModel wb, Metrics metrics, List parts,
+ LinkedHashSet hyperlinks, WarnOnce warn) {
+ int totalCols = totalColumns(sheet);
+ List visibleCols = new ArrayList<>();
+ for (int c = 0; c < totalCols; c++) {
+ SheetModel.ColDef def = sheet.col(c);
+ if (def == null || !def.hidden()) {
+ visibleCols.add(c);
+ }
+ }
+ StringBuilder xml = new StringBuilder();
+ xml.append("")
+ .append("");
+ for (int c : visibleCols) {
+ xml.append("");
+ }
+ xml.append("");
+ int emittedRows = 0;
+ for (var e : sheet.rows().entrySet()) {
+ SheetModel.RowData row = e.getValue();
+ if (row.hidden()) {
+ continue;
+ }
+ if (!isSignificant(sheet, row, e.getKey())) {
+ continue;
+ }
+ emitRow(xml, e.getKey(), row, sheet, styles, sst, metrics, visibleCols,
+ hyperlinks, warn);
+ emittedRows++;
+ }
+ if (emittedRows == 0) {
+ return "";
+ }
+ xml.append("");
+ return xml.toString();
+ }
+
+ /** Максимальная колонка данных/merge'ей (exclusive). */
+ private static int totalColumns(SheetModel sheet) {
+ int total = sheet.usedCols();
+ for (SheetModel.Merge m : sheet.merges()) {
+ total = Math.max(total, m.col2() + 1);
+ }
+ return total;
+ }
+
+ private static int colTwips(SheetModel sheet, Metrics metrics, int col) {
+ SheetModel.ColDef def = sheet.col(col);
+ return Metrics.pxToTwips(metrics.colWidthPx(def == null ? null : def.width(),
+ sheet.baseColWidth(), def != null && def.hidden()));
+ }
+
+ /** Строку эмитим, когда в ней есть значение, стиль (s≠0) или merge. */
+ private static boolean isSignificant(SheetModel sheet, SheetModel.RowData row, int rowNum1) {
+ if (row.styleIdx() != null && row.styleIdx() > 0) {
+ return true;
+ }
+ for (var c : row.cells().values()) {
+ if (c.raw() != null || c.runs() != null
+ || (c.styleIdx() != null && c.styleIdx() > 0)) {
+ return true;
+ }
+ }
+ int r = rowNum1 - 1;
+ for (SheetModel.Merge m : sheet.merges()) {
+ if (r >= m.row1() && r <= m.row2()) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static void emitRow(StringBuilder xml, int rowNum1, SheetModel.RowData row,
+ SheetModel sheet, StylesModel styles, SharedStrings sst, Metrics metrics,
+ List visibleCols, LinkedHashSet hyperlinks, WarnOnce warn) {
+ int r = rowNum1 - 1;
+ xml.append("");
+ for (int c : visibleCols) {
+ MergeRole role = mergeRole(sheet, r, c);
+ switch (role) {
+ case V_CONT -> xml.append("");
+ case H_CONT -> xml.append("");
+ default -> emitCell(xml, r, c, row, role, sheet, styles, sst, metrics,
+ visibleCols, hyperlinks, warn);
+ }
+ }
+ xml.append("");
+ }
+
+ /** Высота строки exact (Excel печатает фиксированную сетку). */
+ private static int trHeightTwips(SheetModel.RowData row, SheetModel sheet) {
+ double pt = row.ht() == null ? sheet.defaultRowHeight() : row.ht();
+ return Metrics.ptToTwips(pt);
+ }
+
+ /**
+ * ORIGIN — первая видимая колонка диапазона; при скрытой origin-строке/
+ * колонке контент доезжает до первой видимой ячейки диапазона (план).
+ * H_CONT — продолжение по горизонтали (пустая {@code w:tc}),
+ * V_CONT — продолжение по вертикали ({@code w:vMerge}).
+ */
+ private static MergeRole mergeRole(SheetModel sheet, int r, int c) {
+ for (SheetModel.Merge m : sheet.merges()) {
+ if (r < m.row1() || r > m.row2() || c < m.col1() || c > m.col2()) {
+ continue;
+ }
+ boolean firstVisibleCol = firstVisibleColOf(sheet, m) == c;
+ boolean originRow = verticalOriginRow(sheet, m) == r;
+ if (firstVisibleCol && originRow) {
+ return MergeRole.ORIGIN;
+ }
+ return originRow ? MergeRole.H_CONT : MergeRole.V_CONT;
+ }
+ return MergeRole.NONE;
+ }
+
+ private static int firstVisibleColOf(SheetModel sheet, SheetModel.Merge m) {
+ for (int c = m.col1(); c <= m.col2(); c++) {
+ SheetModel.ColDef def = sheet.col(c);
+ if (def == null || !def.hidden()) {
+ return c;
+ }
+ }
+ return m.col1();
+ }
+
+ /** Первая видимая строка диапазона (все скрытые — формально первая). */
+ private static int verticalOriginRow(SheetModel sheet, SheetModel.Merge m) {
+ for (int r = m.row1(); r <= m.row2(); r++) {
+ SheetModel.RowData row = sheet.rows().get(r + 1);
+ if (row == null || !row.hidden()) {
+ return r;
+ }
+ }
+ return m.row1();
+ }
+
+ private static void emitCell(StringBuilder xml, int r, int c, SheetModel.RowData row,
+ MergeRole role, SheetModel sheet, StylesModel styles, SharedStrings sst,
+ Metrics metrics, List visibleCols, LinkedHashSet hyperlinks,
+ WarnOnce warn) {
+ xml.append("");
+ SheetModel.Merge merge = role == MergeRole.ORIGIN ? sheetMergeAt(sheet, r, c) : null;
+ if (merge != null) {
+ int span = gridSpan(merge, visibleCols);
+ if (span != SINGLE_CELL_SPAN) {
+ xml.append("");
+ }
+ if (merge.row2() > merge.row1()) {
+ xml.append("");
+ }
+ }
+ xml.append("");
+ SheetModel.CellData cell = contentCell(sheet, row, r, c, merge);
+ // стиль — физической ячейки позиции (редирект контента стиль не переносит)
+ int styleIdx = resolveStyle(row.cells().get(c), row, sheet, c);
+ String linkId = hyperlinkId(sheet, r, c, hyperlinks);
+ emitParagraph(xml, cell, styleIdx, linkId, styles, sst, warn);
+ xml.append("");
+ }
+
+ /**
+ * Содержимое ячейки: при редиректе origin'а (скрытая строка/колонка) —
+ * значение из фактической origin-клетки диапазона.
+ */
+ private static SheetModel.CellData contentCell(SheetModel sheet, SheetModel.RowData row,
+ int r, int c, SheetModel.Merge merge) {
+ SheetModel.CellData own = row.cells().get(c);
+ if (merge == null || (r == merge.row1() && c == merge.col1())
+ || own == null || hasContent(own)) {
+ return own;
+ }
+ SheetModel.RowData originRow = sheet.rows().get(merge.row1() + 1);
+ if (originRow == null) {
+ return own;
+ }
+ SheetModel.CellData origin = originRow.cells().get(merge.col1());
+ return origin != null && hasContent(origin) ? origin : own;
+ }
+
+ private static boolean hasContent(SheetModel.CellData cell) {
+ return cell.raw() != null || cell.runs() != null;
+ }
+
+ private static SheetModel.Merge sheetMergeAt(SheetModel sheet, int r, int c) {
+ for (SheetModel.Merge m : sheet.merges()) {
+ if (r >= m.row1() && r <= m.row2() && c >= m.col1() && c <= m.col2()) {
+ return m;
+ }
+ }
+ return null;
+ }
+
+ /** Число видимых колонок диапазона. */
+ private static int gridSpan(SheetModel.Merge m, List visibleCols) {
+ int span = 0;
+ for (int c : visibleCols) {
+ if (c >= m.col1() && c <= m.col2()) {
+ span++;
+ }
+ }
+ return Math.max(1, span);
+ }
+
+ /** cell s → row s (@customFormat) → col s → 0. */
+ private static int resolveStyle(SheetModel.CellData cell, SheetModel.RowData row,
+ SheetModel sheet, int c) {
+ if (cell != null && cell.styleIdx() != null) {
+ return cell.styleIdx();
+ }
+ Integer rowStyle = row.effectiveStyle();
+ if (rowStyle != null) {
+ return rowStyle;
+ }
+ Integer colStyle = sheet.colStyle(c);
+ return colStyle == null ? 0 : colStyle;
+ }
+
+ /** {@code hlN} для ячейки внутри диапазона внешней ссылки (dedup по target). */
+ private static String hyperlinkId(SheetModel sheet, int r, int c,
+ LinkedHashSet hyperlinks) {
+ for (var e : sheet.externalLinks().entrySet()) {
+ int[] range = SheetModel.parseRange(e.getKey());
+ if (range.length < 4 || r < range[0] || r > range[2] || c < range[1] || c > range[3]) {
+ continue;
+ }
+ hyperlinks.add(e.getValue());
+ return "hl" + indexOf(hyperlinks, e.getValue());
+ }
+ return null;
+ }
+
+ private static int indexOf(LinkedHashSet set, String value) {
+ int i = 0;
+ for (String v : set) {
+ if (v.equals(value)) {
+ return i;
+ }
+ i++;
+ }
+ return -1;
+ }
+
+ /** Абзац ячейки: pPr (spacing/jc) + раны (rich или один по стилю ячейки). */
+ private static void emitParagraph(StringBuilder xml, SheetModel.CellData cell, int styleIdx,
+ String linkId, StylesModel styles, SharedStrings sst, WarnOnce warn) {
+ StylesModel.CellXf xf = styles.xf(styleIdx);
+ xml.append("")
+ .append("");
+ appendJc(xml, xf.horizontal());
+ xml.append("");
+ if (linkId != null) {
+ xml.append("");
+ }
+ List runs = cellRuns(cell, sst, warn);
+ if (runs.isEmpty()) {
+ String text = plainText(cell);
+ if (!text.isEmpty() || linkId != null) {
+ emitRun(xml, text, null, xf, styles);
+ }
+ } else {
+ for (SharedStrings.Run run : runs) {
+ emitRun(xml, run.text(), run.style(), xf, styles);
+ }
+ }
+ if (linkId != null) {
+ xml.append("");
+ }
+ xml.append("");
+ }
+
+ /** Excel-горизонталь → Word jc (§18.8.1 + деградации distributed/distribute). */
+ private static void appendJc(StringBuilder xml, String horizontal) {
+ String jc = switch (horizontal == null ? "" : horizontal) {
+ case "center", "centerContinuous" -> "center";
+ case "right" -> "right";
+ case "fill", "justify" -> "both";
+ case "distributed" -> "distribute";
+ default -> null;
+ };
+ if (jc != null) {
+ xml.append("");
+ }
+ }
+
+ private static List cellRuns(SheetModel.CellData cell,
+ SharedStrings sst, WarnOnce warn) {
+ if (cell == null) {
+ return List.of();
+ }
+ String type = cell.type();
+ switch (type == null ? "" : type) {
+ case "inlineStr":
+ return cell.runs() == null ? List.of() : cell.runs();
+ case "s": {
+ Integer idx = cell.raw() == null ? null : ColorSpec.parseInt(cell.raw().trim());
+ return idx == null ? List.of() : sst.at(idx, warn);
+ }
+ default:
+ return List.of();
+ }
+ }
+
+ /** Текст не-rich ячейки (numFmt-движок подключается шагом 5). */
+ private static String plainText(SheetModel.CellData cell) {
+ if (cell == null || cell.raw() == null) {
+ return "";
+ }
+ return NumberText.of(cell.raw(), cell.type());
+ }
+
+ /**
+ * Один {@code w:r}: rFonts/sz из шрифта ячейки (переопределения rich-рана
+ * приоритетны); цвет/зачёрк/индекс — каркас шага 5.
+ */
+ private static void emitRun(StringBuilder xml, String text, SharedStrings.RunStyle style,
+ StylesModel.CellXf xf, StylesModel styles) {
+ StylesModel.FontDef base = styles.font(xf.fontId());
+ String family = style != null && style.fontName() != null ? style.fontName()
+ : base == null || base.name() == null ? "Calibri" : base.name();
+ boolean bold = (base != null && Boolean.TRUE.equals(base.bold()))
+ || style != null && Boolean.TRUE.equals(style.bold());
+ boolean italic = (base != null && Boolean.TRUE.equals(base.italic()))
+ || style != null && Boolean.TRUE.equals(style.italic());
+ boolean strikeout = (base != null && Boolean.TRUE.equals(base.strikeout()))
+ || style != null && Boolean.TRUE.equals(style.strikeout());
+ boolean underline = style != null && style.underline() != null
+ || base != null && base.underline() != null;
+ double size = style != null && style.sizePt() != null ? style.sizePt()
+ : base == null || base.sizePt() == null ? DEFAULT_SIZE_PT : base.sizePt();
+ xml.append("");
+ appendRFonts(xml, family);
+ int half = (int) Math.ceil(size * 2);
+ xml.append("")
+ .append("");
+ if (bold) {
+ xml.append("");
+ }
+ if (italic) {
+ xml.append("");
+ }
+ if (underline) {
+ xml.append("");
+ }
+ if (strikeout) {
+ xml.append("");
+ }
+ xml.append("").append(escapeXml(text)).append("");
+ }
+
+ /** rFonts ascii/hAnsi/cs (Word определяет латиницу/кириллицу по hAnsi). */
+ private static void appendRFonts(StringBuilder xml, String family) {
+ String esc = escapeXml(family);
+ xml.append("");
+ }
+
+ private static String escapeXml(String s) {
+ StringBuilder out = new StringBuilder(s.length() + 8);
+ for (int i = 0; i < s.length(); i++) {
+ char ch = s.charAt(i);
+ switch (ch) {
+ case '&' -> out.append("&");
+ case '<' -> out.append("<");
+ case '>' -> out.append(">");
+ case '"' -> out.append(""");
+ default -> {
+ // управляющие XML 1.0 не допускает — вырезаем
+ if (ch >= 0x20 || ch == '\t' || ch == '\n' || ch == '\r') {
+ out.append(ch);
+ }
+ }
+ }
+ }
+ return out.toString();
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java
new file mode 100644
index 0000000..2f70210
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java
@@ -0,0 +1,506 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * {@code xl/styles.xml} (ECMA-376 §18.8): таблицы {@code numFmts},
+ * {@code fonts}, {@code fills}, {@code borders}, {@code cellStyleXfs} +
+ * {@code cellXfs}. Для каждого индекса {@code c/@s} заранее вычисляется
+ * эффективный формат {@link CellXf}: старт от базы {@code cellStyleXfs[xfId]}
+ * (base-first), поля cellXfs перекрывают базу по правилам apply*-флагов
+ * Excel: {@code applyX="1"} — берём значение cellXfs (даже отсутствующий
+ * атрибут = дефолт 0), {@code applyX="0"} — всегда база, флага нет —
+ * значение cellXfs, если атрибут задан явно, иначе база.
+ *
+ * {@code dxfs} (§18.8.15) не парсятся: conditional formatting вне v1.
+ */
+final class StylesModel {
+
+ /** Шрифт {@code fonts/font} (§18.8.23 CT_Font). */
+ record FontDef(String name, String scheme, Double sizePt, Boolean bold, Boolean italic,
+ String underline, Boolean strikeout, ColorSpec color) {
+ }
+
+ /** Заливка {@code fills/fill} (§18.8.32 CT_PatternFill). */
+ record FillDef(String patternType, ColorSpec fgColor) {
+ }
+
+ /** Одна сторона границы (§18.8.5 CT_Border). */
+ record BorderSide(String style, ColorSpec color) {
+ }
+
+ /** Граница {@code borders/border}; диагонали не эмитятся (Word-ячейка). */
+ record BorderDef(BorderSide left, BorderSide right, BorderSide top, BorderSide bottom) {
+ }
+
+ /** Эффективный формат ячейки (cellXfs[с], разрешённый через базу). */
+ record CellXf(int numFmtId, int fontId, int fillId, int borderId,
+ String horizontal, String vertical, boolean wrapText, int indent) {
+ }
+
+ private static final Logger LOG = LoggerFactory.getLogger(StylesModel.class);
+ private static final String STYLES_PART = "xl/styles.xml";
+ /** Дефолт CT_Font/@sz. */
+ private static final double DEFAULT_SIZE_PT = 11.0;
+
+ private final List fonts;
+ private final List fills;
+ private final List borders;
+ private final List xfs;
+ /** {@code colors/indexedColors/rgbColor}: индекс 64+n. */
+ private final List indexedColors;
+
+ private StylesModel(List fonts, List fills, List borders,
+ List xfs, List indexedColors) {
+ this.fonts = fonts;
+ this.fills = fills;
+ this.borders = borders;
+ this.xfs = xfs;
+ this.indexedColors = indexedColors;
+ }
+
+ FontDef font(int index) {
+ return index >= 0 && index < fonts.size() ? fonts.get(index) : null;
+ }
+
+ FillDef fill(int index) {
+ return index >= 0 && index < fills.size() ? fills.get(index) : null;
+ }
+
+ BorderDef border(int index) {
+ return index >= 0 && index < borders.size() ? borders.get(index) : null;
+ }
+
+ CellXf xf(int index) {
+ return index >= 0 && index < xfs.size() ? xfs.get(index) : xfs.get(0);
+ }
+
+ int xfCount() {
+ return xfs.size();
+ }
+
+ /** Палитра {@code indexedColors} (может быть короче/пустой). */
+ List indexedColors() {
+ return indexedColors;
+ }
+
+ /**
+ * Семейство шрифта Normal-стиля (индекс 0 cellStyles) — для MDW в
+ * {@link Metrics}; имя (или scheme=minor при отсутствии имени).
+ */
+ String normalFontName() {
+ CellXf base = xfs.isEmpty() ? new CellXf(0, 0, 0, 0, null, null, false, 0) : xfs.get(0);
+ FontDef f = font(base.fontId());
+ if (f == null || f.name() == null) {
+ return "Calibri";
+ }
+ return f.name();
+ }
+
+ static StylesModel read(XlsxPackage pkg, WarnOnce warn) throws IOException {
+ byte[] data = pkg.entry(STYLES_PART);
+ if (data == null) {
+ warn.warn(LOG, "В .xlsx нет xl/styles.xml — все ячейки дефолтным форматом");
+ return new StylesModel(List.of(defaultFont()), List.of(noFill(), gray125()),
+ List.of(noBorder()), List.of(new CellXf(0, 0, 0, 0, null, null, false, 0)),
+ List.of());
+ }
+ Parser p = new Parser();
+ try {
+ XMLStreamReader xr = XlsxPackage.newSecureReader()
+ .createXMLStreamReader(new ByteArrayInputStream(data));
+ p.parse(xr);
+ xr.close();
+ } catch (XMLStreamException e) {
+ throw new IOException("Не удалось разобрать xl/styles.xml", e);
+ }
+ return p.build();
+ }
+
+ // ================== разбор ==================
+
+ /** Промежуточное xf-сырьё (до разрешения базы). */
+ private record RawXf(Integer numFmtId, Integer fontId, Integer fillId, Integer borderId,
+ Integer xfId, Boolean applyNumFmt, Boolean applyFont, Boolean applyFill,
+ Boolean applyBorder, Boolean applyAlignment,
+ String horizontal, String vertical, Boolean wrap, Integer indent) {
+
+ /** Эффективный xf по правилу apply*-флагов (base-first). */
+ CellXf resolve(RawXf base) {
+ int nf = pickNum(numFmtId, applyNumFmt, base == null ? null : base.numFmtId);
+ int fn = pickNum(fontId, applyFont, base == null ? null : base.fontId);
+ int fl = pickNum(fillId, applyFill, base == null ? null : base.fillId);
+ int bd = pickNum(borderId, applyBorder, base == null ? null : base.borderId);
+ String hz;
+ String vt;
+ boolean wr;
+ int ind;
+ if (Boolean.FALSE.equals(applyAlignment) && base != null) {
+ hz = base.horizontal;
+ vt = base.vertical;
+ wr = Boolean.TRUE.equals(base.wrap);
+ ind = base.indent == null ? 0 : base.indent;
+ } else {
+ hz = horizontal != null || base == null || Boolean.TRUE.equals(applyAlignment)
+ ? horizontal : base.horizontal;
+ vt = vertical != null || base == null || Boolean.TRUE.equals(applyAlignment)
+ ? vertical : base.vertical;
+ wr = wrap != null || base == null || Boolean.TRUE.equals(applyAlignment)
+ ? Boolean.TRUE.equals(wrap) : Boolean.TRUE.equals(base.wrap);
+ ind = indent != null || base == null || Boolean.TRUE.equals(applyAlignment)
+ ? (indent == null ? 0 : indent) : base.indent == null ? 0 : base.indent;
+ }
+ return new CellXf(nf, fn, fl, bd, hz, vt, wr, ind);
+ }
+
+ private static int pickNum(Integer own, Boolean apply, Integer base) {
+ if (Boolean.TRUE.equals(apply)) {
+ return own == null ? 0 : own;
+ }
+ if (Boolean.FALSE.equals(apply)) {
+ return base == null ? 0 : base;
+ }
+ if (own != null) {
+ return own;
+ }
+ return base == null ? 0 : base;
+ }
+ }
+
+ /** Контейнер разбора одной части styles.xml. */
+ private static final class Parser {
+ private final List fonts = new ArrayList<>();
+ private final List fills = new ArrayList<>();
+ private final List borders = new ArrayList<>();
+ private final List styleXfs = new ArrayList<>();
+ private final List cellXfs = new ArrayList<>();
+ private final List indexedColors = new ArrayList<>();
+ /** Текущая таблица для дочерних элементов. */
+ private String table;
+
+ void parse(XMLStreamReader xr) throws XMLStreamException {
+ boolean rootOpen = false;
+ while (!rootOpen && xr.hasNext()) {
+ // до START корня styleSheet — дальше диспатчим только детей
+ // (иначе default-skip проглотит весь документ)
+ rootOpen = xr.next() == XMLStreamConstants.START_ELEMENT;
+ }
+ while (xr.hasNext()) {
+ if (xr.next() != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ table = xr.getLocalName();
+ switch (table) {
+ case "fonts" -> parseFonts(xr);
+ case "fills" -> parseFills(xr);
+ case "borders" -> parseBorders(xr);
+ case "cellStyleXfs" -> styleXfs.addAll(parseXfs(xr));
+ case "cellXfs" -> cellXfs.addAll(parseXfs(xr));
+ case "colors" -> parseColors(xr);
+ default -> SharedStrings.skipElement(xr);
+ }
+ }
+ }
+
+ StylesModel build() {
+ if (fonts.isEmpty()) {
+ fonts.add(defaultFont());
+ }
+ // ECMA §18.8.21: fills[0] — none, fills[1] — легаси gray125
+ // (генераторы иногда пишут только первую).
+ while (fills.size() < 2) {
+ fills.add(fills.isEmpty() ? noFill() : gray125());
+ }
+ if (borders.isEmpty()) {
+ borders.add(noBorder());
+ }
+ List xfs = new ArrayList<>(cellXfs.size());
+ for (RawXf xf : cellXfs) {
+ RawXf base = xf.xfId() == null || xf.xfId() < 0 || xf.xfId() >= styleXfs.size()
+ ? null : styleXfs.get(xf.xfId());
+ xfs.add(xf.resolve(base));
+ }
+ if (xfs.isEmpty()) {
+ xfs.add(new CellXf(0, 0, 0, 0, null, null, false, 0));
+ }
+ return new StylesModel(List.copyOf(fonts), List.copyOf(fills),
+ List.copyOf(borders), List.copyOf(xfs), List.copyOf(indexedColors));
+ }
+
+ private void parseFonts(XMLStreamReader xr) throws XMLStreamException {
+ while (nextTableItem(xr, "font")) {
+ fonts.add(readFont(xr));
+ }
+ }
+
+ private FontDef readFont(XMLStreamReader xr) throws XMLStreamException {
+ String name = null;
+ String scheme = null;
+ Double size = null;
+ Boolean bold = null;
+ Boolean italic = null;
+ String underline = null;
+ Boolean strikeout = null;
+ ColorSpec color = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "name" -> name = XlsxPackage.attr(xr, "val");
+ case "scheme" -> scheme = XlsxPackage.attr(xr, "val");
+ case "sz" -> size = ColorSpec.parseDouble(XlsxPackage.attr(xr, "val"));
+ case "b" -> bold = SharedStrings.boolVal(xr);
+ case "i" -> italic = SharedStrings.boolVal(xr);
+ case "strike" -> strikeout = SharedStrings.boolVal(xr);
+ case "u" -> {
+ String v = XlsxPackage.attr(xr, "val");
+ underline = v == null || "none".equals(v) ? null : v;
+ }
+ case "color" -> color = ColorSpec.fromColorElement(xr);
+ default -> {
+ }
+ }
+ // листок font (name/sz/b/…) доедает свой END, иначе он
+ // досрочно прервёт разбор шрифта
+ SharedStrings.skipElement(xr);
+ }
+ return new FontDef(name, scheme, size, bold, italic, underline, strikeout, color);
+ }
+
+ private void parseFills(XMLStreamReader xr) throws XMLStreamException {
+ while (nextTableItem(xr, "fill")) {
+ fills.add(readFill(xr));
+ }
+ }
+
+ private FillDef readFill(XMLStreamReader xr) throws XMLStreamException {
+ String pattern = "none";
+ ColorSpec fg = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT
+ && "patternFill".equals(xr.getLocalName())) {
+ String pt = XlsxPackage.attr(xr, "patternType");
+ pattern = pt == null ? "none" : pt;
+ fg = readPatternColors(xr);
+ } else if (ev == XMLStreamConstants.START_ELEMENT) {
+ SharedStrings.skipElement(xr);
+ }
+ }
+ return new FillDef(pattern, fg);
+ }
+
+ /** fgColor patternFill (solid — это ОН же цвет заливки); bgColor пропускается. */
+ private ColorSpec readPatternColors(XMLStreamReader xr) throws XMLStreamException {
+ ColorSpec fg = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "fgColor" -> {
+ fg = ColorSpec.fromColorElement(xr);
+ SharedStrings.skipElement(xr);
+ }
+ default -> SharedStrings.skipElement(xr);
+ }
+ }
+ return fg;
+ }
+
+ private void parseBorders(XMLStreamReader xr) throws XMLStreamException {
+ while (nextTableItem(xr, "border")) {
+ borders.add(readBorder(xr));
+ }
+ }
+
+ private BorderDef readBorder(XMLStreamReader xr) throws XMLStreamException {
+ BorderSide left = null;
+ BorderSide right = null;
+ BorderSide top = null;
+ BorderSide bottom = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ String side = xr.getLocalName();
+ if ("left".equals(side) || "right".equals(side)
+ || "top".equals(side) || "bottom".equals(side)) {
+ String style = XlsxPackage.attr(xr, "style");
+ ColorSpec color = readSideColor(xr);
+ BorderSide s = new BorderSide(style, color);
+ switch (side) {
+ case "left" -> left = s;
+ case "right" -> right = s;
+ case "top" -> top = s;
+ default -> bottom = s;
+ }
+ } else {
+ SharedStrings.skipElement(xr);
+ }
+ }
+ return new BorderDef(left, right, top, bottom);
+ }
+
+ /** Дочерний color стороны (сторона без children — просто END). */
+ private ColorSpec readSideColor(XMLStreamReader xr) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT && "color".equals(xr.getLocalName())) {
+ ColorSpec c = ColorSpec.fromColorElement(xr);
+ SharedStrings.skipElement(xr);
+ return c;
+ }
+ }
+ return null;
+ }
+
+ private List parseXfs(XMLStreamReader xr) throws XMLStreamException {
+ List xfs = new ArrayList<>();
+ while (nextTableItem(xr, "xf")) {
+ xfs.add(readXf(xr));
+ }
+ return xfs;
+ }
+
+ private RawXf readXf(XMLStreamReader xr) throws XMLStreamException {
+ Integer numFmtId = ColorSpec.parseInt(XlsxPackage.attr(xr, "numFmtId"));
+ Integer fontId = ColorSpec.parseInt(XlsxPackage.attr(xr, "fontId"));
+ Integer fillId = ColorSpec.parseInt(XlsxPackage.attr(xr, "fillId"));
+ Integer borderId = ColorSpec.parseInt(XlsxPackage.attr(xr, "borderId"));
+ Integer xfId = ColorSpec.parseInt(XlsxPackage.attr(xr, "xfId"));
+ Boolean applyNumFmt = flag(XlsxPackage.attr(xr, "applyNumFmt"));
+ Boolean applyFont = flag(XlsxPackage.attr(xr, "applyFont"));
+ Boolean applyFill = flag(XlsxPackage.attr(xr, "applyFill"));
+ Boolean applyBorder = flag(XlsxPackage.attr(xr, "applyBorder"));
+ Boolean applyAlignment = flag(XlsxPackage.attr(xr, "applyAlignment"));
+ String hz = null;
+ String vt = null;
+ Boolean wrap = null;
+ Integer indent = null;
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "alignment" -> {
+ hz = XlsxPackage.attr(xr, "horizontal");
+ vt = XlsxPackage.attr(xr, "vertical");
+ String w = XlsxPackage.attr(xr, "wrapText");
+ wrap = w == null ? null : XlsxPackage.truthy(w);
+ indent = ColorSpec.parseInt(XlsxPackage.attr(xr, "indent"));
+ SharedStrings.skipElement(xr);
+ }
+ default -> SharedStrings.skipElement(xr); // protection/неизвестное
+ }
+ }
+ return new RawXf(numFmtId, fontId, fillId, borderId, xfId, applyNumFmt,
+ applyFont, applyFill, applyBorder, applyAlignment, hz, vt, wrap, indent);
+ }
+
+ private void parseColors(XMLStreamReader xr) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (ev != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "indexedColors":
+ while (xr.hasNext()) {
+ int e2 = xr.next();
+ if (e2 == XMLStreamConstants.END_ELEMENT) {
+ break;
+ }
+ if (e2 != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ switch (xr.getLocalName()) {
+ case "rgbColor" -> {
+ String rgb = XlsxPackage.attr(xr, "rgb");
+ indexedColors.add(rgb == null ? "000000" : rgb);
+ }
+ default -> {
+ }
+ }
+ SharedStrings.skipElement(xr);
+ }
+ break;
+ default:
+ SharedStrings.skipElement(xr);
+ }
+ }
+ }
+
+ /** Следующий START дочернего элемента {@code item} таблицы; END таблицы — false. */
+ private boolean nextTableItem(XMLStreamReader xr, String item) throws XMLStreamException {
+ while (xr.hasNext()) {
+ int ev = xr.next();
+ if (ev == XMLStreamConstants.END_ELEMENT) {
+ return false;
+ }
+ if (ev == XMLStreamConstants.START_ELEMENT && item.equals(xr.getLocalName())) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static Boolean flag(String v) {
+ if (v == null) {
+ return null;
+ }
+ return XlsxPackage.truthy(v);
+ }
+ }
+
+ private static FontDef defaultFont() {
+ return new FontDef("Calibri", "minor", DEFAULT_SIZE_PT, null, null, null, null, null);
+ }
+
+ private static FillDef noFill() {
+ return new FillDef("none", null);
+ }
+
+ private static FillDef gray125() {
+ return new FillDef("gray125", null);
+ }
+
+ private static BorderDef noBorder() {
+ return new BorderDef(null, null, null, null);
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java
new file mode 100644
index 0000000..506fa16
Binary files /dev/null and b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java differ
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java
new file mode 100644
index 0000000..a99762d
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java
@@ -0,0 +1,118 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import javax.xml.stream.XMLStreamConstants;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * {@code xl/workbook.xml} (ECMA-376 §18.2.20): листы в tab-порядке
+ * {@code sheets/sheet} с путями частей через {@code xl/_rels/workbook.xml.rels}
+ * и флаг {@code workbookPr/@date1904} (§18.2.28 — эпoca дат 1904-01-01).
+ * Лист без связи на worksheet-часть (внешняя связь, chartsheet, rel на
+ * отсутствующую часть) в модель не попадает — {@link XlsxToDocx} печатает
+ * warn и пропускает лист.
+ */
+final class WorkbookModel {
+
+ /** Один лист: имя, {@code @state} ("visible" если нет) и путь части (null — не резолвится). */
+ record Sheet(String name, String state, String partPath) {
+
+ boolean visible() {
+ return state == null || "visible".equals(state);
+ }
+ }
+
+ /** Namespace атрибута r:id (ECMA-376 Part 2 §17.7.5.4). */
+ private static final String REL_NS =
+ "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+
+ /** Тип связи worksheet (ECMA-376 Part 2). */
+ private static final String WORKSHEET_REL_TYPE =
+ "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet";
+
+ private static final String WORKBOOK_PART = "xl/workbook.xml";
+ private static final String WORKBOOK_RELS_PART = "xl/_rels/workbook.xml.rels";
+
+ private static final Logger LOG = LoggerFactory.getLogger(WorkbookModel.class);
+
+ private final List sheets;
+ private final boolean date1904;
+
+ private WorkbookModel(List sheets, boolean date1904) {
+ this.sheets = sheets;
+ this.date1904 = date1904;
+ }
+
+ /** Листы в порядке {@code sheets}. */
+ List sheets() {
+ return sheets;
+ }
+
+ /** {@code workbookPr/@date1904} — система дат 1904. */
+ boolean date1904() {
+ return date1904;
+ }
+
+ static WorkbookModel read(XlsxPackage pkg) throws IOException {
+ byte[] data = pkg.entry(WORKBOOK_PART);
+ if (data == null) {
+ throw new IOException("В .xlsx нет части xl/workbook.xml");
+ }
+ // pass 1: rId → worksheet-часть (rels уже отрезолвлены от xl/)
+ Map partByRid = new HashMap<>();
+ for (XlsxPackage.Rel rel : pkg.rels(WORKBOOK_PART)) {
+ if (WORKSHEET_REL_TYPE.equals(rel.type()) && !rel.external()) {
+ partByRid.putIfAbsent(rel.id(),
+ XlsxPackage.resolvePath("xl/", rel.target()));
+ }
+ }
+ // pass 2: sheets/sheet в порядке документа
+ List sheets = new ArrayList<>();
+ boolean date1904 = false;
+ try {
+ XMLStreamReader xr = XlsxPackage.newSecureReader()
+ .createXMLStreamReader(new ByteArrayInputStream(data));
+ while (xr.hasNext()) {
+ if (xr.next() != XMLStreamConstants.START_ELEMENT) {
+ continue;
+ }
+ String name = xr.getLocalName();
+ switch (name) {
+ case "sheet" -> {
+ String sheetName = XlsxPackage.attr(xr, "name");
+ String state = XlsxPackage.attr(xr, "state");
+ String rid = XlsxPackage.attrNs(xr, REL_NS, "id");
+ String partPath = rid == null ? null : partByRid.get(rid);
+ if (partPath == null || !pkg.has(partPath)) {
+ LOG.warn("Лист '{}' (.xlsx) не имеет worksheet-части — пропущен",
+ sheetName);
+ continue;
+ }
+ sheets.add(new Sheet(sheetName == null ? "" : sheetName, state, partPath));
+ }
+ case "workbookPr" ->
+ date1904 = XlsxPackage.truthy(XlsxPackage.attr(xr, "date1904"));
+ default -> {
+ }
+ }
+ }
+ xr.close();
+ } catch (javax.xml.stream.XMLStreamException e) {
+ throw new IOException("Не удалось разобрать xl/workbook.xml", e);
+ }
+ // rels workbook обязаны существовать, но лист-то уже найден через map;
+ // отдельная проверка части rels не нужна (пустой rels ⇒ нет листов ⇒ warn выше).
+ if (pkg.entry(WORKBOOK_RELS_PART) == null && !sheets.isEmpty()) {
+ LOG.warn("В .xlsx нет xl/_rels/workbook.xml.rels — связи листов не найдены");
+ }
+ return new WorkbookModel(sheets, date1904);
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java
new file mode 100644
index 0000000..c416905
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java
@@ -0,0 +1,220 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+/**
+ * .xlsx как zip: байты записей (дубликаты враждебного архива — первая
+ * выигрывает) и разбор OPC-связей {@code /_rels/.rels} (StAX,
+ * ECMA-376 Part 2 §15). Целый архив в памяти держится сознательно: вход
+ * уже проскан валидатором (zip-бомба отсекается ДО моста,
+ * {@code WordPdfSettings#MAX_DECOMPRESSED_MB}), а per-part ленивое чтение
+ * потребовало бы либо держать байты xlsx, либо раскрывать zip вторично —
+ * при multi-sheet обходе это дороже.
+ */
+final class XlsxPackage {
+
+ /** Одна связь {@code Relationship} из .rels-части. */
+ record Rel(String id, String type, String target, boolean external) {
+ }
+
+ private final Map entries = new LinkedHashMap<>();
+ private final Map> relsByPart = new HashMap<>();
+
+ private XlsxPackage() {
+ }
+
+ /** Распаковка архива (первая запись из дубликатов). */
+ static XlsxPackage read(byte[] xlsxBytes) throws IOException {
+ XlsxPackage pkg = new XlsxPackage();
+ try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(xlsxBytes))) {
+ ZipEntry entry;
+ while ((entry = zip.getNextEntry()) != null) {
+ if (entry.isDirectory() || pkg.entries.containsKey(entry.getName())) {
+ continue;
+ }
+ pkg.entries.put(entry.getName(), zip.readAllBytes());
+ }
+ }
+ return pkg;
+ }
+
+ /** Байты части или {@code null} (части нет). */
+ byte[] entry(String path) {
+ return entries.get(path);
+ }
+
+ /** Есть ли часть. */
+ boolean has(String path) {
+ return entries.containsKey(path);
+ }
+
+ /**
+ * Связи части: {@code dir/_rels/.rels} рядом с {@code partPath}
+ * (пустой список, если rels-части нет). Парсинг ленивый, повторный вызов
+ * отдаёт кэш.
+ */
+ List rels(String partPath) {
+ List cached = relsByPart.get(partPath);
+ if (cached != null) {
+ return cached;
+ }
+ String relsPath = relsPathOf(partPath);
+ List rels = new ArrayList<>();
+ byte[] data = relsPath == null ? null : entries.get(relsPath);
+ if (data != null) {
+ try {
+ rels = parseRels(data);
+ } catch (XMLStreamException | IOException e) {
+ // Битые rels — «связей нет»: лист без rels пустой (+warn у
+ // вызывающего), падать из-за них на весь документ незачем.
+ rels = List.of();
+ }
+ }
+ relsByPart.put(partPath, rels);
+ return rels;
+ }
+
+ /** First rel заданного типа с id (внешние тоже) или null. */
+ Rel relByTargetId(String partPath, String relId) {
+ for (Rel rel : rels(partPath)) {
+ if (rel.id().equals(relId)) {
+ return rel;
+ }
+ }
+ return null;
+ }
+
+ /** Часть-цель связи (resolved от каталога part-источника) или null. */
+ String relTargetPath(String partPath, String relId) {
+ Rel rel = relByTargetId(partPath, relId);
+ if (rel == null || rel.external()) {
+ return null;
+ }
+ return resolvePath(parentDir(partPath), rel.target());
+ }
+
+ /** {@code word/document.xml} → {@code word/_rels/document.xml.rels}. */
+ static String relsPathOf(String partPath) {
+ int slash = partPath.lastIndexOf('/');
+ String dir = slash < 0 ? "" : partPath.substring(0, slash + 1);
+ String file = slash < 0 ? partPath : partPath.substring(slash + 1);
+ return dir + "_rels/" + file + ".rels";
+ }
+
+ /** Каталог части с завершающим слэшем ("" для корневых). */
+ static String parentDir(String partPath) {
+ int slash = partPath.lastIndexOf('/');
+ return slash < 0 ? "" : partPath.substring(0, slash + 1);
+ }
+
+ /**
+ * Target связи в путь zip-записи: абсолютный ("/xl/…") — от корня
+ * пакета; относительный разрешается от каталога {@code fromDir}
+ * («.», «..», обратный слэш).
+ */
+ static String resolvePath(String fromDir, String target) {
+ String t = target.replace('\\', '/');
+ int query = t.indexOf('?');
+ if (query >= 0) {
+ t = t.substring(0, query);
+ }
+ if (t.startsWith("/")) {
+ return t.substring(1);
+ }
+ Deque segs = new ArrayDeque<>();
+ for (String dir : fromDir.split("/")) {
+ if (!dir.isEmpty()) {
+ segs.push(dir);
+ }
+ }
+ for (String seg : t.split("/")) {
+ if (seg.isEmpty() || CUR.equals(seg)) {
+ continue;
+ }
+ if (UP.equals(seg)) {
+ if (!segs.isEmpty()) {
+ segs.pop();
+ }
+ } else {
+ segs.push(seg);
+ }
+ }
+ StringBuilder path = new StringBuilder();
+ for (var it = segs.descendingIterator(); it.hasNext(); ) {
+ if (path.length() > 0) {
+ path.append('/');
+ }
+ path.append(it.next());
+ }
+ return path.toString();
+ }
+
+ /** Сегменты относительных путей. */
+ private static final String CUR = ".";
+ private static final String UP = "..";
+
+ private static List parseRels(byte[] data) throws IOException, XMLStreamException {
+ List rels = new ArrayList<>();
+ Map seenIds = new HashMap<>();
+ XMLStreamReader xr = newSecureReader().createXMLStreamReader(new ByteArrayInputStream(data));
+ while (xr.hasNext()) {
+ if (xr.next() == XMLStreamReader.START_ELEMENT
+ && "Relationship".equals(xr.getLocalName())) {
+ String id = attr(xr, "Id");
+ String type = attr(xr, "Type");
+ String target = attr(xr, "Target");
+ boolean external = "External".equals(attr(xr, "TargetMode"));
+ if (id != null && type != null && target != null && seenIds.put(id, true) == null) {
+ rels.add(new Rel(id, type, target, external));
+ }
+ }
+ }
+ xr.close();
+ return rels;
+ }
+
+ /** Значение атрибута по локальному имени (без привязки к namespace). */
+ static String attr(XMLStreamReader xr, String name) {
+ for (int i = 0; i < xr.getAttributeCount(); i++) {
+ if (xr.getAttributeName(i).getLocalPart().equals(name)) {
+ return xr.getAttributeValue(i);
+ }
+ }
+ return null;
+ }
+
+ /** Значение namespace-атрибута (например r:id). */
+ static String attrNs(XMLStreamReader xr, String ns, String name) {
+ return xr.getAttributeValue(ns, name);
+ }
+
+ /**
+ * XML-boolean атрибут ECMA-376 (§18.18.62): отсутствует или {@code 0}/
+ * {@code false}/{@code off} — ложь; {@code 1}/{@code true}/{@code on}/
+ * пустое значение (атрибут выставлен) — истина.
+ */
+ static boolean truthy(String value) {
+ return value != null && !"0".equals(value) && !"false".equalsIgnoreCase(value)
+ && !"off".equalsIgnoreCase(value);
+ }
+
+ static XMLInputFactory newSecureReader() {
+ XMLInputFactory f = XMLInputFactory.newInstance();
+ f.setProperty(XMLInputFactory.SUPPORT_DTD, false);
+ f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false);
+ return f;
+ }
+}
diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java
new file mode 100644
index 0000000..6db48af
--- /dev/null
+++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java
@@ -0,0 +1,91 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import ru.pjandro.wordpdf.ConvertOptions;
+import ru.pjandro.wordpdf.ConversionException;
+import ru.pjandro.wordpdf.DrawingFoundException;
+import ru.pjandro.wordpdf.ValidationException;
+import ru.pjandro.wordpdf.internal.DocxPackageWriter;
+
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.List;
+
+/**
+ * Мост .xlsx → in-memory .docx: лист Excel превращается в Word-таблицу
+ * фиксированной сетки, дальше — штатный пайплайн {@code WordPdfConverter}
+ * (шаги 1–7: шрифты, {@code DrawingPreRenderer}, вендорный XSLT, FOP).
+ * Нормативная база — ECMA-376 Part 1 §18 SpreadsheetML (ссылки § — в
+ * javadoc'ах классов пакета); печатная семантика (срезы/разрывы/fitToPage)
+ * — как печать Excel.
+ *
+ * Тот же архитектурный приём, что мост {@code internal.doc}: разбор →
+ * модель → генерация docx-байтов; наружу из пакета — только {@link #convert}.
+ * Сгенерированный docx — собственный артефакт, штатной валидацией входа не
+ * проверяется (вход проверен {@code WordPdfValidator} по байтам .xlsx).
+ */
+public final class XlsxToDocx {
+
+ private XlsxToDocx() {
+ }
+
+ /**
+ * Байты .xlsx → байты .docx того же документа (все видимые листы по
+ * tab-порядку; между листами — разрыв секции, шаг 6).
+ *
+ * @param options error-флаги рисунков (chart/OLE) и лимиты на этот вызов
+ * @throws DrawingFoundException {@code options.errorOnCharts()}/{@code errorOnOle()}
+ * и объект найден — уходит вызывающему как есть (REST мапит в 422)
+ * @throws ValidationException любой внешний отказ разбора — контрактный
+ * текст «Не удалось разобрать байты .xlsx»
+ */
+ public static byte[] convert(byte[] xlsxBytes, ConvertOptions options)
+ throws ConversionException {
+ try {
+ return convertInternal(xlsxBytes, options);
+ } catch (ConversionException e) {
+ // DrawingFoundException (и иной Contract-исключение моста) — как есть
+ throw e;
+ } catch (Exception e) {
+ throw new ValidationException("Не удалось разобрать байты .xlsx", e);
+ }
+ }
+
+ private static byte[] convertInternal(byte[] xlsxBytes, ConvertOptions options)
+ throws Exception {
+ WarnOnce warn = new WarnOnce();
+ XlsxPackage pkg = XlsxPackage.read(xlsxBytes);
+ WorkbookModel wb = WorkbookModel.read(pkg);
+ StylesModel styles = StylesModel.read(pkg, warn);
+ SharedStrings sst = SharedStrings.read(pkg, warn);
+ Metrics metrics = Metrics.forNormalFamily(styles.normalFontName());
+
+ StringBuilder body = new StringBuilder();
+ List parts = new ArrayList<>();
+ LinkedHashSet hyperlinks = new LinkedHashSet<>();
+ int emitted = 0;
+ for (WorkbookModel.Sheet sheet : wb.sheets()) {
+ if (!sheet.visible()) {
+ continue;
+ }
+ SheetModel model = SheetModel.read(pkg, sheet, warn);
+ if (model.olePresent() && options.errorOnOle()) {
+ // OLE в xlsx: объект не эмитится никогда; флаг — отказ (шаг 7
+ // уточняет находку по embeddings; structural-признаки — здесь)
+ throw new DrawingFoundException(DrawingFoundException.Kind.OLE);
+ }
+ String tableXml = SheetToTable.emit(model, styles, sst, wb, metrics,
+ parts, hyperlinks, warn);
+ if (tableXml.isEmpty()) {
+ // пустой лист — только страница (секция появится шагом 6)
+ continue;
+ }
+ if (emitted++ > 0) {
+ body.append("");
+ }
+ body.append(tableXml);
+ }
+ // финальный абзац body (Word-контент-блок после последней таблицы)
+ body.append("");
+ return DocxPackageWriter.write(body.toString(), parts, new ArrayList<>(hyperlinks));
+ }
+}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java
new file mode 100644
index 0000000..5144d8b
--- /dev/null
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java
@@ -0,0 +1,60 @@
+package ru.pjandro.wordpdf;
+
+import org.apache.pdfbox.Loader;
+import org.apache.pdfbox.pdmodel.PDDocument;
+import org.apache.pdfbox.text.PDFTextStripper;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Сквозная конвертация .xlsx (роутинг моста {@code internal.xlsx} внутри
+ * {@link WordPdfConverter}) до PDF: текст доезжает, глифов «#» нет, шрифт
+ * не Helvetica. Остальные аспекты (срезы, numFmt, рисунки) — тесты шагов 5–7.
+ */
+class XlsxPdfConverterTest {
+
+ private static byte[] sample(String name) throws IOException {
+ try (InputStream in = XlsxPdfConverterTest.class.getClassLoader()
+ .getResourceAsStream("samples/" + name)) {
+ assertNotNull(in, "Нет фикстуры: samples/" + name);
+ return in.readAllBytes();
+ }
+ }
+
+ private static Path convertPdf(byte[] xlsx) throws IOException {
+ Path out = Files.createTempFile("xlsx-", ".pdf");
+ Files.write(out, WordPdfConverter.convert(xlsx, "xlsx"));
+ return out;
+ }
+
+ private static String norm(String s) {
+ return s.replaceAll("\\s+", " ");
+ }
+
+ @Test
+ void basic_ruTextReachesPdf_noHashNoHelvetica() throws IOException {
+ Path pdf = convertPdf(sample("xlsx-basic.xlsx"));
+ String text;
+ try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
+ assertTrue(doc.getNumberOfPages() >= 1);
+ text = norm(new PDFTextStripper().getText(doc));
+ }
+ assertFalse(text.contains("#"), "в PDF есть «#» (не покрыт глиф): " + text);
+ assertFalse(text.contains("Helvetica"), "FOP ушёл в Helvetica");
+ assertTrue(text.contains("Отчёт"), "нет заголовка листа");
+ // узкие колонки v1 рвут слова переносом — сравнение без пробелов
+ String flat = text.replaceAll("\\s+", "");
+ assertTrue(flat.contains("Молоко"), "нет данных");
+ assertTrue(text.contains("1234.5"), "нет числа");
+ assertTrue(flat.contains("ЖИРНЫЙ"), "rich-строка потеряна");
+ assertTrue(flat.contains("объединённойячейки"), "merge-текст потерян");
+ }
+}
diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java
new file mode 100644
index 0000000..437b286
--- /dev/null
+++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java
@@ -0,0 +1,103 @@
+package ru.pjandro.wordpdf.internal.xlsx;
+
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipInputStream;
+
+import ru.pjandro.wordpdf.ConvertOptions;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Структура docx-конвертата моста .xlsx (samples/xlsx-basic.xlsx): сетка без
+ * скрытых колонок/строк, merge'ы, внешняя гиперссылка, rich-раны SST.
+ * PDF-уровень — XlsxPdfConverterTest; стили/numFmt — шаг 5.
+ */
+class XlsxToDocxTest {
+
+ private static final String DOCUMENT_ENTRY = "word/document.xml";
+
+ private static byte[] sample(String name) throws IOException {
+ try (InputStream in = XlsxToDocxTest.class.getClassLoader()
+ .getResourceAsStream("samples/" + name)) {
+ assertNotNull(in, "Нет фикстуры: samples/" + name);
+ return in.readAllBytes();
+ }
+ }
+
+ private static String documentXml(String fixture) throws IOException {
+ byte[] docx = XlsxToDocx.convert(sample(fixture), ConvertOptions.defaults());
+ try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(docx))) {
+ ZipEntry entry;
+ while ((entry = zip.getNextEntry()) != null) {
+ if (DOCUMENT_ENTRY.equals(entry.getName())) {
+ return new String(zip.readAllBytes(), StandardCharsets.UTF_8);
+ }
+ }
+ }
+ throw new AssertionError("в конвертате нет word/document.xml");
+ }
+
+ @Test
+ void basic_gridDropsHiddenColumnAndRow() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ // фикстура: колонка H и строка 8 скрыты — сетка 7 колонок, 7 строк
+ Matcher grid = Pattern.compile("(.*?)").matcher(xml);
+ assertTrue(grid.find(), "нет tblGrid");
+ assertTrue(grid.group(1).split("Отчёт"), "нет заголовка");
+ assertTrue(!xml.contains("скрытая"), "скрытая строка 8 эмитирована");
+ }
+
+ @Test
+ void merges_gridSpanAndVMerge() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ // B2:D2 — горизонтальный; F3:G4 — блок; C5:C6 — вертикальный
+ assertTrue(xml.contains(""), "нет gridSpan=3 (B2:D2)");
+ assertTrue(xml.contains(""), "нет gridSpan=2 (F3:G4)");
+ assertTrue(xml.contains(""), "нет vMerge restart");
+ assertTrue(Pattern.compile("").matcher(xml).find(), "нет vMerge continue");
+ assertTrue(xml.contains("объединённой ячейки"), "текст merge-ячейки потерян");
+ }
+
+ @Test
+ void externalHyperlink_emittedWithRelId() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ assertTrue(xml.contains(""), "нет w:hyperlink r:id=hl0: "
+ + xml.substring(0, Math.min(xml.length(), 600)));
+ }
+
+ @Test
+ void richSharedString_boldRunPreserved() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ int at = xml.indexOf("ЖИРНЫЙ");
+ assertTrue(at > 0, "rich-строка потеряна");
+ String run = xml.substring(xml.lastIndexOf("", at), at);
+ assertTrue(run.contains(""), "полужирный run потерян: " + run);
+ }
+
+ @Test
+ void booleanAndInlineStrings_values() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ assertTrue(xml.contains("TRUE"), "boolean TRUE потерян");
+ assertTrue(xml.contains("инлайн-строка"), "inlineStr потерян");
+ assertTrue(xml.contains("1234.5"), "дробное число потеряно");
+ }
+
+ @Test
+ void secondSheet_appendedAfterSeparator() throws IOException {
+ String xml = documentXml("xlsx-basic.xlsx");
+ assertTrue(xml.indexOf("Заметка") > 0, "лист 2 потерян");
+ int tables = xml.split("", -1).length - 1;
+ assertTrue(tables == 2, "число таблиц: " + tables);
+ }
+}