abstract-document 6.9.5 → 6.10.3

package/src/abstract-document-xml/__tests__/test-defs/simple-document.tsx

@@ -0,0 +1,196 @@
+import { ExportTestDef } from "../export-test-def";
+
+export const test: ExportTestDef = {
+  name: "Simple document",
+  images: {},
+  fonts: {},
+  abstractDocXML: `<AbstractDoc>
+  <StyleNames>
+      <StyleName name="footerResultText" type="TextStyle" fontSize="8" color="#353535" bold="true"/>
+      <StyleName name="footerResultCell" type="TableCellStyle" padding="4 4 3 0" borders="1 0 0 0" borderColor="#123151" verticalAlignment="Bottom"/>
+  </StyleNames>
+  <Section>
+      <Table columnWidths="375,70,60">
+          <style margins="150 0 0 0"/>
+          <TableRow>
+              <TableCell styleName="footerResultCell"/>
+              <TextCell text="Cost €" styleNames="footerResultText, footerResultCell"/>
+              <TextCell text="Price €" styleNames="footerResultText, footerResultCell"/>
+          </TableRow>
+      </Table>
+  </Section>
+</AbstractDoc>`,
+  expectedPdfJson: {
+    children: [
+      {
+        page: {
+          style: {
+            headerMargins: { top: 0, bottom: 0, left: 0, right: 0 },
+            footerMargins: { top: 0, bottom: 0, left: 0, right: 0 },
+            contentMargins: { top: 0, bottom: 0, left: 0, right: 0 },
+            orientation: "Portrait",
+            paperSize: "A4",
+            noTopBottomMargin: false,
+          },
+          header: [],
+          footer: [],
+        },
+        id: "",
+        children: [
+          {
+            type: "Table",
+            columnWidths: [375, 70, 60],
+            styleName: "",
+            style: {
+              margins: { top: 150, right: 0, bottom: 0, left: 0 },
+              type: "TableStyle",
+            },
+            headerRows: [],
+            children: [
+              {
+                children: [
+                  {
+                    styleName: "footerResultCell",
+                    columnSpan: 1,
+                    rowSpan: 1,
+                    style: {
+                      type: "TableCellStyle",
+                      borders: { top: 0, bottom: 0, left: 0, right: 0 },
+                      borderColors: { top: "", bottom: "", left: "", right: "" },
+                      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+                    },
+                    dummy: false,
+                    children: [],
+                  },
+                  {
+                    styleName: "footerResultCell",
+                    columnSpan: 1,
+                    rowSpan: 1,
+                    style: {
+                      type: "TableCellStyle",
+                      borders: { top: 0, bottom: 0, left: 0, right: 0 },
+                      borderColors: { top: "", bottom: "", left: "", right: "" },
+                      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+                    },
+                    dummy: false,
+                    children: [
+                      {
+                        type: "Paragraph",
+                        styleName: "",
+                        style: {
+                          type: "ParagraphStyle",
+                          margins: { top: 0, bottom: 0, left: 0, right: 0 },
+                          position: "relative",
+                          textStyle: { type: "TextStyle" },
+                        },
+                        children: [
+                          {
+                            type: "TextRun",
+                            styleName: "footerResultText",
+                            text: "Cost €",
+                            style: { type: "TextStyle" },
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                  {
+                    styleName: "footerResultCell",
+                    columnSpan: 1,
+                    rowSpan: 1,
+                    style: {
+                      type: "TableCellStyle",
+                      borders: { top: 0, bottom: 0, left: 0, right: 0 },
+                      borderColors: { top: "", bottom: "", left: "", right: "" },
+                      padding: { top: 0, bottom: 0, left: 0, right: 0 },
+                    },
+                    dummy: false,
+                    children: [
+                      {
+                        type: "Paragraph",
+                        styleName: "",
+                        style: {
+                          type: "ParagraphStyle",
+                          margins: { top: 0, bottom: 0, left: 0, right: 0 },
+                          position: "relative",
+                          textStyle: { type: "TextStyle" },
+                        },
+                        children: [
+                          {
+                            type: "TextRun",
+                            styleName: "footerResultText",
+                            text: "Price €",
+                            style: { type: "TextStyle" },
+                          },
+                        ],
+                      },
+                    ],
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      },
+    ],
+    styles: {
+      TextStyle_footerResultText: {
+        name: "footerResultText",
+        type: "TextStyle",
+        fontSize: 8,
+        color: "#353535",
+        bold: "true",
+        style: { type: "TextStyle" },
+      },
+      TableCellStyle_footerResultCell: {
+        name: "footerResultCell",
+        type: "TableCellStyle",
+        padding: { top: 4, right: 4, bottom: 3, left: 0 },
+        borders: { top: 1, right: 0, bottom: 0, left: 0 },
+        borderColor: "#123151",
+        verticalAlignment: "Bottom",
+      },
+      ParagraphStyle_H1: {
+        type: "ParagraphStyle",
+        margins: { top: 8, bottom: 2, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 32 },
+      },
+      ParagraphStyle_H2: {
+        type: "ParagraphStyle",
+        margins: { top: 6, bottom: 1.5, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 24 },
+      },
+      ParagraphStyle_H3: {
+        type: "ParagraphStyle",
+        margins: { top: 4.5, bottom: 1.125, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 18 },
+      },
+      ParagraphStyle_H4: {
+        type: "ParagraphStyle",
+        margins: { top: 3.75, bottom: 0.9375, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 15 },
+      },
+      ParagraphStyle_H5: {
+        type: "ParagraphStyle",
+        margins: { top: 3.25, bottom: 0.8125, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 13 },
+      },
+      ParagraphStyle_H6: {
+        type: "ParagraphStyle",
+        margins: { top: 2.5, bottom: 0.625, left: 0, right: 0 },
+        position: "relative",
+        textStyle: { type: "TextStyle", bold: true, fontSize: 10 },
+      },
+      TextStyle_Emphasis: { type: "TextStyle", italic: true },
+      TextStyle_Strong: { type: "TextStyle", bold: true },
+      TextStyle_Subscript: { type: "TextStyle", subScript: true, fontSize: 6 },
+      TextStyle_Superscript: { type: "TextStyle", superScript: true, fontSize: 6 },
+    },
+    fonts: {},
+  },
+};

package/src/abstract-document-xml/abstract-doc-of-xml/abstract-doc-of-xml.ts

@@ -0,0 +1,96 @@
+import { XmlElement } from "../parse-xml";
+import { ADCreatorFn, propsCreators } from "./creator";
+
+export function abstractDocOfXml(
+  creators: Record<string, ADCreatorFn>,
+  xmlElement: XmlElement,
+  onlyChildren: boolean = false
+): unknown {
+  const children = [];
+  const props: Record<string, unknown> = {};
+  for (const childElement of xmlElement.children ?? []) {
+    const childName = childElement.tagName;
+    if (childName !== undefined) {
+      if (childName === "StyleNames") {
+        props.styles = abstractDocOfXml(creators, childElement);
+      } else if (childName === "StyleName" && childElement.attributes && childElement.attributes.name) {
+        const styleName = childElement.attributes.name;
+        const style = abstractDocOfXml(creators, childElement);
+        props[styleName] = style;
+      } else if (childName.startsWith(childName.charAt(0).toUpperCase())) {
+        // For uppercase elements we add them to the children key
+        children.push(abstractDocOfXml(creators, childElement));
+      } else {
+        // For lowercase elements we add them as keys using their name
+        // Some special keys should directly have an array of children as value instead of an object with children key
+        const childrenOnly = childName === "header" || childName === "footer" || childName === "headerRows";
+        props[childName] = abstractDocOfXml(creators, childElement, childrenOnly);
+      }
+    }
+  }
+  if (onlyChildren) {
+    return children;
+  }
+
+  // Create the abstract doc object to return
+  const allProps = { ...xmlElement.attributes, ...props };
+  const creator = xmlElement.tagName && creators[xmlElement.tagName] ? creators[xmlElement.tagName] : () => allProps;
+  if (creator === undefined) {
+    throw new Error(`Could not find creator for element with name ${xmlElement.tagName}`);
+  }
+  //
+  const theObj = creator(allProps, children) as { [k: string]: unknown };
+
+  for (const propName of Object.keys(allProps)) {
+    const propsCreator = allProps[propName] && propsCreators[propName] ? propsCreators[propName] : undefined;
+    if (propsCreator) {
+      theObj[propsCreator.name] = propsCreator(allProps, children);
+    }
+  }
+
+  // Elements styling needs to have style: {type= "StyleName" }. Occures when having a <style></style> element.
+  if (theObj.type && (theObj.type as string) === "Table") {
+    theObj.style = { ...(theObj.style as Object), type: "TableStyle" };
+  }
+  if (theObj.type && (theObj.type as string).startsWith("Text")) {
+    theObj.style = { ...(theObj.style as Object), type: "TextStyle" };
+  }
+  if (theObj.type && (theObj.type as string) === "Paragraph") {
+    theObj.style = {
+      ...(theObj.style as Object),
+      type: "ParagraphStyle",
+      textStyle: { type: "TextStyle" },
+    };
+  }
+  if (theObj.columnSpan) {
+    theObj.style = { ...(theObj.style as Object), type: "TableCellStyle" };
+  }
+  // let theObj["columnWidths"] = propsCreator(allProps, children);
+  if (children.length > 0) {
+    (theObj as { children: Array<unknown> }).children = children;
+  }
+  return theObj;
+}
+
+export function extractImageFontsStyleNames(
+  xmlElement: ReadonlyArray<XmlElement>
+): readonly [images: ReadonlyArray<string>, fonts: ReadonlyArray<string>, styleNames: Record<string, string>] {
+  const images = Array<string>();
+  const fonts = Array<string>();
+  let styleNames: Record<string, string> = {};
+  xmlElement.forEach((item) => {
+    if (item.tagName === "Image" && item.attributes?.src) {
+      images.push(item.attributes.src as string);
+    } else if (item.attributes?.fontFamily) {
+      fonts.push(item.attributes.fontFamily as string);
+    } else if (item.tagName === "StyleName" && item.attributes.name && item.attributes.type) {
+      styleNames[item.attributes.name as string] = item.attributes.type;
+    } else {
+      const [newImages, newFonts, newStyleNames] = extractImageFontsStyleNames(item.children);
+      images.push(...newImages);
+      fonts.push(...newFonts);
+      styleNames = { ...styleNames, ...newStyleNames };
+    }
+  });
+  return [images, fonts, styleNames];
+}

package/src/abstract-document-xml/abstract-doc-of-xml/creator.ts

@@ -0,0 +1,267 @@
+import {
+  AbstractDoc,
+  Atom,
+  DefaultStyles,
+  Font,
+  Group,
+  Image,
+  Markdown,
+  PageBreak,
+  Paragraph,
+  Section,
+  SectionElement,
+  Table,
+  TableCell,
+  TableRow,
+  TextField,
+  TextRun,
+  TocSeparator,
+  Types,
+  ImageResource as ADImageResource,
+  TextStyle,
+} from "../../abstract-document/index";
+import {
+  TextRowProps,
+  TextRow,
+  TextCellProps,
+  TextCell,
+  TextParagraphProps,
+  TextParagraph,
+  ImageCellProps,
+  ImageCell,
+} from "./custom-elements";
+
+export type ADCreatorFn = (props?: Record<string, unknown>, children?: ReadonlyArray<unknown>) => unknown;
+
+export type ImageResource = ADImageResource.ImageResource & { readonly width?: number; readonly height?: number };
+
+export type TextRunProps = {
+  readonly text: string;
+  readonly styleName?: string;
+  readonly style?: TextStyle.TextStyle;
+};
+
+export const creators: (
+  images: Record<string, ImageResource>,
+  fonts: Types.Indexer<Font.Font>,
+  styleNames: Record<string, string>
+) => Record<string, ADCreatorFn> = (images, fonts, styleNames) => {
+  return {
+    AbstractDoc: (props, children: ReadonlyArray<Section.Section>) => {
+      if (props) {
+        props.fonts = fonts ?? undefined;
+      }
+      return AbstractDoc.create(props, children);
+    },
+    Paragraph: (props, children: ReadonlyArray<Atom.Atom>) => Paragraph.create(props, children),
+    Section: (props, children: ReadonlyArray<SectionElement.SectionElement>) => Section.create(props, children),
+    TextRun: (props) => TextRun.create(props as unknown as TextRun.TextRunProps),
+    TextRow: (props: TextRowProps) => TextRow(props, styleNames),
+    TextCell: (props: TextCellProps) => TextCell(props, styleNames),
+    TextParagraph: (props: TextParagraphProps) => TextParagraph(props, styleNames),
+    ImageCell: (props: ImageCellProps) => ImageCell(props, styleNames),
+    Table: (props, children: ReadonlyArray<TableRow.TableRow>) =>
+      Table.create(props as unknown as Table.TableProps, children),
+    TableRow: (props, children: ReadonlyArray<TableCell.TableCell>) => TableRow.create(props, children),
+    TableCell: (props, children: ReadonlyArray<SectionElement.SectionElement>) => TableCell.create(props, children),
+    TextField: (props) => TextField.create(props as unknown as TextField.TextFieldProps),
+    Image: (props: Record<string, unknown>) => {
+      const image = images[(props.src as string) ?? ""];
+      if (image) {
+        if (image.width && image.height) {
+          props.width = image.width;
+          props.height = image.height;
+        } else {
+          const scaleX = (props.width as number) / image.abstractImage.size.width;
+          const scaleY = (props.height as number) / image.abstractImage.size.height;
+          if (scaleX < scaleY) {
+            props.height = (props.height as number) * (scaleX / scaleY);
+          } else {
+            props.width = (props.width as number) * (scaleY / scaleX);
+          }
+        }
+
+        props.imageResource = images[props.src as string];
+      }
+      return Image.create(props as unknown as Image.ImageProps);
+    },
+    Group: (props, children) => Group.create(props, children as ReadonlyArray<Group.Group>),
+    PageBreak: () => PageBreak.create(),
+    Markdown: (props) => Markdown.create(props as unknown as Markdown.MarkdownProps),
+    TocSeparator: (props) => TocSeparator.create(props as TocSeparator.TocSeparatorProps),
+  };
+};
+
+export const propsCreators: Record<string, ADCreatorFn> = {
+  styles: (props: {
+    readonly styles: Record<string, Record<string, string | number> & { readonly type: string }>;
+  }): unknown => {
+    const fixedStyles: Record<string, Record<string, string | number>> = {};
+    if (props.styles) {
+      Object.keys(props.styles).forEach((key: string) => {
+        const styleObj = props.styles[key];
+        fixedStyles[((styleObj ? styleObj.type : "") + "_" + key) as string] = { ...props.styles[key] };
+      });
+    }
+
+    return { ...fixedStyles, ...DefaultStyles.createStandardStyles() };
+  },
+  columnWidths: (props: { readonly columnWidths: string; readonly columnMultiplier: string }): unknown => {
+    const columnWidths = props.columnWidths
+      .toString()
+      .split(",")
+      .map((item: string) => {
+        const number = Number(item);
+        return number === 0 || Number.isNaN(number) ? Infinity : number;
+      });
+    if (props.columnMultiplier) {
+      return columnWidths.map((l) => l * Number(props.columnMultiplier));
+    }
+    return columnWidths;
+  },
+  borders: (props: { readonly borders: string }): unknown => {
+    const borders: { [k: string]: number } = { top: 0, right: 0, bottom: 0, left: 0 };
+    const propBorders = props.borders.toString().split(" ");
+    if (!propBorders) {
+      return borders;
+    }
+
+    if (propBorders.length === 1) {
+      borders.top = Number(propBorders[0]);
+      borders.right = Number(propBorders[0]);
+      borders.bottom = Number(propBorders[0]);
+      borders.left = Number(propBorders[0]);
+      return borders;
+    }
+
+    propBorders.forEach((item: string, index) => {
+      switch (index) {
+        case 1:
+          borders.top = Number(propBorders[0]);
+          borders.right = Number(item);
+          borders.bottom = Number(propBorders[0]);
+          borders.left = Number(item);
+          break;
+        case 2:
+          borders.top = Number(propBorders[0]);
+          borders.right = Number(propBorders[1]);
+          borders.bottom = Number(item);
+          borders.left = Number(propBorders[1]);
+          break;
+        case 3:
+          borders.top = Number(propBorders[0]);
+          borders.right = Number(propBorders[1]);
+          borders.bottom = Number(propBorders[2]);
+          borders.left = Number(item);
+          break;
+        default:
+          break;
+      }
+    });
+    return borders;
+  },
+  padding: (props: { readonly padding: string }): unknown => {
+    const padding: { [k: string]: number } = { top: 0, right: 0, bottom: 0, left: 0 };
+
+    const paddings = props.padding.toString().split(" ");
+    if (!paddings) {
+      return padding;
+    }
+
+    if (paddings.length === 1) {
+      padding.top = Number(paddings[0]);
+      padding.right = Number(paddings[0]);
+      padding.bottom = Number(paddings[0]);
+      padding.left = Number(paddings[0]);
+      return padding;
+    }
+
+    paddings.forEach((item: string, index) => {
+      switch (index) {
+        case 1:
+          padding.top = Number(paddings[0]);
+          padding.right = Number(item);
+          padding.bottom = Number(paddings[0]);
+          padding.left = Number(item);
+          break;
+        case 2:
+          padding.top = Number(paddings[0]);
+          padding.right = Number(paddings[1]);
+          padding.bottom = Number(item);
+          padding.left = Number(paddings[1]);
+          break;
+        case 3:
+          padding.top = Number(paddings[0]);
+          padding.right = Number(paddings[1]);
+          padding.bottom = Number(paddings[2]);
+          padding.left = Number(item);
+          break;
+        default:
+          break;
+      }
+    });
+    return padding;
+  },
+  margins: (props: { readonly margins: string }): unknown => {
+    const margins: { [k: string]: number } = { top: 0, right: 0, bottom: 0, left: 0 };
+    const propMargins = props.margins.toString().split(" ");
+    if (!propMargins) {
+      return margins;
+    }
+
+    if (propMargins.length === 1) {
+      margins.top = Number(propMargins[0]);
+      margins.right = Number(propMargins[0]);
+      margins.bottom = Number(propMargins[0]);
+      margins.left = Number(propMargins[0]);
+      return margins;
+    }
+    propMargins.forEach((item: string, index) => {
+      switch (index) {
+        case 1:
+          margins.top = Number(propMargins[0]);
+          margins.right = Number(item);
+          margins.bottom = Number(propMargins[0]);
+          margins.left = Number(item);
+          break;
+        case 2:
+          margins.top = Number(propMargins[0]);
+          margins.right = Number(propMargins[1]);
+          margins.bottom = Number(item);
+          margins.left = Number(propMargins[1]);
+          break;
+        case 3:
+          margins.top = Number(propMargins[0]);
+          margins.right = Number(propMargins[1]);
+          margins.bottom = Number(propMargins[2]);
+          margins.left = Number(item);
+          break;
+        default:
+          break;
+      }
+    });
+    return margins;
+  },
+  borderColors: (props: { readonly borderColors: string }): unknown => {
+    const borderColors: { [k: string]: string } = { top: "", right: "", bottom: "", left: "" };
+    props.borderColors.split(" ").forEach((item: string, index) => {
+      switch (index) {
+        case 0:
+          borderColors.top = item;
+          break;
+        case 1:
+          borderColors.right = item;
+          break;
+        case 2:
+          borderColors.bottom = item;
+          break;
+        case 3:
+          borderColors.left = item;
+          break;
+        default:
+          break;
+      }
+    });
+    return borderColors;
+  },
+};

package/src/abstract-document-xml/abstract-doc-of-xml/custom-elements.tsx

@@ -0,0 +1,110 @@
+import {
+  TextStyle,
+  ParagraphStyle,
+  TableCellStyle,
+  ImageResource,
+  TextRun,
+  Paragraph,
+  TableCell,
+  TableRow,
+  Image,
+} from "../../abstract-document/index";
+
+type StyleProps = {
+  readonly ParagraphStyle: string;
+  readonly TextStyle: string;
+  readonly TableCellStyle: string;
+  readonly TableStyle: string;
+  readonly GroupStyle: string;
+};
+
+const stylePropsKeys: Record<string, boolean> = {
+  ParagraphStyle: true,
+  TextStyle: true,
+  TableCellStyle: true,
+  TableStyle: true,
+  GroupStyle: true,
+};
+
+export function extractStyleNames(
+  styleNames: string | undefined,
+  styleNameTypes: Record<string, string>
+): Partial<StyleProps> {
+  const names = (styleNames || "").split(",");
+
+  let styleNameProps = {};
+
+  for (const name of names) {
+    const trimmed = name.trim();
+    const type = styleNameTypes[trimmed];
+    if (type && stylePropsKeys[type]) {
+      styleNameProps = { ...styleNameProps, [type]: trimmed };
+    }
+  }
+  return styleNameProps;
+}
+
+export type TextParagraphProps = {
+  readonly text: string;
+  readonly textStyle?: TextStyle.TextStyle;
+  readonly paragraphStyle?: ParagraphStyle.ParagraphStyle;
+  readonly styleNames?: string;
+};
+
+export function TextParagraph(props: TextParagraphProps, styleNameTypes: Record<string, string>): Paragraph.Paragraph {
+  const { text, textStyle, paragraphStyle } = props;
+  const styleNames = extractStyleNames(props.styleNames, styleNameTypes);
+  const textRun = TextRun.create({ text, style: textStyle, styleName: styleNames.TextStyle });
+  return Paragraph.create({ style: paragraphStyle, styleName: styleNames.ParagraphStyle }, [textRun]);
+}
+
+export type TextCellProps = TextParagraphProps & {
+  readonly columnSpan?: number;
+  readonly rowSpan?: number;
+  readonly cellStyle?: TableCellStyle.TableCellStyle;
+  readonly styleNames?: string;
+};
+
+export function TextCell(props: TextCellProps, styleNameTypes: Record<string, string>): TableCell.TableCell {
+  const { text, textStyle, paragraphStyle, cellStyle, columnSpan, rowSpan } = props;
+  const styleNames = extractStyleNames(props.styleNames, styleNameTypes);
+  const textRun = TextRun.create({ text, style: textStyle, styleName: styleNames.TextStyle });
+  const paragraph = Paragraph.create({ style: paragraphStyle, styleName: styleNames.ParagraphStyle }, [textRun]);
+  return TableCell.create({ columnSpan, rowSpan, style: cellStyle, styleName: styleNames.TableCellStyle }, [paragraph]);
+}
+
+export type TextRowProps = TextCellProps & {};
+
+export function TextRow(props: TextRowProps, styleNameTypes: Record<string, string>): TableRow.TableRow {
+  const { text, textStyle, paragraphStyle, cellStyle, columnSpan, rowSpan } = props;
+  const styleNames = extractStyleNames(props.styleNames, styleNameTypes);
+  const textRun = TextRun.create({ text, style: textStyle, styleName: styleNames.TextStyle });
+  const paragraph = Paragraph.create({ style: paragraphStyle, styleName: styleNames.ParagraphStyle }, [textRun]);
+  const tableCell = TableCell.create({ columnSpan, rowSpan, style: cellStyle, styleName: styleNames.TableCellStyle }, [
+    paragraph,
+  ]);
+  return TableRow.create({}, [tableCell]);
+}
+
+export type ImageCellProps = {
+  readonly image: ImageResource.ImageResource | undefined;
+  readonly width: number;
+  readonly height: number;
+  readonly paragraphStyle?: ParagraphStyle.ParagraphStyle;
+  readonly cellStyle?: TableCellStyle.TableCellStyle;
+  readonly columnSpan?: number;
+  readonly rowSpan?: number;
+  readonly styleNames?: string;
+};
+
+export function ImageCell(props: ImageCellProps, styleNameTypes: Record<string, string>): TableCell.TableCell {
+  const { image, width, height, paragraphStyle, cellStyle, columnSpan, rowSpan } = props;
+  const styleNames = extractStyleNames(props.styleNames, styleNameTypes);
+  const imageElement = image && Image.create({ imageResource: image, width, height });
+  const paragraph =
+    imageElement && Paragraph.create({ style: paragraphStyle, styleName: styleNames.ParagraphStyle }, [imageElement]);
+  return TableCell.create(
+    { columnSpan, rowSpan, style: cellStyle, styleName: styleNames.TableCellStyle },
+    paragraph && [paragraph]
+  );
+}

package/src/abstract-document-xml/abstract-doc-of-xml/index.ts

@@ -0,0 +1,2 @@
+export * from "./abstract-doc-of-xml";
+export { creators } from "./creator";

package/src/abstract-document-xml/index.ts

@@ -0,0 +1,3 @@
+export * from "./xsd-template";
+export * from "./abstract-doc-of-xml";
+export * from "./parse-xml";

package/src/abstract-document-xml/parse-xml/index.ts

@@ -0,0 +1,2 @@
+export * from "./validation";
+export * from "./parse-xml";