docx 8.0.0 → 8.0.1

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

@@ -1,91 +0,0 @@
-// http://officeopenxml.com/WPtableProperties.php
-//
-// <xsd:complexType name="CT_TblPrBase">
-//     <xsd:sequence>
-//         <xsd:element name="tblStyle" type="CT_String" minOccurs="0"/>
-//         <xsd:element name="tblpPr" type="CT_TblPPr" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblOverlap" type="CT_TblOverlap" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="bidiVisual" type="CT_OnOff" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblStyleRowBandSize" type="CT_DecimalNumber" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblStyleColBandSize" type="CT_DecimalNumber" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblW" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="jc" type="CT_JcTable" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblCellSpacing" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblInd" type="CT_TblWidth" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblBorders" type="CT_TblBorders" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="shd" type="CT_Shd" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblLayout" type="CT_TblLayoutType" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblCellMar" type="CT_TblCellMar" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblLook" type="CT_TblLook" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblCaption" type="CT_String" minOccurs="0" maxOccurs="1"/>
-//         <xsd:element name="tblDescription" type="CT_String" minOccurs="0" maxOccurs="1"/>
-//     </xsd:sequence>
-// </xsd:complexType>
-import { IgnoreIfEmptyXmlComponent, OnOffElement, StringValueElement } from "@file/xml-components";
-
-import { Alignment, AlignmentType } from "../../paragraph";
-import { IShadingAttributesProperties, Shading } from "../../shading";
-import { ITableWidthProperties, TableWidthElement } from "../table-width";
-import { ITableBordersOptions, TableBorders } from "./table-borders";
-import { ITableCellMarginOptions, TableCellMargin, TableCellMarginElementType } from "./table-cell-margin";
-import { ITableFloatOptions, TableFloatProperties } from "./table-float-properties";
-import { TableLayout, TableLayoutType } from "./table-layout";
-
-export interface ITablePropertiesOptions {
-    readonly width?: ITableWidthProperties;
-    readonly indent?: ITableWidthProperties;
-    readonly layout?: TableLayoutType;
-    readonly borders?: ITableBordersOptions;
-    readonly float?: ITableFloatOptions;
-    readonly shading?: IShadingAttributesProperties;
-    readonly style?: string;
-    readonly alignment?: AlignmentType;
-    readonly cellMargin?: ITableCellMarginOptions;
-    readonly visuallyRightToLeft?: boolean;
-}
-
-export class TableProperties extends IgnoreIfEmptyXmlComponent {
-    public constructor(options: ITablePropertiesOptions) {
-        super("w:tblPr");
-
-        if (options.style) {
-            this.root.push(new StringValueElement("w:tblStyle", options.style));
-        }
-
-        if (options.float) {
-            this.root.push(new TableFloatProperties(options.float));
-        }
-
-        if (options.visuallyRightToLeft !== undefined) {
-            this.root.push(new OnOffElement("w:bidiVisual", options.visuallyRightToLeft));
-        }
-
-        if (options.width) {
-            this.root.push(new TableWidthElement("w:tblW", options.width));
-        }
-
-        if (options.alignment) {
-            this.root.push(new Alignment(options.alignment));
-        }
-
-        if (options.indent) {
-            this.root.push(new TableWidthElement("w:tblInd", options.indent));
-        }
-
-        if (options.borders) {
-            this.root.push(new TableBorders(options.borders));
-        }
-
-        if (options.shading) {
-            this.root.push(new Shading(options.shading));
-        }
-
-        if (options.layout) {
-            this.root.push(new TableLayout(options.layout));
-        }
-
-        if (options.cellMargin) {
-            this.root.push(new TableCellMargin(TableCellMarginElementType.TABLE, options.cellMargin));
-        }
-    }
-}

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

@@ -1,3 +0,0 @@
-export * from "./table-row";
-export * from "./table-row-properties";
-export * from "./table-row-height";

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

@@ -1,43 +0,0 @@
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { PositiveUniversalMeasure, twipsMeasureValue } from "@util/values";
-
-// <xsd:complexType name="CT_Height">
-//     <xsd:attribute name="val" type="s:ST_TwipsMeasure"/>
-//     <xsd:attribute name="hRule" type="ST_HeightRule"/>
-// </xsd:complexType>
-
-// <xsd:simpleType name="ST_HeightRule">
-//     <xsd:restriction base="xsd:string">
-//         <xsd:enumeration value="auto"/>
-//         <xsd:enumeration value="exact"/>
-//         <xsd:enumeration value="atLeast"/>
-//     </xsd:restriction>
-// </xsd:simpleType>
-export enum HeightRule {
-    /** Height is determined based on the content, so value is ignored. */
-    AUTO = "auto",
-    /** At least the value specified */
-    ATLEAST = "atLeast",
-    /** Exactly the value specified */
-    EXACT = "exact",
-}
-
-export class TableRowHeightAttributes extends XmlAttributeComponent<{
-    readonly value: number | string;
-    readonly rule: HeightRule;
-}> {
-    protected readonly xmlKeys = { value: "w:val", rule: "w:hRule" };
-}
-
-export class TableRowHeight extends XmlComponent {
-    public constructor(value: number | PositiveUniversalMeasure, rule: HeightRule) {
-        super("w:trHeight");
-
-        this.root.push(
-            new TableRowHeightAttributes({
-                value: twipsMeasureValue(value),
-                rule: rule,
-            }),
-        );
-    }
-}

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

@@ -1,64 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { HeightRule } from "@file/table/table-row/table-row-height";
-
-import { TableRowProperties } from "./table-row-properties";
-
-describe("TableRowProperties", () => {
-    describe("#constructor", () => {
-        it("creates an initially empty property object", () => {
-            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");
-        });
-
-        it("sets cantSplit to avoid row been paginated", () => {
-            const rowProperties = new TableRowProperties({ cantSplit: true });
-            const tree = new Formatter().format(rowProperties);
-            expect(tree).to.deep.equal({ "w:trPr": [{ "w:cantSplit": {} }] });
-        });
-
-        it("sets row as table header (repeat row on each page of table)", () => {
-            const rowProperties = new TableRowProperties({ tableHeader: true });
-            const tree = new Formatter().format(rowProperties);
-            expect(tree).to.deep.equal({ "w:trPr": [{ "w:tblHeader": {} }] });
-        });
-
-        it("sets row height 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({
-                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({
-                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,60 +0,0 @@
-// http://officeopenxml.com/WPtableRowProperties.php
-
-// <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";
-import { PositiveUniversalMeasure } from "@util/values";
-
-import { HeightRule, TableRowHeight } from "./table-row-height";
-
-export interface ITableRowPropertiesOptions {
-    readonly cantSplit?: boolean;
-    readonly tableHeader?: boolean;
-    readonly height?: {
-        readonly value: number | PositiveUniversalMeasure;
-        readonly rule: HeightRule;
-    };
-}
-
-export class TableRowProperties extends IgnoreIfEmptyXmlComponent {
-    public constructor(options: ITableRowPropertiesOptions) {
-        super("w:trPr");
-
-        if (options.cantSplit !== undefined) {
-            this.root.push(new OnOffElement("w:cantSplit", options.cantSplit));
-        }
-
-        if (options.tableHeader !== undefined) {
-            this.root.push(new OnOffElement("w:tblHeader", options.tableHeader));
-        }
-
-        if (options.height) {
-            this.root.push(new TableRowHeight(options.height.value, options.height.rule));
-        }
-    }
-}

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

@@ -1,266 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Paragraph } from "@file/paragraph";
-import { HeightRule } from "@file/table/table-row/table-row-height";
-import { EMPTY_OBJECT } from "@file/xml-components";
-import { TableCell } from "../table-cell";
-import { TableRow } from "./table-row";
-
-describe("TableRow", () => {
-    describe("#constructor", () => {
-        it("should create with no cells", () => {
-            const tableRow = new TableRow({
-                children: [],
-            });
-            const tree = new Formatter().format(tableRow);
-            expect(tree).to.deep.equal({
-                "w:tr": EMPTY_OBJECT,
-            });
-        });
-
-        it("should create with one cell", () => {
-            const tableRow = new TableRow({
-                children: [
-                    new TableCell({
-                        children: [],
-                    }),
-                ],
-            });
-            const tree = new Formatter().format(tableRow);
-            expect(tree).to.deep.equal({
-                "w:tr": [
-                    {
-                        "w:tc": [
-                            {
-                                "w:p": EMPTY_OBJECT,
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("should create with cant split", () => {
-            const tableRow = new TableRow({
-                children: [],
-                cantSplit: true,
-            });
-            const tree = new Formatter().format(tableRow);
-            expect(tree).to.deep.equal({
-                "w:tr": [
-                    {
-                        "w:trPr": [
-                            {
-                                "w:cantSplit": {},
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("should create with table header", () => {
-            const tableRow = new TableRow({
-                children: [],
-                tableHeader: true,
-            });
-            const tree = new Formatter().format(tableRow);
-            expect(tree).to.deep.equal({
-                "w:tr": [
-                    {
-                        "w:trPr": [
-                            {
-                                "w:tblHeader": {},
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("should set row height", () => {
-            const tableRow = new TableRow({
-                children: [],
-                height: {
-                    value: 100,
-                    rule: HeightRule.EXACT,
-                },
-            });
-            const tree = new Formatter().format(tableRow);
-            expect(tree).to.deep.equal({
-                "w:tr": [
-                    {
-                        "w:trPr": [
-                            {
-                                "w:trHeight": {
-                                    _attr: {
-                                        "w:hRule": "exact",
-                                        "w:val": 100,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-
-    describe("#addCellToIndex", () => {
-        it("should add cell to correct index with no initial properties", () => {
-            const tableRow = new TableRow({
-                children: [
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                ],
-                tableHeader: true,
-            });
-
-            tableRow.addCellToIndex(
-                new TableCell({
-                    children: [],
-                }),
-                0,
-            );
-
-            const tree = new Formatter().format(tableRow);
-
-            expect(tree).to.deep.equal({
-                "w:tr": [
-                    {
-                        "w:trPr": [
-                            {
-                                "w:tblHeader": {},
-                            },
-                        ],
-                    },
-                    {
-                        "w:tc": [
-                            {
-                                "w:p": {},
-                            },
-                        ],
-                    },
-                    {
-                        "w:tc": [
-                            {
-                                "w:p": [
-                                    {
-                                        "w:r": [
-                                            {
-                                                "w:t": [
-                                                    {
-                                                        _attr: {
-                                                            "xml:space": "preserve",
-                                                        },
-                                                    },
-                                                    "test",
-                                                ],
-                                            },
-                                        ],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-
-    describe("#rootIndexToColumnIndex", () => {
-        it("should get the correct virtual column index by root index", () => {
-            const tableRow = new TableRow({
-                children: [
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                ],
-            });
-
-            expect(tableRow.rootIndexToColumnIndex(1)).to.equal(0);
-            expect(tableRow.rootIndexToColumnIndex(2)).to.equal(3);
-            expect(tableRow.rootIndexToColumnIndex(3)).to.equal(4);
-            expect(tableRow.rootIndexToColumnIndex(4)).to.equal(5);
-
-            expect(() => tableRow.rootIndexToColumnIndex(0)).to.throw(`cell 'rootIndex' should between 1 to 4`);
-            expect(() => tableRow.rootIndexToColumnIndex(5)).to.throw(`cell 'rootIndex' should between 1 to 4`);
-        });
-    });
-
-    describe("#columnIndexToRootIndex", () => {
-        it("should get the correct root index by virtual column index", () => {
-            const tableRow = new TableRow({
-                children: [
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                ],
-            });
-
-            expect(tableRow.columnIndexToRootIndex(0)).to.equal(1);
-            expect(tableRow.columnIndexToRootIndex(1)).to.equal(1);
-            expect(tableRow.columnIndexToRootIndex(2)).to.equal(1);
-
-            expect(tableRow.columnIndexToRootIndex(3)).to.equal(2);
-            expect(tableRow.columnIndexToRootIndex(4)).to.equal(3);
-
-            expect(tableRow.columnIndexToRootIndex(5)).to.equal(4);
-            expect(tableRow.columnIndexToRootIndex(6)).to.equal(4);
-            expect(tableRow.columnIndexToRootIndex(7)).to.equal(4);
-
-            expect(() => tableRow.columnIndexToRootIndex(-1)).to.throw(`cell 'columnIndex' should not less than zero`);
-            expect(() => tableRow.columnIndexToRootIndex(8)).to.throw(`cell 'columnIndex' should not great than 7`);
-        });
-
-        it("should allow end new cell index", () => {
-            const tableRow = new TableRow({
-                children: [
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                    }),
-                    new TableCell({
-                        children: [new Paragraph("test")],
-                        columnSpan: 3,
-                    }),
-                ],
-            });
-
-            expect(tableRow.columnIndexToRootIndex(8, true)).to.equal(5);
-            // for column 10, just place the new cell at the end of row
-            expect(tableRow.columnIndexToRootIndex(10, true)).to.equal(5);
-        });
-    });
-});

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

@@ -1,75 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { TableCell } from "../table-cell";
-import { ITableRowPropertiesOptions, TableRowProperties } from "./table-row-properties";
-
-export interface ITableRowOptions extends ITableRowPropertiesOptions {
-    readonly children: readonly TableCell[];
-}
-
-export class TableRow extends XmlComponent {
-    public constructor(private readonly options: ITableRowOptions) {
-        super("w:tr");
-        this.root.push(new TableRowProperties(options));
-
-        for (const child of options.children) {
-            this.root.push(child);
-        }
-    }
-
-    public get CellCount(): number {
-        return this.options.children.length;
-    }
-
-    public get cells(): readonly TableCell[] {
-        return this.root.filter((xmlComponent) => xmlComponent instanceof TableCell);
-    }
-
-    public addCellToIndex(cell: TableCell, index: number): void {
-        // Offset because properties is also in root.
-        this.root.splice(index + 1, 0, cell);
-    }
-
-    public addCellToColumnIndex(cell: TableCell, columnIndex: number): void {
-        const rootIndex = this.columnIndexToRootIndex(columnIndex, true);
-        this.addCellToIndex(cell, rootIndex - 1);
-    }
-
-    public rootIndexToColumnIndex(rootIndex: number): number {
-        // convert the root index to the virtual column index
-        if (rootIndex < 1 || rootIndex >= this.root.length) {
-            throw new Error(`cell 'rootIndex' should between 1 to ${this.root.length - 1}`);
-        }
-        let colIdx = 0;
-        // Offset because properties is also in root.
-        for (let rootIdx = 1; rootIdx < rootIndex; rootIdx++) {
-            const cell = this.root[rootIdx] as TableCell;
-            colIdx += cell.options.columnSpan || 1;
-        }
-        return colIdx;
-    }
-
-    public columnIndexToRootIndex(columnIndex: number, allowEndNewCell: boolean = false): number {
-        // convert the virtual column index to the root index
-        // `allowEndNewCell` for get index to inert new cell
-        if (columnIndex < 0) {
-            throw new Error(`cell 'columnIndex' should not less than zero`);
-        }
-        let colIdx = 0;
-        // Offset because properties is also in root.
-        let rootIdx = 1;
-        while (colIdx <= columnIndex) {
-            if (rootIdx >= this.root.length) {
-                if (allowEndNewCell) {
-                    // for inserting verticalMerge CONTINUE cell at end of row
-                    return this.root.length;
-                } else {
-                    throw new Error(`cell 'columnIndex' should not great than ${colIdx - 1}`);
-                }
-            }
-            const cell = this.root[rootIdx] as TableCell;
-            rootIdx += 1;
-            colIdx += (cell && cell.options.columnSpan) || 1;
-        }
-        return rootIdx - 1;
-    }
-}

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

@@ -1,49 +0,0 @@
-// http://officeopenxml.com/WPtableWidth.php
-import { NextAttributeComponent, XmlComponent } from "@file/xml-components";
-import { measurementOrPercentValue, Percentage, UniversalMeasure } from "@util/values";
-
-// <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 type ITableWidthProperties = {
-    readonly size: number | Percentage | UniversalMeasure;
-    readonly type?: WidthType;
-};
-
-export class TableWidthElement extends XmlComponent {
-    public 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 NextAttributeComponent<ITableWidthProperties>({
-                type: { key: "w:type", value: type },
-                size: { key: "w:w", value: measurementOrPercentValue(tableWidthValue) },
-            }),
-        );
-    }
-}