abstract-document 6.1.0 → 6.3.2

package/src/abstract-document-exporters/pdf/paginate.ts

@@ -1,7 +1,10 @@
 import * as R from "ramda";
+import { split } from "ramda";
 import * as AD from "../../abstract-document/index";
+import { Table } from "../../abstract-document/section-elements/table";
 import { getResources } from "../shared/get_resources";
 import { registerFonts } from "./font";
+import { measureTable } from "./measure";
 
 /* tslint:disable:no-any */
 
@@ -25,25 +28,23 @@ export function paginate(
   let pdf = new pdfKit({
     compress: false,
     autoFirstPage: false,
-    bufferPages: true
+    bufferPages: true,
   }) as any;
 
-  registerFonts(
-    (fontName: string, fontSource: AD.Font.FontSource) =>
-      pdf.registerFont(fontName, fontSource),
-    document
-  );
+  registerFonts((fontName: string, fontSource: AD.Font.FontSource) => pdf.registerFont(fontName, fontSource), document);
 
   let pages = new Array<Page>();
   for (let section of document.children) {
     const previousPage = pages.length > 0 ? pages[pages.length - 1] : undefined;
-    pages.push(...splitSection(resources, desiredSizes, previousPage, section));
+    pages.push(...splitSection(pdfKit, document, resources, desiredSizes, previousPage, section));
   }
 
   return pages;
 }
 
 function splitSection(
+  pdfKit: any,
+  document: AD.AbstractDoc.AbstractDoc,
   parentResources: AD.Resources.Resources,
   desiredSizes: Map<{}, AD.Size.Size>,
   previousPage: Page | undefined,
@@ -60,14 +61,7 @@ function splitSection(
   for (let i = 0; i < children.length; ++i) {
     const element = children[i];
     if (element.type === "PageBreak") {
-      currentPage = createPage(
-        resources,
-        desiredSizes,
-        currentPage,
-        section,
-        elements,
-        pages.length === 0
-      );
+      currentPage = createPage(resources, desiredSizes, currentPage, section, elements, pages.length === 0);
       pages.push(currentPage);
       elements = [];
       elementsHeight = 0;
@@ -75,13 +69,9 @@ function splitSection(
     }
     const elementSize = getDesiredSize(element, desiredSizes);
 
-    // Collapse groups the doesn't fit on empty page
+    // Collapse groups that doesn't fit on empty page
     if (elementSize.height > contentRect.height && element.type === "Group") {
-      children = [
-        ...children.slice(0, i),
-        ...element.children,
-        ...children.slice(i + 1)
-      ];
+      children = [...children.slice(0, i), ...element.children, ...children.slice(i + 1)];
       i--;
       continue;
     }
@@ -89,25 +79,53 @@ function splitSection(
     elements.push(element);
     elementsHeight += elementSize.height;
 
-    const [leadingSpace, trailingSpace] = getLeadingAndTrailingSpace(
-      resources,
-      section,
-      elements
-    );
+    const [leadingSpace, trailingSpace] = getLeadingAndTrailingSpace(resources, section, elements);
     const availableHeight = contentRect.height + leadingSpace + trailingSpace;
     if (elementsHeight > availableHeight) {
+      if (element.type === "Table" && element.children.length > 1) {
+        //Remove last element
+        elements.pop();
+        elementsHeight -= elementSize.height;
+
+        //Try to split table
+        const [tableHead, tableTail] = splitTable(
+          pdfKit,
+          document,
+          resources,
+          desiredSizes,
+          element,
+          elementsHeight,
+          availableHeight,
+          elements.length
+        );
+
+        const tableSplit: AD.Table.Table[] = [];
+        if (tableHead) {
+          elements.push(tableHead);
+          tableSplit.push(tableHead);
+        } else {
+          i--;
+        }
+        if (tableTail) {
+          tableSplit.push(tableTail);
+        }
+
+        //Add split table to children to process tableTail in next iteration
+        children = [...children.slice(0, i), ...tableSplit, ...children.slice(i + 1)];
+
+        currentPage = createPage(resources, desiredSizes, currentPage, section, elements, pages.length === 0);
+        pages.push(currentPage);
+        elements = [];
+        elementsHeight = 0;
+
+        continue;
+      }
+
       if (elements.length > 1) {
         elements.pop();
         i--;
       }
-      currentPage = createPage(
-        resources,
-        desiredSizes,
-        currentPage,
-        section,
-        elements,
-        pages.length === 0
-      );
+      currentPage = createPage(resources, desiredSizes, currentPage, section, elements, pages.length === 0);
       pages.push(currentPage);
       elements = [];
       elementsHeight = 0;
@@ -115,19 +133,62 @@ function splitSection(
   }
 
   if (elements.length > 0) {
-    pages.push(
-      createPage(
+    pages.push(createPage(resources, desiredSizes, currentPage, section, elements, pages.length === 0));
+  }
+
+  return pages;
+}
+
+function splitTable(
+  pdfKit: any,
+  document: AD.AbstractDoc.AbstractDoc,
+  resources: AD.Resources.Resources,
+  desiredSizes: Map<{}, AD.Size.Size>,
+  table: AD.Table.Table,
+  elementsHeight: number,
+  availableHeight: number,
+  elementsLength: number
+): [AD.Table.Table | undefined, AD.Table.Table | undefined] {
+  let tableHead = undefined;
+  let tableRest = undefined;
+  elementsHeight += table.style.margins.top || 0;
+
+  //Find where to split table
+  for (const [rowIndex, row] of table.children.entries()) {
+    const rowSize = getDesiredSize(row, desiredSizes);
+    elementsHeight += rowSize.height;
+
+    if (elementsHeight > availableHeight) {
+      if (rowIndex === 0 && elementsLength !== 0) {
+        //Not even first row fit on the page, shove it all to the next page
+        return [undefined, table];
+      }
+
+      const [newTableHead, newTableRest] = splitTableAt(
+        pdfKit,
+        document,
         resources,
         desiredSizes,
-        currentPage,
-        section,
-        elements,
-        pages.length === 0
-      )
-    );
+        table,
+        Math.max(rowIndex, 1)
+      );
+
+      if (newTableHead.children.length > 0) {
+        tableHead = newTableHead;
+      }
+      if (newTableRest.children.length > 0) {
+        tableRest = newTableRest;
+      }
+      break;
+    }
   }
 
-  return pages;
+  if (!tableHead && !tableRest) {
+    //Didnt find a place to split the table, meaning the whole table fits on current page
+    return [table, undefined];
+  }
+
+  return [tableHead, tableRest];
 }
 
 function createPage(
@@ -149,36 +210,22 @@ function createPage(
       top: 0,
       left: 0,
       right: 0,
-      bottom: 0
-    }
+      bottom: 0,
+    },
   };
   const pageNo = previousPage ? previousPage.pageNo + 1 : 1;
 
   const sectionName = isFirst && section.id !== "" ? [section.id] : [];
   // For now, only support link targets at base level. Tree search would be needed to find all targets.
   const targetNames = R.unnest(
-    elements.map(
-      e =>
-        e.type === "Paragraph"
-          ? e.children.map(c => (c.type === "LinkTarget" ? c.name : ""))
-          : []
-    )
-  ).filter(t => t !== "");
+    elements.map((e) => (e.type === "Paragraph" ? e.children.map((c) => (c.type === "LinkTarget" ? c.name : "")) : []))
+  ).filter((t) => t !== "");
   const namedDestionations = [...sectionName, ...targetNames];
 
   // Ignore leading space by expanding the content rect upwards
   const rect = getPageContentRect(desiredSizes, section);
-  const [leadingSpace] = getLeadingAndTrailingSpace(
-    resources,
-    section,
-    elements
-  );
-  const contentRect = AD.Rect.create(
-    rect.x,
-    rect.y - leadingSpace,
-    rect.width,
-    rect.height + leadingSpace
-  );
+  const [leadingSpace] = getLeadingAndTrailingSpace(resources, section, elements);
+  const contentRect = AD.Rect.create(rect.x, rect.y - leadingSpace, rect.width, rect.height + leadingSpace);
 
   return {
     pageNo: pageNo,
@@ -188,14 +235,11 @@ function createPage(
     contentRect: contentRect,
     elements: elements,
     header: section.page.header,
-    footer: section.page.footer
+    footer: section.page.footer,
   };
 }
 
-function getPageContentRect(
-  desiredSizes: Map<{}, AD.Size.Size>,
-  section: AD.Section.Section
-): AD.Rect.Rect {
+function getPageContentRect(desiredSizes: Map<{}, AD.Size.Size>, section: AD.Section.Section): AD.Rect.Rect {
   const style = section.page.style;
   const pageWidth = AD.PageStyle.getWidth(style);
   const pageHeight = AD.PageStyle.getHeight(style);
@@ -218,14 +262,8 @@ function getPageContentRect(
 
   const rectX = style.contentMargins.left;
   const rectY = headerY + style.contentMargins.top;
-  const rectWidth =
-    pageWidth - (style.contentMargins.left + style.contentMargins.right);
-  const rectHeight =
-    pageHeight -
-    headerHeight -
-    footerHeight -
-    style.contentMargins.top -
-    style.contentMargins.bottom;
+  const rectWidth = pageWidth - (style.contentMargins.left + style.contentMargins.right);
+  const rectHeight = pageHeight - headerHeight - footerHeight - style.contentMargins.top - style.contentMargins.bottom;
 
   return AD.Rect.create(rectX, rectY, rectWidth, rectHeight);
 }
@@ -243,8 +281,7 @@ function getLeadingAndTrailingSpace(
 
   const last = elements.length > 0 ? elements[elements.length - 1] : undefined;
   const lastMargins = last && getSectionElementMargin(resources, last);
-  const trailingSpace =
-    lastMargins && noTopBottomMargin ? lastMargins.bottom : 0;
+  const trailingSpace = lastMargins && noTopBottomMargin ? lastMargins.bottom : 0;
 
   return [leadingSpace, trailingSpace];
 }
@@ -266,7 +303,7 @@ function getSectionElementMargin(
         bottom: 0,
         left: 0,
         right: 0,
-        top: 0
+        top: 0,
       };
   }
 }
@@ -290,23 +327,20 @@ function getGroupMargins(
   group: AD.Group.Group
 ): AD.LayoutFoundation.LayoutFoundation {
   const first = group.children.length > 0 ? group.children[0] : undefined;
-  const last =
-    group.children.length > 0
-      ? group.children[group.children.length - 1]
-      : undefined;
+  const last = group.children.length > 0 ? group.children[group.children.length - 1] : undefined;
   const firstMargin = first && getSectionElementMargin(resources, first);
   const lastMargin = last && getSectionElementMargin(resources, last);
   if (firstMargin && lastMargin) {
     return {
       ...firstMargin,
-      bottom: lastMargin.bottom
+      bottom: lastMargin.bottom,
     };
   } else {
     return {
       bottom: 0,
       left: 0,
       right: 0,
-      top: 0
+      top: 0,
     };
   }
 }
@@ -325,13 +359,71 @@ function getTableMargins(
   return style.margins;
 }
 
-function getDesiredSize(
-  element: {},
-  desiredSizes: Map<{}, AD.Size.Size>
-): AD.Size.Size {
+function getDesiredSize(element: {}, desiredSizes: Map<{}, AD.Size.Size>): AD.Size.Size {
   const size = desiredSizes.get(element);
   if (size) {
     return size;
   }
   throw new Error("Could not find size for element!");
 }
+
+function splitTableAt(
+  pdfKit: any,
+  document: AD.AbstractDoc.AbstractDoc,
+  resources: AD.Resources.Resources,
+  desiredSizes: Map<{}, AD.Size.Size>,
+  table: AD.Table.Table,
+  splitIndex: number
+): [AD.Table.Table, AD.Table.Table] {
+  //Push row/cells to head table while splitting rowspan
+  const headRows: AD.TableRow.TableRow[] = [];
+  for (const [rowIndex, row] of table.children.slice(0, splitIndex).entries()) {
+    const newRow: AD.TableCell.TableCell[] = [];
+    for (const cell of row.children) {
+      //If this cell would span over the split index
+      if (rowIndex + (cell.rowSpan || 1) - 1 >= splitIndex) {
+        newRow.push({ ...cell, rowSpan: splitIndex - rowIndex });
+      } else {
+        newRow.push(cell);
+      }
+    }
+    headRows.push({ ...row, children: newRow });
+  }
+
+  //Set dummy to false for all cells in the splitRow
+  //This causes them to be rendered like an empty cell
+  //while keeping the remaining rowspan which was calculated
+  //in the pre-process step
+  const splitRow = table.children[splitIndex];
+  const firstTailRow: AD.TableCell.TableCell[] = [];
+  for (const cell of splitRow.children) {
+    firstTailRow.push({ ...cell, dummy: false });
+  }
+
+  // Push the rest of the rows to tail table
+  const tailRows: AD.TableRow.TableRow[] = [{ ...splitRow, children: firstTailRow }];
+  tailRows.push(...table.children.slice(splitIndex + 1));
+
+  //Create tables and remeasure them
+  const tableHead = {
+    ...table,
+    style: { ...table.style, margins: { ...table.style.margins, bottom: 0 } },
+    children: headRows,
+  };
+  const tableTail = {
+    ...table,
+    style: { ...table.style, margins: { ...table.style.margins, top: 0 } },
+    children: tailRows,
+  };
+
+  const availableSize = getDesiredSize(table, desiredSizes);
+  let pdf = new pdfKit();
+  registerFonts((fontName: string, fontSource: AD.Font.FontSource) => pdf.registerFont(fontName, fontSource), document);
+  const headSizes = measureTable(pdf, resources, availableSize, tableHead);
+  const tailSizes = measureTable(pdf, resources, availableSize, tableTail);
+
+  headSizes.forEach((value, key) => desiredSizes.set(key, value));
+  tailSizes.forEach((value, key) => desiredSizes.set(key, value));
+
+  return [tableHead, tableTail];
+}

package/src/abstract-document-exporters/pdf/pre-process.ts

@@ -29,45 +29,40 @@ const alphabet = [
   "w",
   "x",
   "y",
-  "z"
+  "z",
 ];
 
 const _numberingLevelItems = new Map<string, number>();
 
-export function preProcess(
-  doc: AD.AbstractDoc.AbstractDoc
-): AD.AbstractDoc.AbstractDoc {
-  const children = doc.children.map(s => preProcessSection(s, doc));
+export function preProcess(doc: AD.AbstractDoc.AbstractDoc): AD.AbstractDoc.AbstractDoc {
+  const children = doc.children.map((s) => preProcessSection(s, doc));
   return AD.AbstractDoc.create(
     {
       fonts: doc.fonts,
       imageResources: doc.imageResources,
       styles: doc.styles,
       numberings: doc.numberings,
-      numberingDefinitions: doc.numberingDefinitions
+      numberingDefinitions: doc.numberingDefinitions,
     },
     children
   );
 }
 
-function preProcessSection(
-  s: AD.Section.Section,
-  parentResources: AD.Resources.Resources
-): AD.Section.Section {
+function preProcessSection(s: AD.Section.Section, parentResources: AD.Resources.Resources): AD.Section.Section {
   const resources = AD.Resources.mergeResources([parentResources, s]);
   const header = R.unnest<AD.SectionElement.SectionElement>(
-    s.page.header.map(e => preProcessSectionElement(e, resources))
+    s.page.header.map((e) => preProcessSectionElement(e, resources))
   );
   const footer = R.unnest<AD.SectionElement.SectionElement>(
-    s.page.footer.map(e => preProcessSectionElement(e, resources))
+    s.page.footer.map((e) => preProcessSectionElement(e, resources))
   );
   const page = AD.MasterPage.create({
     style: s.page.style,
     header: header,
-    footer: footer
+    footer: footer,
   });
   const children = R.unnest<AD.SectionElement.SectionElement>(
-    s.children.map(e => preProcessSectionElement(e, resources))
+    s.children.map((e) => preProcessSectionElement(e, resources))
   );
   return AD.Section.create({ page: page, id: s.id }, children);
 }
@@ -105,10 +100,8 @@ function preProcessParagraph(
   const level = paragraph.numbering.level;
   const key = numbering + "_" + level.toString();
   const levelDefinitions = resources.numberingDefinitions[numbering].levels;
-  for (let levelDefinition of levelDefinitions.filter(l => l.level > level)) {
-    _numberingLevelItems.delete(
-      numbering + "_" + levelDefinition.level.toString()
-    );
+  for (let levelDefinition of levelDefinitions.filter((l) => l.level > level)) {
+    _numberingLevelItems.delete(numbering + "_" + levelDefinition.level.toString());
   }
 
   const numberOverride = paragraph.numbering.numberOverride;
@@ -122,7 +115,7 @@ function preProcessParagraph(
     _numberingLevelItems.set(key, (_numberingLevelItems.get(key) || 0) + 1);
   }
 
-  for (let levelDefinition of levelDefinitions.filter(l => l.level <= level)) {
+  for (let levelDefinition of levelDefinitions.filter((l) => l.level <= level)) {
     const numberingLevel = numbering + "_" + levelDefinition.level.toString();
     const currentNumber = _numberingLevelItems.get(numberingLevel) || 0;
     const levelText = generateLevelText(levelDefinition.format, currentNumber);
@@ -135,24 +128,21 @@ function preProcessParagraph(
 
   children.push(AD.TableCell.create());
 
-  const numberTextStyle = TextStyle.overrideWith(
-    levelDefinitions[level].style,
-    paragraph.style.textStyle
-  );
+  const numberTextStyle = TextStyle.overrideWith(levelDefinitions[level].style, paragraph.style.textStyle);
 
   children.push(
     AD.TableCell.create({}, [
       AD.Paragraph.create(
         {
-          styleName: paragraph.styleName
+          styleName: paragraph.styleName,
         },
         [
           AD.TextRun.create({
             style: numberTextStyle,
-            text: paragraph.numbering.append !== true ? numberText : ""
-          })
+            text: paragraph.numbering.append !== true ? numberText : "",
+          }),
         ]
-      )
+      ),
     ])
   );
 
@@ -166,22 +156,16 @@ function preProcessParagraph(
       {
         style: AD.TableStyle.create({
           alignment: "Left",
-          cellStyle: AD.TableCellStyle.create({ verticalAlignment: "Top" })
+          cellStyle: AD.TableCellStyle.create({ verticalAlignment: "Top" }),
         }),
-        columnWidths: [
-          indentationWidth - numberingWidth,
-          numberingWidth,
-          Infinity
-        ]
+        columnWidths: [indentationWidth - numberingWidth, numberingWidth, Infinity],
       },
       rows
-    )
+    ),
   ];
 }
 
-function adjustParagraph(
-  paragraph: AD.Paragraph.Paragraph
-): Array<AD.SectionElement.SectionElement> {
+function adjustParagraph(paragraph: AD.Paragraph.Paragraph): Array<AD.SectionElement.SectionElement> {
   return [paragraph];
   // let adjustedParagraphs: Array<AD.SectionElement.SectionElement> = [];
   // paragraph.children.forEach((a) => {
@@ -217,10 +201,7 @@ function adjustParagraph(
 
   // return adjustedParagraphs;
 }
-function generateLevelText(
-  numberingFormat: AD.NumberingFormat.NumberingFormat,
-  num: number
-): string {
+function generateLevelText(numberingFormat: AD.NumberingFormat.NumberingFormat, num: number): string {
   switch (numberingFormat) {
     case "Decimal":
       return num.toString();
@@ -301,41 +282,77 @@ function toChar(num: number): string {
 //   });
 // }
 
-function preProcessTable(
-  table: AD.Table.Table,
-  resources: AD.Resources.Resources
-): AD.SectionElement.SectionElement {
-  const children = table.children.map(r => preProcessTableRow(r, resources));
+function preProcessTable(table: AD.Table.Table, resources: AD.Resources.Resources): AD.SectionElement.SectionElement {
+  const processedChildren = [];
+  let rowSpans: Map<number, AD.TableCell.TableCell> = new Map();
+  for (const row of table.children) {
+    const children = preProcessTableRow(row, rowSpans, resources);
+    processedChildren.push(children);
+  }
   return AD.Table.create(
     {
       columnWidths: table.columnWidths,
       styleName: table.styleName,
-      style: table.style
+      style: table.style,
     },
-    children
+    processedChildren
   );
 }
 
 function preProcessTableRow(
   r: AD.TableRow.TableRow,
+  rowSpans: Map<number, AD.TableCell.TableCell>,
   resources: AD.Resources.Resources
 ): AD.TableRow.TableRow {
-  const children = r.children.map(c => preProcessTableCell(c, resources));
-  return AD.TableRow.create({}, children);
+  const processedChildren = [];
+  let columnIndex = 0;
+  for (const cell of r.children) {
+    let dummyCell = rowSpans.get(columnIndex);
+    while (dummyCell) {
+      processedChildren.push(dummyCell);
+      if (dummyCell.rowSpan <= 1) {
+        rowSpans.delete(columnIndex);
+      } else {
+        rowSpans.set(columnIndex, { ...dummyCell, rowSpan: dummyCell.rowSpan - 1 });
+      }
+      columnIndex += dummyCell.columnSpan || 1;
+      dummyCell = rowSpans.get(columnIndex);
+    }
+
+    const processedCell = preProcessTableCell(cell, resources);
+    processedChildren.push(processedCell);
+    if ((processedCell.rowSpan || 1) > 1) {
+      rowSpans.set(columnIndex, { ...processedCell, children: [], rowSpan: processedCell.rowSpan - 1, dummy: true });
+    }
+    columnIndex += cell.columnSpan || 1;
+  }
+
+  // Make sure to reduce the rowSpanLeft of any cell that is at the end
+  let dummyCell = rowSpans.get(columnIndex);
+  while (dummyCell) {
+    processedChildren.push(dummyCell);
+    if (dummyCell.rowSpan <= 1) {
+      rowSpans.delete(columnIndex);
+    } else {
+      rowSpans.set(columnIndex, { ...dummyCell, rowSpan: dummyCell.rowSpan - 1 });
+    }
+    columnIndex += dummyCell.columnSpan || 1;
+    dummyCell = rowSpans.get(columnIndex);
+  }
+
+  return AD.TableRow.create({}, processedChildren);
 }
 
-function preProcessTableCell(
-  c: AD.TableCell.TableCell,
-  resources: AD.Resources.Resources
-): AD.TableCell.TableCell {
+function preProcessTableCell(c: AD.TableCell.TableCell, resources: AD.Resources.Resources): AD.TableCell.TableCell {
   const children = R.unnest<AD.SectionElement.SectionElement>(
-    c.children.map(e => preProcessSectionElement(e, resources))
+    c.children.map((e) => preProcessSectionElement(e, resources))
   );
   return AD.TableCell.create(
     {
       styleName: c.styleName,
       columnSpan: c.columnSpan,
-      style: c.style
+      rowSpan: c.rowSpan,
+      style: c.style,
     },
     children
   );
@@ -346,17 +363,17 @@ function preProcessGroup(
   parentResources: AD.Resources.Resources
 ): Array<AD.SectionElement.SectionElement> {
   const children = R.unnest<AD.SectionElement.SectionElement>(
-    group.children.map(e => preProcessSectionElement(e, parentResources))
+    group.children.map((e) => preProcessSectionElement(e, parentResources))
   );
   if (group.keepTogether || AD.Resources.hasResources(group)) {
     return [
       AD.Group.create(
         {
           keepTogether: group.keepTogether,
-          ...AD.Resources.extractResources(group)
+          ...AD.Resources.extractResources(group),
         },
         children
-      )
+      ),
     ];
   }
   return children;