docx 6.0.3 → 7.1.2

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

@@ -6,49 +6,55 @@ import { TableRowProperties } from "./table-row-properties";
 describe("TableRowProperties", () => {
     describe("#constructor", () => {
         it("creates an initially empty property object", () => {
-            const rowProperties = new TableRowProperties();
+            const rowProperties = new TableRowProperties({});
             // The TableRowProperties 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(rowProperties)).to.throw("XMLComponent did not format correctly");
         });
-    });
 
-    describe("#setCantSplit", () => {
         it("sets cantSplit to avoid row been paginated", () => {
-            const rowProperties = new TableRowProperties();
-            rowProperties.setCantSplit();
+            const rowProperties = new TableRowProperties({ cantSplit: true });
             const tree = new Formatter().format(rowProperties);
-            expect(tree).to.deep.equal({ "w:trPr": [{ "w:cantSplit": { _attr: { "w:val": true } } }] });
+            expect(tree).to.deep.equal({ "w:trPr": [{ "w:cantSplit": {} }] });
         });
-    });
 
-    describe("#setTableHeader", () => {
         it("sets row as table header (repeat row on each page of table)", () => {
-            const rowProperties = new TableRowProperties();
-            rowProperties.setTableHeader();
+            const rowProperties = new TableRowProperties({ tableHeader: true });
             const tree = new Formatter().format(rowProperties);
-            expect(tree).to.deep.equal({ "w:trPr": [{ "w:tblHeader": { _attr: { "w:val": true } } }] });
+            expect(tree).to.deep.equal({ "w:trPr": [{ "w:tblHeader": {} }] });
         });
-    });
 
-    describe("#setHeight", () => {
         it("sets row height exact", () => {
-            const rowProperties = new TableRowProperties();
-            rowProperties.setHeight(100, HeightRule.EXACT);
+            const rowProperties = new TableRowProperties({
+                height: {
+                    value: 100,
+                    rule: HeightRule.EXACT,
+                },
+            });
             const tree = new Formatter().format(rowProperties);
             expect(tree).to.deep.equal({ "w:trPr": [{ "w:trHeight": { _attr: { "w:val": 100, "w:hRule": "exact" } } }] });
         });
+
         it("sets row height auto", () => {
-            const rowProperties = new TableRowProperties();
-            rowProperties.setHeight(100, HeightRule.AUTO);
+            const rowProperties = new TableRowProperties({
+                height: {
+                    value: 100,
+                    rule: HeightRule.AUTO,
+                },
+            });
             const tree = new Formatter().format(rowProperties);
             expect(tree).to.deep.equal({ "w:trPr": [{ "w:trHeight": { _attr: { "w:val": 100, "w:hRule": "auto" } } }] });
         });
+
         it("sets row height at least", () => {
-            const rowProperties = new TableRowProperties();
-            rowProperties.setHeight(100, HeightRule.ATLEAST);
+            const rowProperties = new TableRowProperties({
+                height: {
+                    value: 100,
+                    rule: HeightRule.ATLEAST,
+                },
+            });
             const tree = new Formatter().format(rowProperties);
             expect(tree).to.deep.equal({ "w:trPr": [{ "w:trHeight": { _attr: { "w:val": 100, "w:hRule": "atLeast" } } }] });
         });

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

@@ -1,50 +1,59 @@
 // http://officeopenxml.com/WPtableRowProperties.php
-import { IgnoreIfEmptyXmlComponent, XmlAttributeComponent, XmlComponent } from "file/xml-components";
 
-import { HeightRule, TableRowHeight } from "./table-row-height";
-
-export class TableRowProperties extends IgnoreIfEmptyXmlComponent {
-    constructor() {
-        super("w:trPr");
-    }
+// <xsd:complexType name="CT_TrPrBase">
+//     <xsd:choice maxOccurs="unbounded">
+//         <xsd:element name="cnfStyle" type="CT_Cnf" minOccurs="0" maxOccurs="1"/>
+//         <xsd:element name="divId" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="gridBefore" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="gridAfter" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="wBefore" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
+//         <xsd:element name="wAfter" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
+//         <xsd:element name="cantSplit" type="CT_OnOff" minOccurs="0"/>
+//         <xsd:element name="trHeight" type="CT_Height" minOccurs="0"/>
+//         <xsd:element name="tblHeader" type="CT_OnOff" minOccurs="0"/>
+//         <xsd:element name="tblCellSpacing" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
+//         <xsd:element name="jc" type="CT_JcTable" minOccurs="0" maxOccurs="1"/>
+//         <xsd:element name="hidden" type="CT_OnOff" minOccurs="0"/>
+//     </xsd:choice>
+// </xsd:complexType>
+// <xsd:complexType name="CT_TrPr">
+//     <xsd:complexContent>
+//         <xsd:extension base="CT_TrPrBase">
+//             <xsd:sequence>
+//                 <xsd:element name="ins" type="CT_TrackChange" minOccurs="0"/>
+//                 <xsd:element name="del" type="CT_TrackChange" minOccurs="0"/>
+//                 <xsd:element name="trPrChange" type="CT_TrPrChange" minOccurs="0"/>
+//             </xsd:sequence>
+//         </xsd:extension>
+//     </xsd:complexContent>
+// </xsd:complexType>
+import { IgnoreIfEmptyXmlComponent, OnOffElement } from "file/xml-components";
 
-    public setCantSplit(): TableRowProperties {
-        this.root.push(new CantSplit());
-
-        return this;
-    }
-
-    public setTableHeader(): TableRowProperties {
-        this.root.push(new TableHeader());
-
-        return this;
-    }
-
-    public setHeight(value: number, rule: HeightRule): TableRowProperties {
-        this.root.push(new TableRowHeight(value, rule));
+import { HeightRule, TableRowHeight } from "./table-row-height";
 
-        return this;
-    }
+export interface ITableRowPropertiesOptions {
+    readonly cantSplit?: boolean;
+    readonly tableHeader?: boolean;
+    readonly height?: {
+        readonly value: number | string;
+        readonly rule: HeightRule;
+    };
 }
 
-class CantSplitAttributes extends XmlAttributeComponent<{ readonly val: boolean }> {
-    protected readonly xmlKeys = { val: "w:val" };
-}
+export class TableRowProperties extends IgnoreIfEmptyXmlComponent {
+    constructor(options: ITableRowPropertiesOptions) {
+        super("w:trPr");
 
-export class CantSplit extends XmlComponent {
-    constructor() {
-        super("w:cantSplit");
-        this.root.push(new CantSplitAttributes({ val: true }));
-    }
-}
+        if (options.cantSplit !== undefined) {
+            this.root.push(new OnOffElement("w:cantSplit", options.cantSplit));
+        }
 
-class TableHeaderAttributes extends XmlAttributeComponent<{ readonly val: boolean }> {
-    protected readonly xmlKeys = { val: "w:val" };
-}
+        if (options.tableHeader !== undefined) {
+            this.root.push(new OnOffElement("w:tblHeader", options.tableHeader));
+        }
 
-export class TableHeader extends XmlComponent {
-    constructor() {
-        super("w:tblHeader");
-        this.root.push(new TableHeaderAttributes({ val: true }));
+        if (options.height) {
+            this.root.push(new TableRowHeight(options.height.value, options.height.rule));
+        }
     }
 }

package/src/file/table/table-row/table-row.spec.ts

@@ -53,11 +53,7 @@ describe("TableRow", () => {
                     {
                         "w:trPr": [
                             {
-                                "w:cantSplit": {
-                                    _attr: {
-                                        "w:val": true,
-                                    },
-                                },
+                                "w:cantSplit": {},
                             },
                         ],
                     },
@@ -76,11 +72,7 @@ describe("TableRow", () => {
                     {
                         "w:trPr": [
                             {
-                                "w:tblHeader": {
-                                    _attr: {
-                                        "w:val": true,
-                                    },
-                                },
+                                "w:tblHeader": {},
                             },
                         ],
                     },
@@ -141,11 +133,7 @@ describe("TableRow", () => {
                     {
                         "w:trPr": [
                             {
-                                "w:tblHeader": {
-                                    _attr: {
-                                        "w:val": true,
-                                    },
-                                },
+                                "w:tblHeader": {},
                             },
                         ],
                     },

package/src/file/table/table-row/table-row.ts

@@ -1,41 +1,19 @@
-import { HeightRule } from "file/table/table-row/table-row-height";
 import { XmlComponent } from "file/xml-components";
 import { TableCell } from "../table-cell";
-import { TableRowProperties } from "./table-row-properties";
+import { ITableRowPropertiesOptions, TableRowProperties } from "./table-row-properties";
 
-export interface ITableRowOptions {
-    readonly cantSplit?: boolean;
-    readonly tableHeader?: boolean;
-    readonly height?: {
-        readonly value: number;
-        readonly rule: HeightRule;
-    };
+export interface ITableRowOptions extends ITableRowPropertiesOptions {
     readonly children: TableCell[];
 }
 
 export class TableRow extends XmlComponent {
-    private readonly properties: TableRowProperties;
-
     constructor(private readonly options: ITableRowOptions) {
         super("w:tr");
-        this.properties = new TableRowProperties();
-        this.root.push(this.properties);
+        this.root.push(new TableRowProperties(options));
 
         for (const child of options.children) {
             this.root.push(child);
         }
-
-        if (options.cantSplit) {
-            this.properties.setCantSplit();
-        }
-
-        if (options.tableHeader) {
-            this.properties.setTableHeader();
-        }
-
-        if (options.height) {
-            this.properties.setHeight(options.height.value, options.height.rule);
-        }
     }
 
     public get CellCount(): number {

package/src/file/table/table-width.ts

@@ -0,0 +1,47 @@
+// http://officeopenxml.com/WPtableWidth.php
+import { measurementOrPercentValue } from "file/values";
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+// <xsd:simpleType name="ST_TblWidth">
+//   <xsd:restriction base="xsd:string">
+//     <xsd:enumeration value="nil"/>
+//     <xsd:enumeration value="pct"/>
+//     <xsd:enumeration value="dxa"/>
+//     <xsd:enumeration value="auto"/>
+//   </xsd:restriction>
+// </xsd:simpleType>
+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",
+}
+
+// <xsd:complexType name="CT_TblWidth">
+//     <xsd:attribute name="w" type="ST_MeasurementOrPercent"/>
+//     <xsd:attribute name="type" type="ST_TblWidth"/>
+// </xsd:complexType>
+export interface ITableWidthProperties {
+    readonly size: string | number;
+    readonly type?: WidthType;
+}
+
+class TableWidthAttributes extends XmlAttributeComponent<ITableWidthProperties> {
+    protected readonly xmlKeys = { type: "w:type", size: "w:w" };
+}
+
+export class TableWidthElement extends XmlComponent {
+    constructor(name: string, { type = WidthType.AUTO, size }: ITableWidthProperties) {
+        super(name);
+        // super("w:tblW");
+        let tableWidthValue = size;
+        if (type === WidthType.PERCENTAGE && typeof size === "number") {
+            tableWidthValue = `${size}%`;
+        }
+        this.root.push(new TableWidthAttributes({ type: type, size: measurementOrPercentValue(tableWidthValue) }));
+    }
+}

package/src/file/table/table.spec.ts

@@ -5,58 +5,21 @@ import { Formatter } from "export/formatter";
 
 import { AlignmentType, Paragraph } from "../paragraph";
 import { Table } from "./table";
-// import { WidthType } from "./table-cell";
 import { RelativeHorizontalPosition, RelativeVerticalPosition, TableAnchorType } from "./table-properties";
 
-import { TableCell, WidthType } from "./table-cell";
+import { TableCell } from "./table-cell";
 import { TableLayoutType } from "./table-properties/table-layout";
 import { TableRow } from "./table-row";
-
-const DEFAULT_TABLE_PROPERTIES = {
-    "w:tblCellMar": [
-        {
-            "w:bottom": {
-                _attr: {
-                    "w:type": "auto",
-                    "w:w": 0,
-                },
-            },
-        },
-        {
-            "w:top": {
-                _attr: {
-                    "w:type": "auto",
-                    "w:w": 0,
-                },
-            },
-        },
-        {
-            "w:left": {
-                _attr: {
-                    "w:type": "auto",
-                    "w:w": 0,
-                },
-            },
-        },
-        {
-            "w:right": {
-                _attr: {
-                    "w:type": "auto",
-                    "w:w": 0,
-                },
-            },
-        },
-    ],
-};
+import { WidthType } from "./table-width";
 
 const BORDERS = {
     "w:tblBorders": [
-        { "w:top": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
-        { "w:left": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
-        { "w:bottom": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
-        { "w:right": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
-        { "w:insideH": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
-        { "w:insideV": { _attr: { "w:val": "single", "w:sz": 4, "w:space": 0, "w:color": "auto" } } },
+        { "w:top": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
+        { "w:left": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
+        { "w:bottom": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
+        { "w:right": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
+        { "w:insideH": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
+        { "w:insideV": { _attr: { "w:val": "single", "w:sz": 4, "w:color": "auto" } } },
     ],
 };
 
@@ -177,7 +140,7 @@ describe("Table", () => {
             };
             expect(tree).to.deep.equal({
                 "w:tbl": [
-                    { "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] },
+                    { "w:tblPr": [WIDTHS, BORDERS] },
                     {
                         "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
                     },
@@ -223,7 +186,7 @@ describe("Table", () => {
             const cellP = { "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "hello"] }] }] };
             expect(tree).to.deep.equal({
                 "w:tbl": [
-                    { "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS] },
+                    { "w:tblPr": [WIDTHS, BORDERS] },
                     {
                         "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
                     },
@@ -270,7 +233,7 @@ describe("Table", () => {
             const tree = new Formatter().format(table);
             expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
             expect(tree["w:tbl"][0]).to.deep.equal({
-                "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS, { "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
+                "w:tblPr": [WIDTHS, BORDERS, { "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
             });
         });
 
@@ -290,11 +253,11 @@ describe("Table", () => {
             const tree = new Formatter().format(table);
             expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
             expect(tree["w:tbl"][0]).to.deep.equal({
-                "w:tblPr": [DEFAULT_TABLE_PROPERTIES, BORDERS, WIDTHS, { "w:jc": { _attr: { "w:val": "center" } } }],
+                "w:tblPr": [WIDTHS, { "w:jc": { _attr: { "w:val": "center" } } }, BORDERS],
             });
         });
 
-        it("should set the table to provided width", () => {
+        it("should set the table to provided 100% width", () => {
             const table = new Table({
                 rows: [
                     new TableRow({
@@ -315,8 +278,6 @@ describe("Table", () => {
             expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
             expect(tree["w:tbl"][0]).to.deep.equal({
                 "w:tblPr": [
-                    DEFAULT_TABLE_PROPERTIES,
-                    BORDERS,
                     {
                         "w:tblW": {
                             _attr: {
@@ -325,6 +286,42 @@ describe("Table", () => {
                             },
                         },
                     },
+                    BORDERS,
+                    { "w:tblLayout": { _attr: { "w:type": "fixed" } } },
+                ],
+            });
+        });
+
+        it("should set the table to provided 1000 DXA", () => {
+            const table = new Table({
+                rows: [
+                    new TableRow({
+                        children: [
+                            new TableCell({
+                                children: [new Paragraph("hello")],
+                            }),
+                        ],
+                    }),
+                ],
+                width: {
+                    size: 1000,
+                    type: WidthType.DXA,
+                },
+                layout: TableLayoutType.FIXED,
+            });
+            const tree = new Formatter().format(table);
+            expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
+            expect(tree["w:tbl"][0]).to.deep.equal({
+                "w:tblPr": [
+                    {
+                        "w:tblW": {
+                            _attr: {
+                                "w:type": "dxa",
+                                "w:w": 1000,
+                            },
+                        },
+                    },
+                    BORDERS,
                     { "w:tblLayout": { _attr: { "w:type": "fixed" } } },
                 ],
             });
@@ -477,9 +474,6 @@ describe("Table", () => {
             expect(tree).to.have.property("w:tbl").which.is.an("array").with.has.length.at.least(1);
             expect(tree["w:tbl"][0]).to.deep.equal({
                 "w:tblPr": [
-                    DEFAULT_TABLE_PROPERTIES,
-                    BORDERS,
-                    WIDTHS,
                     {
                         "w:tblpPr": {
                             _attr: {
@@ -496,6 +490,8 @@ describe("Table", () => {
                             },
                         },
                     },
+                    WIDTHS,
+                    BORDERS,
                 ],
             });
         });

package/src/file/table/table.ts

@@ -3,10 +3,12 @@ import { XmlComponent } from "file/xml-components";
 
 import { AlignmentType } from "../paragraph";
 import { TableGrid } from "./grid";
-import { TableCell, VerticalMergeType, WidthType } from "./table-cell";
+import { TableCell, VerticalMergeType } from "./table-cell";
 import { ITableBordersOptions, ITableFloatOptions, TableProperties } from "./table-properties";
+import { ITableCellMarginOptions } from "./table-properties/table-cell-margin";
 import { TableLayoutType } from "./table-properties/table-layout";
 import { TableRow } from "./table-row";
+import { ITableWidthProperties } from "./table-width";
 
 /*
     0-width columns don't get rendered correctly, so we need
@@ -20,18 +22,10 @@ import { TableRow } from "./table-row";
  */
 export interface ITableOptions {
     readonly rows: TableRow[];
-    readonly width?: {
-        readonly size: number;
-        readonly type?: WidthType;
-    };
+    readonly width?: ITableWidthProperties;
     readonly columnWidths?: number[];
-    readonly margins?: {
-        readonly marginUnitType?: WidthType;
-        readonly top?: number;
-        readonly bottom?: number;
-        readonly right?: number;
-        readonly left?: number;
-    };
+    readonly margins?: ITableCellMarginOptions;
+    readonly indent?: ITableWidthProperties;
     readonly float?: ITableFloatOptions;
     readonly layout?: TableLayoutType;
     readonly style?: string;
@@ -45,7 +39,8 @@ export class Table extends XmlComponent {
         rows,
         width,
         columnWidths = Array<number>(Math.max(...rows.map((row) => row.CellCount))).fill(100),
-        margins: { marginUnitType, top, bottom, right, left } = { marginUnitType: WidthType.AUTO, top: 0, bottom: 0, right: 0, left: 0 },
+        margins,
+        indent,
         float,
         layout,
         style,
@@ -59,28 +54,12 @@ export class Table extends XmlComponent {
             new TableProperties({
                 borders: borders ?? {},
                 width: width ?? { size: 100 },
+                indent,
                 float,
                 layout,
                 style,
                 alignment,
-                cellMargin: {
-                    bottom: {
-                        value: bottom || 0,
-                        type: marginUnitType,
-                    },
-                    top: {
-                        value: top || 0,
-                        type: marginUnitType,
-                    },
-                    left: {
-                        value: left || 0,
-                        type: marginUnitType,
-                    },
-                    right: {
-                        value: right || 0,
-                        type: marginUnitType,
-                    },
-                },
+                cellMargin: margins,
                 visuallyRightToLeft,
             }),
         );

package/src/file/track-revision/track-revision-components/deleted-text-run.spec.ts

@@ -54,18 +54,10 @@ describe("DeletedTextRun", () => {
                             {
                                 "w:rPr": [
                                     {
-                                        "w:b": {
-                                            _attr: {
-                                                "w:val": true,
-                                            },
-                                        },
+                                        "w:b": {},
                                     },
                                     {
-                                        "w:bCs": {
-                                            _attr: {
-                                                "w:val": true,
-                                            },
-                                        },
+                                        "w:bCs": {},
                                     },
                                 ],
                             },