docx 6.0.3 → 7.1.2

package/src/file/styles/styles.ts

@@ -3,7 +3,6 @@ import { BaseXmlComponent, ImportedXmlComponent, XmlComponent } from "file/xml-c
 import { StyleForCharacter, StyleForParagraph } from "./style";
 import { ICharacterStyleOptions } from "./style/character-style";
 import { IParagraphStyleOptions } from "./style/paragraph-style";
-export * from "./border";
 
 export interface IStylesOptions {
     readonly default?: IDefaultStylesOptions;
@@ -13,6 +12,13 @@ export interface IStylesOptions {
     readonly importedStyles?: (XmlComponent | StyleForParagraph | StyleForCharacter | ImportedXmlComponent)[];
 }
 
+// <xsd:complexType name="CT_Styles">
+// <xsd:sequence>
+//   <xsd:element name="docDefaults" type="CT_DocDefaults" minOccurs="0"/>
+//   <xsd:element name="latentStyles" type="CT_LatentStyles" minOccurs="0" maxOccurs="1"/>
+//   <xsd:element name="style" type="CT_Style" minOccurs="0" maxOccurs="unbounded"/>
+// </xsd:sequence>
+// </xsd:complexType>
 export class Styles extends XmlComponent {
     constructor(options: IStylesOptions) {
         super("w:styles");

package/src/file/table/grid.ts

@@ -1,8 +1,19 @@
 // http://officeopenxml.com/WPtableGrid.php
+
+// <xsd:complexType name="CT_TblGridCol">
+//     <xsd:attribute name="w" type="s:ST_TwipsMeasure"/>
+// </xsd:complexType>
+// <xsd:complexType name="CT_TblGridBase">
+//     <xsd:sequence>
+//         <xsd:element name="gridCol" type="CT_TblGridCol" minOccurs="0" maxOccurs="unbounded"/>
+//     </xsd:sequence>
+// </xsd:complexType>
+
+import { twipsMeasureValue } from "file/values";
 import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
 
 export class TableGrid extends XmlComponent {
-    constructor(widths: number[]) {
+    constructor(widths: number[] | string[]) {
         super("w:tblGrid");
         for (const width of widths) {
             this.root.push(new GridCol(width));
@@ -10,15 +21,15 @@ export class TableGrid extends XmlComponent {
     }
 }
 
-class GridColAttributes extends XmlAttributeComponent<{ readonly w: number }> {
+class GridColAttributes extends XmlAttributeComponent<{ readonly w: number | string }> {
     protected readonly xmlKeys = { w: "w:w" };
 }
 
 export class GridCol extends XmlComponent {
-    constructor(width?: number) {
+    constructor(width?: number | string) {
         super("w:gridCol");
         if (width !== undefined) {
-            this.root.push(new GridColAttributes({ w: width }));
+            this.root.push(new GridColAttributes({ w: twipsMeasureValue(width) }));
         }
     }
 }

package/src/file/table/index.ts

@@ -1,5 +1,5 @@
 export * from "./table";
 export * from "./table-cell";
 export * from "./table-properties";
-export * from "./shading";
 export * from "./table-row";
+export * from "./table-width";

package/src/file/table/table-cell/table-cell-components.ts

@@ -1,78 +1,53 @@
-import { BorderStyle } from "file/styles";
+import { BorderElement, IBorderOptions } from "file/border";
+import { decimalNumber } from "file/values";
 import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
 
-class CellBorderAttributes extends XmlAttributeComponent<{
-    readonly style: BorderStyle;
-    readonly size: number;
-    readonly color: string;
-}> {
-    protected readonly xmlKeys = { style: "w:val", size: "w:sz", color: "w:color" };
-}
-
-class BaseTableCellBorder extends XmlComponent {
-    public setProperties(style: BorderStyle, size: number, color: string): BaseTableCellBorder {
-        const attrs = new CellBorderAttributes({
-            style: style,
-            size: size,
-            color: color,
-        });
-        this.root.push(attrs);
-
-        return this;
-    }
+// <xsd:complexType name="CT_TcBorders">
+// <xsd:sequence>
+//   <xsd:element name="top" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="start" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="left" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="bottom" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="end" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="right" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="insideH" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="insideV" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="tl2br" type="CT_Border" minOccurs="0"/>
+//   <xsd:element name="tr2bl" type="CT_Border" minOccurs="0"/>
+// </xsd:sequence>
+// </xsd:complexType>
+
+export interface ITableCellBorders {
+    readonly top?: IBorderOptions;
+    readonly start?: IBorderOptions;
+    readonly left?: IBorderOptions;
+    readonly bottom?: IBorderOptions;
+    readonly end?: IBorderOptions;
+    readonly right?: IBorderOptions;
 }
 
 export class TableCellBorders extends IgnoreIfEmptyXmlComponent {
-    constructor() {
+    constructor(options: ITableCellBorders) {
         super("w:tcBorders");
-    }
-
-    public addTopBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const top = new BaseTableCellBorder("w:top");
-        top.setProperties(style, size, color);
-        this.root.push(top);
 
-        return this;
-    }
-
-    public addStartBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const start = new BaseTableCellBorder("w:start");
-        start.setProperties(style, size, color);
-        this.root.push(start);
-
-        return this;
-    }
-
-    public addBottomBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const bottom = new BaseTableCellBorder("w:bottom");
-        bottom.setProperties(style, size, color);
-        this.root.push(bottom);
-
-        return this;
-    }
-
-    public addEndBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const end = new BaseTableCellBorder("w:end");
-        end.setProperties(style, size, color);
-        this.root.push(end);
-
-        return this;
-    }
-
-    public addLeftBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const left = new BaseTableCellBorder("w:left");
-        left.setProperties(style, size, color);
-        this.root.push(left);
-
-        return this;
-    }
-
-    public addRightBorder(style: BorderStyle, size: number, color: string): TableCellBorders {
-        const right = new BaseTableCellBorder("w:right");
-        right.setProperties(style, size, color);
-        this.root.push(right);
-
-        return this;
+        if (options.top) {
+            this.root.push(new BorderElement("w:top", options.top));
+        }
+        if (options.start) {
+            this.root.push(new BorderElement("w:start", options.start));
+        }
+        if (options.left) {
+            this.root.push(new BorderElement("w:left", options.left));
+        }
+        if (options.bottom) {
+            this.root.push(new BorderElement("w:bottom", options.bottom));
+        }
+        if (options.end) {
+            this.root.push(new BorderElement("w:end", options.end));
+        }
+        if (options.right) {
+            this.root.push(new BorderElement("w:right", options.right));
+        }
     }
 }
 
@@ -83,6 +58,10 @@ class GridSpanAttributes extends XmlAttributeComponent<{ readonly val: number }>
     protected readonly xmlKeys = { val: "w:val" };
 }
 
+// <xsd:complexType name="CT_TcPrBase">
+//   ...
+//   <xsd:element name="gridSpan" type="CT_DecimalNumber" minOccurs="0"/>
+// </xsd>
 /**
  * GridSpan element. Should be used in a table cell. Pass the number of columns that this cell need to span.
  */
@@ -92,7 +71,7 @@ export class GridSpan extends XmlComponent {
 
         this.root.push(
             new GridSpanAttributes({
-                val: value,
+                val: decimalNumber(value),
             }),
         );
     }
@@ -131,31 +110,6 @@ export class VerticalMerge extends XmlComponent {
     }
 }
 
-export enum VerticalAlign {
-    BOTTOM = "bottom",
-    CENTER = "center",
-    TOP = "top",
-}
-
-class VAlignAttributes extends XmlAttributeComponent<{ readonly val: VerticalAlign }> {
-    protected readonly xmlKeys = { val: "w:val" };
-}
-
-/**
- * Vertical align element.
- */
-export class VAlign extends XmlComponent {
-    constructor(value: VerticalAlign) {
-        super("w:vAlign");
-
-        this.root.push(
-            new VAlignAttributes({
-                val: value,
-            }),
-        );
-    }
-}
-
 export enum TextDirection {
     BOTTOM_TO_TOP_LEFT_TO_RIGHT = "btLr",
     LEFT_TO_RIGHT_TOP_TO_BOTTOM = "lrTb",
@@ -180,34 +134,3 @@ export class TDirection extends XmlComponent {
         );
     }
 }
-
-export enum WidthType {
-    /** Auto. */
-    AUTO = "auto",
-    /** Value is in twentieths of a point */
-    DXA = "dxa",
-    /** No (empty) value. */
-    NIL = "nil",
-    /** Value is in percentage. */
-    PERCENTAGE = "pct",
-}
-
-class TableCellWidthAttributes extends XmlAttributeComponent<{ readonly type: WidthType; readonly width: string | number }> {
-    protected readonly xmlKeys = { width: "w:w", type: "w:type" };
-}
-
-/**
- * Table cell width element.
- */
-export class TableCellWidth extends XmlComponent {
-    constructor(value: string | number, type: WidthType) {
-        super("w:tcW");
-
-        this.root.push(
-            new TableCellWidthAttributes({
-                width: value,
-                type: type,
-            }),
-        );
-    }
-}

package/src/file/table/table-cell/table-cell-properties.spec.ts

@@ -1,136 +1,113 @@
 import { expect } from "chai";
 
 import { Formatter } from "export/formatter";
-import { BorderStyle } from "file/styles";
+import { BorderStyle } from "file/border";
+import { VerticalAlign } from "file/vertical-align";
 
-import { VerticalAlign, VerticalMergeType, WidthType } from "./table-cell-components";
+import { WidthType } from "../table-width";
+
+import { VerticalMergeType } from "./table-cell-components";
 import { TableCellProperties } from "./table-cell-properties";
 
 describe("TableCellProperties", () => {
     describe("#constructor", () => {
         it("creates an initially empty property object", () => {
-            const properties = new TableCellProperties();
+            const properties = new TableCellProperties({});
             // The TableCellProperties is ignorable if there are no attributes,
             // which results in prepForXml returning undefined, which causes
             // the formatter to throw an error if that is the only object it
             // has been asked to format.
             expect(() => new Formatter().format(properties)).to.throw("XMLComponent did not format correctly");
         });
-    });
 
-    describe("#addGridSpan", () => {
         it("adds grid span", () => {
-            const properties = new TableCellProperties();
-            properties.addGridSpan(1);
+            const properties = new TableCellProperties({ columnSpan: 1 });
             const tree = new Formatter().format(properties);
             expect(tree).to.deep.equal({ "w:tcPr": [{ "w:gridSpan": { _attr: { "w:val": 1 } } }] });
         });
-    });
 
-    describe("#addVerticalMerge", () => {
         it("adds vertical merge", () => {
-            const properties = new TableCellProperties();
-            properties.addVerticalMerge(VerticalMergeType.CONTINUE);
+            const properties = new TableCellProperties({ verticalMerge: VerticalMergeType.CONTINUE });
             const tree = new Formatter().format(properties);
             expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "continue" } } }] });
         });
-    });
 
-    describe("#setVerticalAlign", () => {
         it("sets vertical align", () => {
-            const properties = new TableCellProperties();
-            properties.setVerticalAlign(VerticalAlign.BOTTOM);
+            const properties = new TableCellProperties({ verticalAlign: VerticalAlign.BOTTOM });
             const tree = new Formatter().format(properties);
             expect(tree).to.deep.equal({ "w:tcPr": [{ "w:vAlign": { _attr: { "w:val": "bottom" } } }] });
         });
-    });
 
-    describe("#setWidth", () => {
         it("should set width", () => {
-            const properties = new TableCellProperties();
-            properties.setWidth(1, WidthType.DXA);
+            const properties = new TableCellProperties({
+                width: {
+                    size: 1,
+                    type: WidthType.DXA,
+                },
+            });
             const tree = new Formatter().format(properties);
             expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": { _attr: { "w:type": "dxa", "w:w": 1 } } }] });
         });
 
         it("should set width using default of AUTO", () => {
-            const properties = new TableCellProperties();
-            properties.setWidth(1);
+            const properties = new TableCellProperties({
+                width: {
+                    size: 1,
+                },
+            });
             const tree = new Formatter().format(properties);
             expect(tree).to.deep.equal({ "w:tcPr": [{ "w:tcW": { _attr: { "w:type": "auto", "w:w": 1 } } }] });
         });
-    });
 
-    describe("#setShading", () => {
         it("sets shading", () => {
-            const properties = new TableCellProperties();
-            properties.setShading({
-                fill: "test",
-                color: "000",
+            const properties = new TableCellProperties({
+                shading: {
+                    fill: "ffffff",
+                    color: "000000",
+                },
             });
             const tree = new Formatter().format(properties);
-            expect(tree).to.deep.equal({ "w:tcPr": [{ "w:shd": { _attr: { "w:fill": "test", "w:color": "000" } } }] });
+            expect(tree).to.deep.equal({ "w:tcPr": [{ "w:shd": { _attr: { "w:fill": "ffffff", "w:color": "000000" } } }] });
         });
-    });
 
-    describe("#addMargins", () => {
-        it("sets shading", () => {
-            const properties = new TableCellProperties();
-            properties.addMargins({});
-            const tree = new Formatter().format(properties);
-            expect(tree).to.deep.equal({
-                "w:tcPr": [
-                    {
-                        "w:tcMar": [
-                            {
-                                "w:top": {
-                                    _attr: {
-                                        "w:type": "dxa",
-                                        "w:w": 0,
-                                    },
-                                },
-                            },
-                            {
-                                "w:bottom": {
-                                    _attr: {
-                                        "w:type": "dxa",
-                                        "w:w": 0,
-                                    },
-                                },
-                            },
-                            {
-                                "w:end": {
-                                    _attr: {
-                                        "w:type": "dxa",
-                                        "w:w": 0,
-                                    },
-                                },
-                            },
-                            {
-                                "w:start": {
-                                    _attr: {
-                                        "w:type": "dxa",
-                                        "w:w": 0,
-                                    },
-                                },
-                            },
-                        ],
+        it("should set the TableCellBorders", () => {
+            const properties = new TableCellProperties({
+                borders: {
+                    top: {
+                        style: BorderStyle.DASH_DOT_STROKED,
+                        color: "ff0000",
+                        size: 3,
                     },
-                ],
+                },
+            });
+
+            const tree = new Formatter().format(properties);
+
+            expect(tree["w:tcPr"][0]).to.deep.equal({
+                "w:tcBorders": [{ "w:top": { _attr: { "w:val": "dashDotStroked", "w:sz": 3, "w:color": "ff0000" } } }],
             });
         });
-    });
 
-    describe("#Borders", () => {
-        it("should return the TableCellBorders if Border has borders", () => {
-            const properties = new TableCellProperties();
-            properties.Borders.addTopBorder(BorderStyle.DASH_DOT_STROKED, 3, "red");
-            const borders = properties.Borders;
+        it("should set the margins", () => {
+            const properties = new TableCellProperties({
+                margins: {
+                    marginUnitType: WidthType.DXA,
+                    top: 5,
+                    left: 10,
+                    bottom: 15,
+                    right: 20,
+                },
+            });
 
-            const tree = new Formatter().format(borders);
+            const tree = new Formatter().format(properties);
 
-            expect(tree).to.deep.equal({
-                "w:tcBorders": [{ "w:top": { _attr: { "w:val": "dashDotStroked", "w:sz": 3, "w:color": "red" } } }],
+            expect(tree["w:tcPr"][0]).to.deep.equal({
+                "w:tcMar": [
+                    { "w:top": { _attr: { "w:type": "dxa", "w:w": 5 } } },
+                    { "w:left": { _attr: { "w:type": "dxa", "w:w": 10 } } },
+                    { "w:bottom": { _attr: { "w:type": "dxa", "w:w": 15 } } },
+                    { "w:right": { _attr: { "w:type": "dxa", "w:w": 20 } } },
+                ],
             });
         });
     });

package/src/file/table/table-cell/table-cell-properties.ts

@@ -1,72 +1,68 @@
+import { VerticalAlign, VerticalAlignElement } from "file/vertical-align";
 import { IgnoreIfEmptyXmlComponent } from "file/xml-components";
 
-import { ITableShadingAttributesProperties, TableShading } from "../shading";
-import { ITableCellMarginOptions, TableCellMargin } from "./cell-margin/table-cell-margins";
+import { IShadingAttributesProperties, Shading } from "../../shading";
+import { ITableCellMarginOptions, TableCellMargin, TableCellMarginElementType } from "../table-properties/table-cell-margin";
+import { ITableWidthProperties, TableWidthElement } from "../table-width";
 import {
     GridSpan,
+    ITableCellBorders,
     TableCellBorders,
-    TableCellWidth,
     TDirection,
     TextDirection,
-    VAlign,
-    VerticalAlign,
     VerticalMerge,
     VerticalMergeType,
-    WidthType,
 } from "./table-cell-components";
 
-export class TableCellProperties extends IgnoreIfEmptyXmlComponent {
-    private readonly cellBorder: TableCellBorders;
+export interface ITableCellPropertiesOptions {
+    readonly shading?: IShadingAttributesProperties;
+    readonly margins?: ITableCellMarginOptions;
+    readonly verticalAlign?: VerticalAlign;
+    readonly textDirection?: TextDirection;
+    readonly verticalMerge?: VerticalMergeType;
+    readonly width?: ITableWidthProperties;
+    readonly columnSpan?: number;
+    readonly rowSpan?: number;
+    readonly borders?: ITableCellBorders;
+}
 
-    constructor() {
+export class TableCellProperties extends IgnoreIfEmptyXmlComponent {
+    constructor(options: ITableCellPropertiesOptions) {
         super("w:tcPr");
-        this.cellBorder = new TableCellBorders();
-        this.root.push(this.cellBorder);
-    }
-
-    public get Borders(): TableCellBorders {
-        return this.cellBorder;
-    }
-
-    public addGridSpan(cellSpan: number): TableCellProperties {
-        this.root.push(new GridSpan(cellSpan));
-
-        return this;
-    }
 
-    public addVerticalMerge(type: VerticalMergeType): TableCellProperties {
-        this.root.push(new VerticalMerge(type));
+        if (options.width) {
+            this.root.push(new TableWidthElement("w:tcW", options.width));
+        }
 
-        return this;
-    }
-
-    public setVerticalAlign(type: VerticalAlign): TableCellProperties {
-        this.root.push(new VAlign(type));
+        if (options.columnSpan) {
+            this.root.push(new GridSpan(options.columnSpan));
+        }
 
-        return this;
-    }
+        if (options.verticalMerge) {
+            this.root.push(new VerticalMerge(options.verticalMerge));
+        } else if (options.rowSpan && options.rowSpan > 1) {
+            // if cell already have a `verticalMerge`, don't handle `rowSpan`
+            this.root.push(new VerticalMerge(VerticalMergeType.RESTART));
+        }
 
-    public setWidth(width: string | number, type: WidthType = WidthType.AUTO): TableCellProperties {
-        this.root.push(new TableCellWidth(width, type));
-
-        return this;
-    }
+        if (options.borders) {
+            this.root.push(new TableCellBorders(options.borders));
+        }
 
-    public setShading(attrs: ITableShadingAttributesProperties): TableCellProperties {
-        this.root.push(new TableShading(attrs));
+        if (options.shading) {
+            this.root.push(new Shading(options.shading));
+        }
 
-        return this;
-    }
-
-    public addMargins(options: ITableCellMarginOptions): TableCellProperties {
-        this.root.push(new TableCellMargin(options));
-
-        return this;
-    }
+        if (options.margins) {
+            this.root.push(new TableCellMargin(TableCellMarginElementType.TABLE_CELL, options.margins));
+        }
 
-    public setTextDirection(type: TextDirection): TableCellProperties {
-        this.root.push(new TDirection(type));
+        if (options.textDirection) {
+            this.root.push(new TDirection(options.textDirection));
+        }
 
-        return this;
+        if (options.verticalAlign) {
+            this.root.push(new VerticalAlignElement(options.verticalAlign));
+        }
     }
 }