docx 7.8.2 → 8.0.1

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

@@ -1,499 +0,0 @@
-/* tslint:disable:no-unused-expression */
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { AlignmentType, Paragraph } from "../paragraph";
-import { Table } from "./table";
-import { RelativeHorizontalPosition, RelativeVerticalPosition, TableAnchorType } from "./table-properties";
-
-import { TableCell } from "./table-cell";
-import { TableLayoutType } from "./table-properties/table-layout";
-import { TableRow } from "./table-row";
-import { WidthType } from "./table-width";
-
-const BORDERS = {
-    "w:tblBorders": [
-        { "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" } } },
-    ],
-};
-
-const WIDTHS = {
-    "w:tblW": {
-        _attr: {
-            "w:type": "auto",
-            "w:w": 100,
-        },
-    },
-};
-
-// const f = {
-//     "w:tbl": [
-//         {
-//             "w:tblPr": [
-//                 {
-//                     "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 } } },
-//                     ],
-//                 },
-//                 {
-//                     "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:tblW": { _attr: { "w:type": "auto", "w:w": 100 } } },
-//                 {
-//                     "w:tblpPr": {
-//                         _attr: {
-//                             "w:horzAnchor": "margin",
-//                             "w:vertAnchor": "page",
-//                             "w:tblpX": 10,
-//                             "w:tblpXSpec": "center",
-//                             "w:tblpY": 20,
-//                             "w:tblpYSpec": "bottom",
-//                             "w:bottomFromText": 30,
-//                             "w:topFromText": 40,
-//                             "w:leftFromText": 50,
-//                             "w:rightFromText": 60,
-//                         },
-//                     },
-//                 },
-//             ],
-//         },
-//         { "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }] },
-//         { "w:tr": [{ "w:tc": [{ "w:p": EMPTY_OBJECT }] }] },
-//     ],
-// };
-
-describe("Table", () => {
-    describe("#constructor", () => {
-        it("creates a table with the correct number of rows and columns", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-            });
-            const tree = new Formatter().format(table);
-            const cell = {
-                "w:tc": [
-                    {
-                        "w:p": [
-                            {
-                                "w:r": [
-                                    {
-                                        "w:t": [
-                                            {
-                                                _attr: {
-                                                    "xml:space": "preserve",
-                                                },
-                                            },
-                                            "hello",
-                                        ],
-                                    },
-                                ],
-                            },
-                        ],
-                    },
-                ],
-            };
-            expect(tree).to.deep.equal({
-                "w:tbl": [
-                    { "w:tblPr": [WIDTHS, BORDERS] },
-                    {
-                        "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
-                    },
-                    { "w:tr": [cell, cell] },
-                    { "w:tr": [cell, cell] },
-                    { "w:tr": [cell, cell] },
-                ],
-            });
-        });
-
-        it("creates a table with the correct columnSpan and rowSpan", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                                columnSpan: 2,
-                            }),
-                        ],
-                    }),
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                                rowSpan: 2,
-                            }),
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-            });
-            const tree = new Formatter().format(table);
-            const cellP = { "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "hello"] }] }] };
-            expect(tree).to.deep.equal({
-                "w:tbl": [
-                    { "w:tblPr": [WIDTHS, BORDERS] },
-                    {
-                        "w:tblGrid": [{ "w:gridCol": { _attr: { "w:w": 100 } } }, { "w:gridCol": { _attr: { "w:w": 100 } } }],
-                    },
-                    {
-                        "w:tr": [
-                            {
-                                "w:tc": [{ "w:tcPr": [{ "w:gridSpan": { _attr: { "w:val": 2 } } }] }, cellP],
-                            },
-                        ],
-                    },
-                    {
-                        "w:tr": [
-                            {
-                                "w:tc": [{ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "restart" } } }] }, cellP],
-                            },
-                            { "w:tc": [cellP] },
-                        ],
-                    },
-                    {
-                        "w:tr": [
-                            {
-                                "w:tc": [{ "w:tcPr": [{ "w:vMerge": { _attr: { "w:val": "continue" } } }] }, { "w:p": {} }],
-                            },
-                            { "w:tc": [cellP] },
-                        ],
-                    },
-                ],
-            });
-        });
-
-        it("sets the table to fixed width layout", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-                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": [WIDTHS, BORDERS, { "w:tblLayout": { _attr: { "w:type": "fixed" } } }],
-            });
-        });
-
-        it("should center the table", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-                alignment: AlignmentType.CENTER,
-            });
-            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": [WIDTHS, { "w:jc": { _attr: { "w:val": "center" } } }, BORDERS],
-            });
-        });
-
-        it("should set the table to provided 100% width", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-                width: {
-                    size: 100,
-                    type: WidthType.PERCENTAGE,
-                },
-                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": "pct",
-                                "w:w": "100%",
-                            },
-                        },
-                    },
-                    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" } } },
-                ],
-            });
-        });
-    });
-
-    describe("Cell", () => {
-        describe("#prepForXml", () => {
-            it("inserts a paragraph at the end of the cell if it is empty", () => {
-                const table = new Table({
-                    rows: [
-                        new TableRow({
-                            children: [
-                                new TableCell({
-                                    children: [new Paragraph("hello")],
-                                }),
-                            ],
-                        }),
-                    ],
-                });
-                const tree = new Formatter().format(table);
-                expect(tree).to.have.property("w:tbl").which.is.an("array");
-                const row = tree["w:tbl"].find((x) => x["w:tr"]);
-                expect(row).not.to.be.undefined;
-                expect(row["w:tr"]).to.be.an("array").which.has.length.at.least(1);
-                expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
-                    "w:tc": [
-                        {
-                            "w:p": [
-                                {
-                                    "w:r": [
-                                        {
-                                            "w:t": [
-                                                {
-                                                    _attr: {
-                                                        "xml:space": "preserve",
-                                                    },
-                                                },
-                                                "hello",
-                                            ],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                });
-            });
-
-            // it("inserts a paragraph at the end of the cell even if it has a child table", () => {
-            //     const table = new Table({
-            //         rows: [
-            //             new TableRow({
-            //                 children: [
-            //                     new TableCell({
-            //                         children: [new Paragraph("hello")],
-            //                     }),
-            //                 ],
-            //             }),
-            //         ],
-            //     });
-            //     table.getCell(0, 0).add(
-            //         new Table({
-            //             rows: [
-            //                 new TableRow({
-            //                     children: [
-            //                         new TableCell({
-            //                             children: [new Paragraph("hello")],
-            //                         }),
-            //                     ],
-            //                 }),
-            //             ],
-            //         }),
-            //     );
-            //     const tree = new Formatter().format(table);
-            //     expect(tree)
-            //         .to.have.property("w:tbl")
-            //         .which.is.an("array");
-            //     const row = tree["w:tbl"].find((x) => x["w:tr"]);
-            //     expect(row).not.to.be.undefined;
-            //     expect(row["w:tr"])
-            //         .to.be.an("array")
-            //         .which.has.length.at.least(1);
-            //     const cell = row["w:tr"].find((x) => x["w:tc"]);
-            //     expect(cell).not.to.be.undefined;
-            //     expect(cell["w:tc"][cell["w:tc"].length - 1]).to.deep.equal({
-            //         "w:p": EMPTY_OBJECT,
-            //     });
-            // });
-
-            // it("does not insert a paragraph if it already ends with one", () => {
-            //     const table = new Table({
-            //         rows: [
-            //             new TableRow({
-            //                 children: [
-            //                     new TableCell({
-            //                         children: [new Paragraph("hello")],
-            //                     }),
-            //                 ],
-            //             }),
-            //         ],
-            //     });
-            //     table.getCell(0, 0).add(new Paragraph("Hello"));
-            //     const tree = new Formatter().format(table);
-            //     expect(tree)
-            //         .to.have.property("w:tbl")
-            //         .which.is.an("array");
-            //     const row = tree["w:tbl"].find((x) => x["w:tr"]);
-            //     expect(row).not.to.be.undefined;
-            //     expect(row["w:tr"])
-            //         .to.be.an("array")
-            //         .which.has.length.at.least(1);
-            //     expect(row["w:tr"].find((x) => x["w:tc"])).to.deep.equal({
-            //         "w:tc": [
-            //             {
-            //                 "w:p": [{ "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "Hello"] }] }],
-            //             },
-            //         ],
-            //     });
-            // });
-        });
-    });
-
-    describe("#float", () => {
-        it("sets the table float properties", () => {
-            const table = new Table({
-                rows: [
-                    new TableRow({
-                        children: [
-                            new TableCell({
-                                children: [new Paragraph("hello")],
-                            }),
-                        ],
-                    }),
-                ],
-                float: {
-                    horizontalAnchor: TableAnchorType.MARGIN,
-                    verticalAnchor: TableAnchorType.PAGE,
-                    absoluteHorizontalPosition: 10,
-                    relativeHorizontalPosition: RelativeHorizontalPosition.CENTER,
-                    absoluteVerticalPosition: 20,
-                    relativeVerticalPosition: RelativeVerticalPosition.BOTTOM,
-                    bottomFromText: 30,
-                    topFromText: 40,
-                    leftFromText: 50,
-                    rightFromText: 60,
-                },
-            });
-            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:tblpPr": {
-                            _attr: {
-                                "w:horzAnchor": "margin",
-                                "w:vertAnchor": "page",
-                                "w:tblpX": 10,
-                                "w:tblpXSpec": "center",
-                                "w:tblpY": 20,
-                                "w:tblpYSpec": "bottom",
-                                "w:bottomFromText": 30,
-                                "w:topFromText": 40,
-                                "w:leftFromText": 50,
-                                "w:rightFromText": 60,
-                            },
-                        },
-                    },
-                    WIDTHS,
-                    BORDERS,
-                ],
-            });
-        });
-    });
-});

package/src/file/table/table.ts

@@ -1,98 +0,0 @@
-// http://officeopenxml.com/WPtableGrid.php
-import { XmlComponent } from "@file/xml-components";
-
-import { AlignmentType } from "../paragraph";
-import { TableGrid } from "./grid";
-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
-    to give them some value. A reasonable default would be
-    ~6in / numCols, but if we do that it becomes very hard
-    to resize the table using setWidth, unless the layout
-    algorithm is set to 'fixed'. Instead, the approach here
-    means even in 'auto' layout, setting a width on the
-    table will make it look reasonable, as the layout
-    algorithm will expand columns to fit its content
- */
-export interface ITableOptions {
-    readonly rows: readonly TableRow[];
-    readonly width?: ITableWidthProperties;
-    readonly columnWidths?: readonly number[];
-    readonly margins?: ITableCellMarginOptions;
-    readonly indent?: ITableWidthProperties;
-    readonly float?: ITableFloatOptions;
-    readonly layout?: TableLayoutType;
-    readonly style?: string;
-    readonly borders?: ITableBordersOptions;
-    readonly alignment?: AlignmentType;
-    readonly visuallyRightToLeft?: boolean;
-}
-
-export class Table extends XmlComponent {
-    public constructor({
-        rows,
-        width,
-        // eslint-disable-next-line functional/immutable-data
-        columnWidths = Array<number>(Math.max(...rows.map((row) => row.CellCount))).fill(100),
-        margins,
-        indent,
-        float,
-        layout,
-        style,
-        borders,
-        alignment,
-        visuallyRightToLeft,
-    }: ITableOptions) {
-        super("w:tbl");
-
-        this.root.push(
-            new TableProperties({
-                borders: borders ?? {},
-                width: width ?? { size: 100 },
-                indent,
-                float,
-                layout,
-                style,
-                alignment,
-                cellMargin: margins,
-                visuallyRightToLeft,
-            }),
-        );
-
-        this.root.push(new TableGrid(columnWidths));
-
-        for (const row of rows) {
-            this.root.push(row);
-        }
-
-        rows.forEach((row, rowIndex) => {
-            if (rowIndex === rows.length - 1) {
-                // don't process the end row
-                return;
-            }
-            let columnIndex = 0;
-            row.cells.forEach((cell) => {
-                // Row Span has to be added in this method and not the constructor because it needs to know information about the column which happens after Table Cell construction
-                // Row Span of 1 will crash word as it will add RESTART and not a corresponding CONTINUE
-                if (cell.options.rowSpan && cell.options.rowSpan > 1) {
-                    const continueCell = new TableCell({
-                        // the inserted CONTINUE cell has rowSpan, and will be handled when process the next row
-                        rowSpan: cell.options.rowSpan - 1,
-                        columnSpan: cell.options.columnSpan,
-                        borders: cell.options.borders,
-                        children: [],
-                        verticalMerge: VerticalMergeType.CONTINUE,
-                    });
-                    rows[rowIndex + 1].addCellToColumnIndex(continueCell, columnIndex);
-                }
-                columnIndex += cell.options.columnSpan || 1;
-            });
-        });
-    }
-}

package/src/file/table-of-contents/field-instruction.ts

@@ -1,70 +0,0 @@
-// http://officeopenxml.com/WPfieldInstructions.php
-import { TextAttributes } from "@file/paragraph/run/text-attributes";
-import { SpaceType } from "@file/shared";
-import { XmlComponent } from "@file/xml-components";
-
-import { ITableOfContentsOptions } from "./table-of-contents-properties";
-
-export class FieldInstruction extends XmlComponent {
-    private readonly properties: ITableOfContentsOptions;
-
-    public constructor(properties: ITableOfContentsOptions = {}) {
-        super("w:instrText");
-
-        this.properties = properties;
-
-        this.root.push(new TextAttributes({ space: SpaceType.PRESERVE }));
-        let instruction = "TOC";
-
-        if (this.properties.captionLabel) {
-            instruction = `${instruction} \\a "${this.properties.captionLabel}"`;
-        }
-        if (this.properties.entriesFromBookmark) {
-            instruction = `${instruction} \\b "${this.properties.entriesFromBookmark}"`;
-        }
-        if (this.properties.captionLabelIncludingNumbers) {
-            instruction = `${instruction} \\c "${this.properties.captionLabelIncludingNumbers}"`;
-        }
-        if (this.properties.sequenceAndPageNumbersSeparator) {
-            instruction = `${instruction} \\d "${this.properties.sequenceAndPageNumbersSeparator}"`;
-        }
-        if (this.properties.tcFieldIdentifier) {
-            instruction = `${instruction} \\f "${this.properties.tcFieldIdentifier}"`;
-        }
-        if (this.properties.hyperlink) {
-            instruction = `${instruction} \\h`;
-        }
-        if (this.properties.tcFieldLevelRange) {
-            instruction = `${instruction} \\l "${this.properties.tcFieldLevelRange}"`;
-        }
-        if (this.properties.pageNumbersEntryLevelsRange) {
-            instruction = `${instruction} \\n "${this.properties.pageNumbersEntryLevelsRange}"`;
-        }
-        if (this.properties.headingStyleRange) {
-            instruction = `${instruction} \\o "${this.properties.headingStyleRange}"`;
-        }
-        if (this.properties.entryAndPageNumberSeparator) {
-            instruction = `${instruction} \\p "${this.properties.entryAndPageNumberSeparator}"`;
-        }
-        if (this.properties.seqFieldIdentifierForPrefix) {
-            instruction = `${instruction} \\s "${this.properties.seqFieldIdentifierForPrefix}"`;
-        }
-        if (this.properties.stylesWithLevels && this.properties.stylesWithLevels.length) {
-            const styles = this.properties.stylesWithLevels.map((sl) => `${sl.styleName},${sl.level}`).join(",");
-            instruction = `${instruction} \\t "${styles}"`;
-        }
-        if (this.properties.useAppliedParagraphOutlineLevel) {
-            instruction = `${instruction} \\u`;
-        }
-        if (this.properties.preserveTabInEntries) {
-            instruction = `${instruction} \\w`;
-        }
-        if (this.properties.preserveNewLineInEntries) {
-            instruction = `${instruction} \\x`;
-        }
-        if (this.properties.hideTabAndPageNumbersInWebView) {
-            instruction = `${instruction} \\z`;
-        }
-        this.root.push(instruction);
-    }
-}

package/src/file/table-of-contents/index.ts

@@ -1,2 +0,0 @@
-export * from "./table-of-contents";
-export * from "./table-of-contents-properties";

package/src/file/table-of-contents/sdt-content.ts

@@ -1,7 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-
-export class StructuredDocumentTagContent extends XmlComponent {
-    public constructor() {
-        super("w:sdtContent");
-    }
-}