docx 8.0.0 → 8.0.1

package/src/file/numbering/numbering.ts

@@ -1,237 +0,0 @@
-// http://officeopenxml.com/WPnumbering.php
-// https://stackoverflow.com/questions/58622437/purpose-of-abstractnum-and-numberinginstance
-import { AlignmentType } from "@file/paragraph";
-import { IContext, IXmlableObject, XmlComponent } from "@file/xml-components";
-import { convertInchesToTwip, uniqueNumericId } from "@util/convenience-functions";
-
-import { DocumentAttributes } from "../document/document-attributes";
-import { AbstractNumbering } from "./abstract-numbering";
-import { ILevelsOptions, LevelFormat } from "./level";
-import { ConcreteNumbering } from "./num";
-
-export interface INumberingOptions {
-    readonly config: readonly {
-        readonly levels: readonly ILevelsOptions[];
-        readonly reference: string;
-    }[];
-}
-
-// <xsd:element name="numbering" type="CT_Numbering"/>
-//
-//     <xsd:complexType name="CT_Numbering">
-//         <xsd:sequence>
-//             <xsd:element name="numPicBullet" type="CT_NumPicBullet" minOccurs="0" maxOccurs="unbounded"/>
-//             <xsd:element name="abstractNum" type="CT_AbstractNum" minOccurs="0" maxOccurs="unbounded"/>
-//             <xsd:element name="num" type="CT_Num" minOccurs="0" maxOccurs="unbounded"/>
-//             <xsd:element name="numIdMacAtCleanup" type="CT_DecimalNumber" minOccurs="0"/>
-//         </xsd:sequence>
-//     </xsd:complexType>
-export class Numbering extends XmlComponent {
-    private readonly abstractNumberingMap = new Map<string, AbstractNumbering>();
-    private readonly concreteNumberingMap = new Map<string, ConcreteNumbering>();
-    private readonly referenceConfigMap = new Map<string, object>();
-
-    public constructor(options: INumberingOptions) {
-        super("w:numbering");
-        this.root.push(
-            new DocumentAttributes({
-                wpc: "http://schemas.microsoft.com/office/word/2010/wordprocessingCanvas",
-                mc: "http://schemas.openxmlformats.org/markup-compatibility/2006",
-                o: "urn:schemas-microsoft-com:office:office",
-                r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships",
-                m: "http://schemas.openxmlformats.org/officeDocument/2006/math",
-                v: "urn:schemas-microsoft-com:vml",
-                wp14: "http://schemas.microsoft.com/office/word/2010/wordprocessingDrawing",
-                wp: "http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing",
-                w10: "urn:schemas-microsoft-com:office:word",
-                w: "http://schemas.openxmlformats.org/wordprocessingml/2006/main",
-                w14: "http://schemas.microsoft.com/office/word/2010/wordml",
-                w15: "http://schemas.microsoft.com/office/word/2012/wordml",
-                wpg: "http://schemas.microsoft.com/office/word/2010/wordprocessingGroup",
-                wpi: "http://schemas.microsoft.com/office/word/2010/wordprocessingInk",
-                wne: "http://schemas.microsoft.com/office/word/2006/wordml",
-                wps: "http://schemas.microsoft.com/office/word/2010/wordprocessingShape",
-                Ignorable: "w14 w15 wp14",
-            }),
-        );
-
-        const abstractNumbering = new AbstractNumbering(uniqueNumericId(), [
-            {
-                level: 0,
-                format: LevelFormat.BULLET,
-                text: "\u25CF",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: convertInchesToTwip(0.5), hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 1,
-                format: LevelFormat.BULLET,
-                text: "\u25CB",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: convertInchesToTwip(1), hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 2,
-                format: LevelFormat.BULLET,
-                text: "\u25A0",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 2160, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 3,
-                format: LevelFormat.BULLET,
-                text: "\u25CF",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 2880, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 4,
-                format: LevelFormat.BULLET,
-                text: "\u25CB",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 3600, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 5,
-                format: LevelFormat.BULLET,
-                text: "\u25A0",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 4320, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 6,
-                format: LevelFormat.BULLET,
-                text: "\u25CF",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 5040, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 7,
-                format: LevelFormat.BULLET,
-                text: "\u25CF",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 5760, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-            {
-                level: 8,
-                format: LevelFormat.BULLET,
-                text: "\u25CF",
-                alignment: AlignmentType.LEFT,
-                style: {
-                    paragraph: {
-                        indent: { left: 6480, hanging: convertInchesToTwip(0.25) },
-                    },
-                },
-            },
-        ]);
-
-        this.concreteNumberingMap.set(
-            "default-bullet-numbering",
-            new ConcreteNumbering({
-                numId: 1,
-                abstractNumId: abstractNumbering.id,
-                reference: "default-bullet-numbering",
-                instance: 0,
-                overrideLevels: [
-                    {
-                        num: 0,
-                        start: 1,
-                    },
-                ],
-            }),
-        );
-
-        this.abstractNumberingMap.set("default-bullet-numbering", abstractNumbering);
-
-        for (const con of options.config) {
-            this.abstractNumberingMap.set(con.reference, new AbstractNumbering(uniqueNumericId(), con.levels));
-            this.referenceConfigMap.set(con.reference, con.levels);
-        }
-    }
-
-    public prepForXml(context: IContext): IXmlableObject | undefined {
-        for (const numbering of this.abstractNumberingMap.values()) {
-            this.root.push(numbering);
-        }
-
-        for (const numbering of this.concreteNumberingMap.values()) {
-            this.root.push(numbering);
-        }
-        return super.prepForXml(context);
-    }
-
-    public createConcreteNumberingInstance(reference: string, instance: number): void {
-        const abstractNumbering = this.abstractNumberingMap.get(reference);
-
-        if (!abstractNumbering) {
-            return;
-        }
-
-        const fullReference = `${reference}-${instance}`;
-
-        if (this.concreteNumberingMap.has(fullReference)) {
-            return;
-        }
-
-        const referenceConfigLevels = this.referenceConfigMap.get(reference);
-        const firstLevelStartNumber = referenceConfigLevels && referenceConfigLevels[0].start;
-
-        const concreteNumberingSettings = {
-            numId: uniqueNumericId(),
-            abstractNumId: abstractNumbering.id,
-            reference,
-            instance,
-            overrideLevel:
-                firstLevelStartNumber && Number.isInteger(firstLevelStartNumber)
-                    ? {
-                          num: 0,
-                          start: firstLevelStartNumber,
-                      }
-                    : {
-                          num: 0,
-                          start: 1,
-                      },
-        };
-
-        this.concreteNumberingMap.set(fullReference, new ConcreteNumbering(concreteNumberingSettings));
-    }
-
-    public get ConcreteNumbering(): readonly ConcreteNumbering[] {
-        return Array.from(this.concreteNumberingMap.values());
-    }
-    public get ReferenceConfig(): readonly object[] {
-        return Array.from(this.referenceConfigMap.values());
-    }
-}

package/src/file/paragraph/formatting/alignment.spec.ts

@@ -1,19 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { Alignment, AlignmentType } from "./alignment";
-
-describe("Alignment", () => {
-    it("should create", () => {
-        const alignment = new Alignment(AlignmentType.BOTH);
-        const tree = new Formatter().format(alignment);
-
-        expect(tree).to.deep.equal({
-            "w:jc": {
-                _attr: {
-                    "w:val": "both",
-                },
-            },
-        });
-    });
-});

package/src/file/paragraph/formatting/alignment.ts

@@ -1,60 +0,0 @@
-// http://officeopenxml.com/WPalignment.php
-// http://officeopenxml.com/WPtableAlignment.php
-// http://www.datypic.com/sc/ooxml/t-w_ST_Jc.html
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-
-// <xsd:simpleType name="ST_Jc">
-//     <xsd:restriction base="xsd:string">
-//         <xsd:enumeration value="start"/>
-//         <xsd:enumeration value="center"/>
-//         <xsd:enumeration value="end"/>
-//         <xsd:enumeration value="both"/>
-//         <xsd:enumeration value="mediumKashida"/>
-//         <xsd:enumeration value="distribute"/>
-//         <xsd:enumeration value="numTab"/>
-//         <xsd:enumeration value="highKashida"/>
-//         <xsd:enumeration value="lowKashida"/>
-//         <xsd:enumeration value="thaiDistribute"/>
-//         <xsd:enumeration value="left"/>
-//         <xsd:enumeration value="right"/>
-//     </xsd:restriction>
-// </xsd:simpleType>
-export enum AlignmentType {
-    /** Align Start */
-    START = "start",
-    /** Align Center */
-    CENTER = "center",
-    /** End */
-    END = "end",
-    /** Justified */
-    BOTH = "both",
-    /** Medium Kashida Length */
-    MEDIUM_KASHIDA = "mediumKashida",
-    /** Distribute All Characters Equally */
-    DISTRIBUTE = "distribute",
-    /** Align to List Tab */
-    NUM_TAB = "numTab",
-    /** Widest Kashida Length */
-    HIGH_KASHIDA = "highKashida",
-    /** Low Kashida Length */
-    LOW_KASHIDA = "lowKashida",
-    /** Thai Language Justification */
-    THAI_DISTRIBUTE = "thaiDistribute",
-    /** Align Left */
-    LEFT = "left",
-    /** Align Right */
-    RIGHT = "right",
-    /** Justified */
-    JUSTIFIED = "both",
-}
-
-export class AlignmentAttributes extends XmlAttributeComponent<{ readonly val: AlignmentType }> {
-    protected readonly xmlKeys = { val: "w:val" };
-}
-
-export class Alignment extends XmlComponent {
-    public constructor(type: AlignmentType) {
-        super("w:jc");
-        this.root.push(new AlignmentAttributes({ val: type }));
-    }
-}

package/src/file/paragraph/formatting/border.spec.ts

@@ -1,119 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { BorderStyle } from "@file/border";
-import { Border, ThematicBreak } from "./border";
-
-describe("Border", () => {
-    describe("#constructor", () => {
-        it("should create", () => {
-            const border = new Border({
-                top: {
-                    color: "FF0000",
-                    space: 1,
-                    style: BorderStyle.WAVE,
-                    size: 2,
-                },
-                bottom: {
-                    color: "FF0000",
-                    space: 3,
-                    style: BorderStyle.WAVE,
-                    size: 4,
-                },
-                left: {
-                    color: "FF0000",
-                    space: 5,
-                    style: BorderStyle.WAVE,
-                    size: 6,
-                },
-                right: {
-                    color: "FF0000",
-                    space: 7,
-                    style: BorderStyle.WAVE,
-                    size: 8,
-                },
-            });
-
-            const tree = new Formatter().format(border);
-
-            expect(tree).to.deep.equal({
-                "w:pBdr": [
-                    {
-                        "w:top": {
-                            _attr: {
-                                "w:color": "FF0000",
-                                "w:space": 1,
-                                "w:sz": 2,
-                                "w:val": "wave",
-                            },
-                        },
-                    },
-                    {
-                        "w:bottom": {
-                            _attr: {
-                                "w:color": "FF0000",
-                                "w:space": 3,
-                                "w:sz": 4,
-                                "w:val": "wave",
-                            },
-                        },
-                    },
-                    {
-                        "w:left": {
-                            _attr: {
-                                "w:color": "FF0000",
-                                "w:space": 5,
-                                "w:sz": 6,
-                                "w:val": "wave",
-                            },
-                        },
-                    },
-                    {
-                        "w:right": {
-                            _attr: {
-                                "w:color": "FF0000",
-                                "w:space": 7,
-                                "w:sz": 8,
-                                "w:val": "wave",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-
-        it("should not add empty borders element if there are no borders defined", () => {
-            const tb = new Border({});
-            expect(() => new Formatter().format(tb)).to.throw();
-        });
-    });
-});
-
-describe("ThematicBreak", () => {
-    let thematicBreak: ThematicBreak;
-
-    beforeEach(() => {
-        thematicBreak = new ThematicBreak();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Thematic Break with correct border properties", () => {
-            const tree = new Formatter().format(thematicBreak);
-            expect(tree).to.deep.equal({
-                "w:pBdr": [
-                    {
-                        "w:bottom": {
-                            _attr: {
-                                "w:color": "auto",
-                                "w:space": 1,
-                                "w:sz": 6,
-                                "w:val": "single",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/formatting/border.ts

@@ -1,45 +0,0 @@
-// http://officeopenxml.com/WPborders.php
-import { BorderElement, BorderStyle, IBorderOptions } from "@file/border";
-import { IgnoreIfEmptyXmlComponent, XmlComponent } from "@file/xml-components";
-
-export interface IBordersOptions {
-    readonly top?: IBorderOptions;
-    readonly bottom?: IBorderOptions;
-    readonly left?: IBorderOptions;
-    readonly right?: IBorderOptions;
-}
-
-export class Border extends IgnoreIfEmptyXmlComponent {
-    public constructor(options: IBordersOptions) {
-        super("w:pBdr");
-
-        if (options.top) {
-            this.root.push(new BorderElement("w:top", options.top));
-        }
-
-        if (options.bottom) {
-            this.root.push(new BorderElement("w:bottom", options.bottom));
-        }
-
-        if (options.left) {
-            this.root.push(new BorderElement("w:left", options.left));
-        }
-
-        if (options.right) {
-            this.root.push(new BorderElement("w:right", options.right));
-        }
-    }
-}
-
-export class ThematicBreak extends XmlComponent {
-    public constructor() {
-        super("w:pBdr");
-        const bottom = new BorderElement("w:bottom", {
-            color: "auto",
-            space: 1,
-            style: BorderStyle.SINGLE,
-            size: 6,
-        });
-        this.root.push(bottom);
-    }
-}

package/src/file/paragraph/formatting/break.spec.ts

@@ -1,65 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { ColumnBreak, PageBreak, PageBreakBefore } from "./break";
-
-describe("PageBreak", () => {
-    let pageBreak: PageBreak;
-
-    beforeEach(() => {
-        pageBreak = new PageBreak();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Page Break with correct attributes", () => {
-            const tree = new Formatter().format(pageBreak);
-            expect(tree).to.deep.equal({
-                "w:r": [
-                    {
-                        "w:br": {
-                            _attr: {
-                                "w:type": "page",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});
-
-describe("ColumnBreak", () => {
-    let columnBreak: ColumnBreak;
-
-    beforeEach(() => {
-        columnBreak = new ColumnBreak();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Column Break with correct attributes", () => {
-            const tree = new Formatter().format(columnBreak);
-            expect(tree).to.deep.equal({
-                "w:r": [
-                    {
-                        "w:br": {
-                            _attr: {
-                                "w:type": "column",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});
-
-describe("PageBreakBefore", () => {
-    it("should create page break before", () => {
-        const pageBreakBefore = new PageBreakBefore();
-        const tree = new Formatter().format(pageBreakBefore);
-        expect(tree).to.deep.equal({
-            "w:pageBreakBefore": {},
-        });
-    });
-});

package/src/file/paragraph/formatting/break.ts

@@ -1,43 +0,0 @@
-// http://officeopenxml.com/WPtextSpecialContent-break.php
-import { Attributes, XmlComponent } from "@file/xml-components";
-import { Run } from "../run";
-
-enum BreakType {
-    COLUMN = "column",
-    PAGE = "page",
-    // textWrapping breaks are the default and already exposed via the "Run" class
-}
-
-class Break extends XmlComponent {
-    public constructor(type: BreakType) {
-        super("w:br");
-        this.root.push(
-            new Attributes({
-                type,
-            }),
-        );
-    }
-}
-
-export class PageBreak extends Run {
-    public constructor() {
-        super({});
-        this.root.push(new Break(BreakType.PAGE));
-    }
-}
-
-export class ColumnBreak extends Run {
-    public constructor() {
-        super({});
-        this.root.push(new Break(BreakType.COLUMN));
-    }
-}
-
-/**
- * Add page break before the paragraph if there is no one added before.
- */
-export class PageBreakBefore extends XmlComponent {
-    public constructor() {
-        super("w:pageBreakBefore");
-    }
-}

package/src/file/paragraph/formatting/indent.spec.ts

@@ -1,42 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Indent } from "./indent";
-
-describe("Indent", () => {
-    it("should create", () => {
-        const indent = new Indent({
-            start: 10,
-            end: 10,
-            left: 10,
-            right: 10,
-            hanging: 10,
-            firstLine: 10,
-        });
-        const tree = new Formatter().format(indent);
-        expect(tree).to.deep.equal({
-            "w:ind": {
-                _attr: {
-                    "w:start": 10,
-                    "w:end": 10,
-                    "w:firstLine": 10,
-                    "w:hanging": 10,
-                    "w:left": 10,
-                    "w:right": 10,
-                },
-            },
-        });
-    });
-
-    it("should create with no indent values", () => {
-        const indent = new Indent({});
-
-        const tree = new Formatter().format(indent);
-        expect(tree).to.deep.equal({
-            "w:ind": {
-                _attr: {},
-            },
-        });
-    });
-});