docx 7.8.2 → 8.0.1

package/src/file/numbering/num.ts

@@ -1,92 +0,0 @@
-import { Attributes, XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { decimalNumber } from "@util/values";
-
-class AbstractNumId extends XmlComponent {
-    public constructor(value: number) {
-        super("w:abstractNumId");
-        this.root.push(
-            new Attributes({
-                val: value,
-            }),
-        );
-    }
-}
-
-class NumAttributes extends XmlAttributeComponent<{
-    readonly numId: number;
-}> {
-    protected readonly xmlKeys = { numId: "w:numId" };
-}
-
-export interface IConcreteNumberingOptions {
-    readonly numId: number;
-    readonly abstractNumId: number;
-    readonly reference: string;
-    readonly instance: number;
-    readonly overrideLevel?: {
-        readonly num: number;
-        readonly start?: number;
-    };
-}
-
-// <xsd:complexType name="CT_Numbering">
-//     ...
-//     <xsd:element name="num" type="CT_Num" minOccurs="0" maxOccurs="unbounded"/>
-
-//         <xsd:complexType name="CT_Num">
-//             <xsd:sequence>
-//                 <xsd:element name="abstractNumId" type="CT_DecimalNumber" minOccurs="1"/>
-//                 <xsd:element name="lvlOverride" type="CT_NumLvl" minOccurs="0" maxOccurs="9"/>
-//             </xsd:sequence>
-//             <xsd:attribute name="numId" type="ST_DecimalNumber" use="required"/>
-//         </xsd:complexType>
-export class ConcreteNumbering extends XmlComponent {
-    public readonly numId: number;
-    public readonly reference: string;
-    public readonly instance: number;
-
-    public constructor(options: IConcreteNumberingOptions) {
-        super("w:num");
-
-        this.numId = options.numId;
-        this.reference = options.reference;
-        this.instance = options.instance;
-
-        this.root.push(
-            new NumAttributes({
-                numId: decimalNumber(options.numId),
-            }),
-        );
-
-        this.root.push(new AbstractNumId(decimalNumber(options.abstractNumId)));
-
-        if (options.overrideLevel) {
-            this.root.push(new LevelOverride(options.overrideLevel.num, options.overrideLevel.start));
-        }
-    }
-}
-
-class LevelOverrideAttributes extends XmlAttributeComponent<{ readonly ilvl: number }> {
-    protected readonly xmlKeys = { ilvl: "w:ilvl" };
-}
-
-export class LevelOverride extends XmlComponent {
-    public constructor(levelNum: number, start?: number) {
-        super("w:lvlOverride");
-        this.root.push(new LevelOverrideAttributes({ ilvl: levelNum }));
-        if (start !== undefined) {
-            this.root.push(new StartOverride(start));
-        }
-    }
-}
-
-class StartOverrideAttributes extends XmlAttributeComponent<{ readonly val: number }> {
-    protected readonly xmlKeys = { val: "w:val" };
-}
-
-class StartOverride extends XmlComponent {
-    public constructor(start: number) {
-        super("w:startOverride");
-        this.root.push(new StartOverrideAttributes({ val: start }));
-    }
-}

package/src/file/numbering/numbering.spec.ts

@@ -1,138 +0,0 @@
-import { expect } from "chai";
-import { SinonStub, stub } from "sinon";
-
-import { Formatter } from "@export/formatter";
-import * as convenienceFunctions from "@util/convenience-functions";
-
-import { Numbering } from "./numbering";
-
-describe("Numbering", () => {
-    before(() => {
-        stub(convenienceFunctions, "uniqueNumericId").callsFake(() => 0);
-    });
-
-    after(() => {
-        (convenienceFunctions.uniqueNumericId as SinonStub).restore();
-    });
-
-    describe("#constructor", () => {
-        it("creates a default numbering with one abstract and one concrete instance", () => {
-            const numbering = new Numbering({
-                config: [],
-            });
-
-            const tree = new Formatter().format(numbering);
-            expect(Object.keys(tree)).to.deep.equal(["w:numbering"]);
-            const abstractNums = tree["w:numbering"].filter((el) => el["w:abstractNum"]);
-            expect(abstractNums).to.have.lengthOf(1);
-            expect(abstractNums[0]["w:abstractNum"]).to.deep.include.members([
-                { _attr: { "w:abstractNumId": 0, "w15:restartNumberingAfterBreak": 0 } },
-                { "w:multiLevelType": { _attr: { "w:val": "hybridMultilevel" } } },
-            ]);
-
-            abstractNums
-                .filter((el) => el["w:lvl"])
-                .forEach((el, ix) => {
-                    expect(Object.keys(el)).to.have.lengthOf(1);
-                    expect(Object.keys(el["w:lvl"])).to.deep.equal(["_attr", "w:start", "w:lvlJc", "w:numFmt", "w:pPr", "w:rPr"]);
-                    expect(el["w:lvl"]).to.have.deep.members([
-                        { _attr: { "w:ilvl": ix, "w15:tentative": 1 } },
-                        { "w:start": [{ _attr: { "w:val": 1 } }] },
-                        { "w:lvlJc": [{ _attr: { "w:val": "left" } }] },
-                        { "w:numFmt": [{ _attr: { "w:val": "bullet" } }] },
-                    ]);
-                    // TODO
-                    // Once chai 4.0.0 lands and #644 is resolved, we can add the following to the test:
-                    // {"w:lvlText": {"_attr": {"w:val": "•"}}},
-                    // {"w:rPr": [{"w:rFonts": {"_attr": {"w:ascii": "Symbol", "w:cs": "Symbol", "w:eastAsia": "Symbol", "w:hAnsi": "Symbol", "w:hint": "default"}}}]},
-                    // {"w:pPr": [
-                    //            {"w:ind": [{"_attr": {"w:left": 720, "w:hanging": 360}}]}]},
-                });
-        });
-
-        describe("#createConcreteNumberingInstance", () => {
-            it("should create a concrete numbering instance", () => {
-                const numbering = new Numbering({
-                    config: [
-                        {
-                            reference: "test-reference",
-                            levels: [
-                                {
-                                    level: 0,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                expect(numbering.ConcreteNumbering).to.have.length(1);
-
-                numbering.createConcreteNumberingInstance("test-reference", 0);
-
-                expect(numbering.ConcreteNumbering).to.have.length(2);
-            });
-
-            it("should not create a concrete numbering instance if reference is invalid", () => {
-                const numbering = new Numbering({
-                    config: [
-                        {
-                            reference: "test-reference",
-                            levels: [
-                                {
-                                    level: 0,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                expect(numbering.ConcreteNumbering).to.have.length(1);
-
-                numbering.createConcreteNumberingInstance("invalid-reference", 0);
-
-                expect(numbering.ConcreteNumbering).to.have.length(1);
-            });
-
-            it("should not create a concrete numbering instance if one already exists", () => {
-                const numbering = new Numbering({
-                    config: [
-                        {
-                            reference: "test-reference",
-                            levels: [
-                                {
-                                    level: 0,
-                                },
-                            ],
-                        },
-                    ],
-                });
-
-                expect(numbering.ConcreteNumbering).to.have.length(1);
-
-                numbering.createConcreteNumberingInstance("test-reference", 0);
-                numbering.createConcreteNumberingInstance("test-reference", 0);
-
-                expect(numbering.ConcreteNumbering).to.have.length(2);
-            });
-        });
-        describe("#referenceConfigMap", () => {
-            it("should store level configs into referenceConfigMap", () => {
-                const numbering = new Numbering({
-                    config: [
-                        {
-                            reference: "test-reference",
-                            levels: [
-                                {
-                                    level: 0,
-                                    start: 10,
-                                },
-                            ],
-                        },
-                    ],
-                });
-                numbering.createConcreteNumberingInstance("test-reference", 0);
-                const referenceConfig = numbering.ReferenceConfig[0];
-                const zeroLevelConfig = referenceConfig[0];
-                expect(zeroLevelConfig.start).to.be.equal(10);
-            });
-        });
-    });
-});

package/src/file/numbering/numbering.ts

@@ -1,235 +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,
-                overrideLevel: {
-                    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",
-                            },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});