docx 6.0.3 → 7.1.2

package/src/file/numbering/level.ts

@@ -1,7 +1,8 @@
 // http://officeopenxml.com/WPnumbering-numFmt.php
-import { Attributes, XmlAttributeComponent, XmlComponent } from "file/xml-components";
+import { decimalNumber } from "file/values";
+import { Attributes, NumberValueElement, XmlAttributeComponent, XmlComponent } from "file/xml-components";
 import { AlignmentType } from "../paragraph/formatting";
-import { IParagraphStylePropertiesOptions, ParagraphProperties } from "../paragraph/properties";
+import { ILevelParagraphStylePropertiesOptions, ParagraphProperties } from "../paragraph/properties";
 import { IRunStylePropertiesOptions, RunProperties } from "../paragraph/run/properties";
 
 export enum LevelFormat {
@@ -31,17 +32,10 @@ class LevelAttributes extends XmlAttributeComponent<{
     };
 }
 
-class Start extends XmlComponent {
-    constructor(value: number) {
-        super("w:start");
-        this.root.push(
-            new Attributes({
-                val: value,
-            }),
-        );
-    }
-}
-
+// <xsd:complexType name="CT_NumFmt">
+//     <xsd:attribute name="val" type="ST_NumberFormat" use="required"/>
+//     <xsd:attribute name="format" type="s:ST_String" use="optional"/>
+// </xsd:complexType>
 class NumberFormat extends XmlComponent {
     constructor(value: string) {
         super("w:numFmt");
@@ -53,6 +47,10 @@ class NumberFormat extends XmlComponent {
     }
 }
 
+// <xsd:complexType name="CT_LevelText">
+//     <xsd:attribute name="val" type="s:ST_String" use="optional"/>
+//     <xsd:attribute name="null" type="s:ST_OnOff" use="optional"/>
+// </xsd:complexType>
 class LevelText extends XmlComponent {
     constructor(value: string) {
         super("w:lvlText");
@@ -90,10 +88,20 @@ export interface ILevelsOptions {
     readonly suffix?: LevelSuffix;
     readonly style?: {
         readonly run?: IRunStylePropertiesOptions;
-        readonly paragraph?: IParagraphStylePropertiesOptions;
+        readonly paragraph?: ILevelParagraphStylePropertiesOptions;
     };
 }
 
+// <xsd:complexType name="CT_LevelSuffix">
+//     <xsd:attribute name="val" type="ST_LevelSuffix" use="required"/>
+// </xsd:complexType>
+//     <xsd:simpleType name="ST_LevelSuffix">
+//         <xsd:restriction base="xsd:string">
+//             <xsd:enumeration value="tab"/>
+//             <xsd:enumeration value="space"/>
+//             <xsd:enumeration value="nothing"/>
+//         </xsd:restriction>
+//     </xsd:simpleType>
 class Suffix extends XmlComponent {
     constructor(value: LevelSuffix) {
         super("w:suff");
@@ -105,39 +113,60 @@ class Suffix extends XmlComponent {
     }
 }
 
+// <xsd:complexType name="CT_Lvl">
+//     <xsd:sequence>
+//         <xsd:element name="start" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="numFmt" type="CT_NumFmt" minOccurs="0"/>
+//         <xsd:element name="lvlRestart" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="pStyle" type="CT_String" minOccurs="0"/>
+//         <xsd:element name="isLgl" type="CT_OnOff" minOccurs="0"/>
+//         <xsd:element name="suff" type="CT_LevelSuffix" minOccurs="0"/>
+//         <xsd:element name="lvlText" type="CT_LevelText" minOccurs="0"/>
+//         <xsd:element name="lvlPicBulletId" type="CT_DecimalNumber" minOccurs="0"/>
+//         <xsd:element name="legacy" type="CT_LvlLegacy" minOccurs="0"/>
+//         <xsd:element name="lvlJc" type="CT_Jc" minOccurs="0"/>
+//         <xsd:element name="pPr" type="CT_PPrGeneral" minOccurs="0"/>
+//         <xsd:element name="rPr" type="CT_RPr" minOccurs="0"/>
+//     </xsd:sequence>
+//     <xsd:attribute name="ilvl" type="ST_DecimalNumber" use="required"/>
+//     <xsd:attribute name="tplc" type="ST_LongHexNumber" use="optional"/>
+//     <xsd:attribute name="tentative" type="s:ST_OnOff" use="optional"/>
+// </xsd:complexType>
 export class LevelBase extends XmlComponent {
     private readonly paragraphProperties: ParagraphProperties;
     private readonly runProperties: RunProperties;
 
     constructor({ level, format, text, alignment = AlignmentType.START, start = 1, style, suffix }: ILevelsOptions) {
         super("w:lvl");
-        this.root.push(
-            new LevelAttributes({
-                ilvl: level,
-                tentative: 1,
-            }),
-        );
 
-        this.root.push(new Start(start));
-        this.root.push(new LevelJc(alignment));
+        this.root.push(new NumberValueElement("w:start", decimalNumber(start)));
 
         if (format) {
             this.root.push(new NumberFormat(format));
         }
 
+        if (suffix) {
+            this.root.push(new Suffix(suffix));
+        }
+
         if (text) {
             this.root.push(new LevelText(text));
         }
 
+        this.root.push(new LevelJc(alignment));
+
         this.paragraphProperties = new ParagraphProperties(style && style.paragraph);
         this.runProperties = new RunProperties(style && style.run);
 
         this.root.push(this.paragraphProperties);
         this.root.push(this.runProperties);
 
-        if (suffix) {
-            this.root.push(new Suffix(suffix));
-        }
+        this.root.push(
+            new LevelAttributes({
+                ilvl: decimalNumber(level),
+                tentative: 1,
+            }),
+        );
     }
 }
 

package/src/file/numbering/multi-level-type.ts

@@ -1,5 +1,19 @@
 import { Attributes, XmlComponent } from "file/xml-components";
 
+// <xsd:complexType name="CT_AbstractNum">
+//     ...
+//     <xsd:element name="multiLevelType" type="CT_MultiLevelType" minOccurs="0"/>
+
+//         <xsd:complexType name="CT_MultiLevelType">
+//             <xsd:attribute name="val" type="ST_MultiLevelType" use="required"/>
+//         </xsd:complexType>
+//             <xsd:simpleType name="ST_MultiLevelType">
+//                 <xsd:restriction base="xsd:string">
+//                     <xsd:enumeration value="singleLevel"/>
+//                     <xsd:enumeration value="multilevel"/>
+//                     <xsd:enumeration value="hybridMultilevel"/>
+//                 </xsd:restriction>
+//             </xsd:simpleType>
 export class MultiLevelType extends XmlComponent {
     constructor(value: string) {
         super("w:multiLevelType");

package/src/file/numbering/num.ts

@@ -1,3 +1,4 @@
+import { decimalNumber } from "file/values";
 import { Attributes, XmlAttributeComponent, XmlComponent } from "file/xml-components";
 
 class AbstractNumId extends XmlComponent {
@@ -28,6 +29,17 @@ export interface IConcreteNumberingOptions {
     };
 }
 
+// <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;
@@ -42,11 +54,11 @@ export class ConcreteNumbering extends XmlComponent {
 
         this.root.push(
             new NumAttributes({
-                numId: options.numId,
+                numId: decimalNumber(options.numId),
             }),
         );
 
-        this.root.push(new AbstractNumId(options.abstractNumId));
+        this.root.push(new AbstractNumId(decimalNumber(options.abstractNumId)));
 
         if (options.overrideLevel) {
             this.root.push(new LevelOverride(options.overrideLevel.num, options.overrideLevel.start));

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

@@ -112,5 +112,26 @@ describe("Numbering", () => {
                 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

@@ -16,9 +16,20 @@ export interface INumberingOptions {
     }[];
 }
 
+// <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>();
 
     constructor(options: INumberingOptions) {
         super("w:numbering");
@@ -149,7 +160,7 @@ export class Numbering extends XmlComponent {
         this.concreteNumberingMap.set(
             "default-bullet-numbering",
             new ConcreteNumbering({
-                numId: 0,
+                numId: 1,
                 abstractNumId: abstractNumbering.id,
                 reference: "default-bullet-numbering",
                 instance: 0,
@@ -164,6 +175,7 @@ export class Numbering extends XmlComponent {
 
         for (const con of options.config) {
             this.abstractNumberingMap.set(con.reference, new AbstractNumbering(uniqueNumericId(), con.levels));
+            this.referenceConfigMap.set(con.reference, con.levels);
         }
     }
 
@@ -191,22 +203,33 @@ export class Numbering extends XmlComponent {
             return;
         }
 
-        this.concreteNumberingMap.set(
-            fullReference,
-            new ConcreteNumbering({
-                numId: uniqueNumericId(),
-                abstractNumId: abstractNumbering.id,
-                reference,
-                instance,
-                overrideLevel: {
-                    num: 0,
-                    start: 1,
-                },
-            }),
-        );
+        const concreteNumberingSettings = {
+            numId: uniqueNumericId(),
+            abstractNumId: abstractNumbering.id,
+            reference,
+            instance,
+            overrideLevel: {
+                num: 0,
+                start: 1,
+            },
+        };
+
+        const referenceConfigLevels = this.referenceConfigMap.get(reference);
+        const firstLevelStartNumber = referenceConfigLevels && referenceConfigLevels[0].start;
+        if (firstLevelStartNumber && Number.isInteger(firstLevelStartNumber)) {
+            concreteNumberingSettings.overrideLevel = {
+                num: 0,
+                start: firstLevelStartNumber,
+            };
+        }
+
+        this.concreteNumberingMap.set(fullReference, new ConcreteNumbering(concreteNumberingSettings));
     }
 
     public get ConcreteNumbering(): ConcreteNumbering[] {
         return Array.from(this.concreteNumberingMap.values());
     }
+    public get ReferenceConfig(): object[] {
+        return Array.from(this.referenceConfigMap.values());
+    }
 }

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

@@ -2,6 +2,7 @@ import { expect } from "chai";
 
 import { Formatter } from "export/formatter";
 
+import { BorderStyle } from "file/border";
 import { Border, ThematicBreak } from "./border";
 
 describe("Border", () => {
@@ -9,27 +10,27 @@ describe("Border", () => {
         it("should create", () => {
             const border = new Border({
                 top: {
-                    color: "red",
+                    color: "FF0000",
                     space: 1,
-                    value: "test",
+                    style: BorderStyle.WAVE,
                     size: 2,
                 },
                 bottom: {
-                    color: "red",
+                    color: "FF0000",
                     space: 3,
-                    value: "test",
+                    style: BorderStyle.WAVE,
                     size: 4,
                 },
                 left: {
-                    color: "red",
+                    color: "FF0000",
                     space: 5,
-                    value: "test",
+                    style: BorderStyle.WAVE,
                     size: 6,
                 },
                 right: {
-                    color: "red",
+                    color: "FF0000",
                     space: 7,
-                    value: "test",
+                    style: BorderStyle.WAVE,
                     size: 8,
                 },
             });
@@ -41,46 +42,51 @@ describe("Border", () => {
                     {
                         "w:top": {
                             _attr: {
-                                "w:color": "red",
+                                "w:color": "FF0000",
                                 "w:space": 1,
                                 "w:sz": 2,
-                                "w:val": "test",
+                                "w:val": "wave",
                             },
                         },
                     },
                     {
                         "w:bottom": {
                             _attr: {
-                                "w:color": "red",
+                                "w:color": "FF0000",
                                 "w:space": 3,
                                 "w:sz": 4,
-                                "w:val": "test",
+                                "w:val": "wave",
                             },
                         },
                     },
                     {
                         "w:left": {
                             _attr: {
-                                "w:color": "red",
+                                "w:color": "FF0000",
                                 "w:space": 5,
                                 "w:sz": 6,
-                                "w:val": "test",
+                                "w:val": "wave",
                             },
                         },
                     },
                     {
                         "w:right": {
                             _attr: {
-                                "w:color": "red",
+                                "w:color": "FF0000",
                                 "w:space": 7,
                                 "w:sz": 8,
-                                "w:val": "test",
+                                "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();
+        });
     });
 });
 

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

@@ -1,57 +1,32 @@
 // http://officeopenxml.com/WPborders.php
-import { XmlComponent } from "file/xml-components";
-import { BorderAttributes } from "./border-attributes";
-
-interface IBorderPropertyOptions {
-    readonly color: string;
-    readonly space: number;
-    readonly value: string;
-    readonly size: number;
-}
-
-export interface IBorderOptions {
-    readonly top?: IBorderPropertyOptions;
-    readonly bottom?: IBorderPropertyOptions;
-    readonly left?: IBorderPropertyOptions;
-    readonly right?: IBorderPropertyOptions;
-}
-
-class BorderProperty extends XmlComponent {
-    constructor(rootKey: string, options: IBorderPropertyOptions = { color: "auto", space: 1, value: "single", size: 6 }) {
-        super(rootKey);
-
-        const attrs = new BorderAttributes({
-            color: options.color,
-            space: options.space,
-            val: options.value,
-            sz: options.size,
-        });
-        this.root.push(attrs);
-    }
+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 XmlComponent {
-    constructor(options: IBorderOptions) {
+export class Border extends IgnoreIfEmptyXmlComponent {
+    constructor(options: IBordersOptions) {
         super("w:pBdr");
 
-        if (options.top !== undefined) {
-            const borderProperty = new BorderProperty("w:top", options.top);
-            this.root.push(borderProperty);
+        if (options.top) {
+            this.root.push(new BorderElement("w:top", options.top));
         }
 
-        if (options.bottom !== undefined) {
-            const borderProperty = new BorderProperty("w:bottom", options.bottom);
-            this.root.push(borderProperty);
+        if (options.bottom) {
+            this.root.push(new BorderElement("w:bottom", options.bottom));
         }
 
-        if (options.left !== undefined) {
-            const borderProperty = new BorderProperty("w:left", options.left);
-            this.root.push(borderProperty);
+        if (options.left) {
+            this.root.push(new BorderElement("w:left", options.left));
         }
 
-        if (options.right !== undefined) {
-            const borderProperty = new BorderProperty("w:right", options.right);
-            this.root.push(borderProperty);
+        if (options.right) {
+            this.root.push(new BorderElement("w:right", options.right));
         }
     }
 }
@@ -59,10 +34,10 @@ export class Border extends XmlComponent {
 export class ThematicBreak extends XmlComponent {
     constructor() {
         super("w:pBdr");
-        const bottom = new BorderProperty("w:bottom", {
+        const bottom = new BorderElement("w:bottom", {
             color: "auto",
             space: 1,
-            value: "single",
+            style: BorderStyle.SINGLE,
             size: 6,
         });
         this.root.push(bottom);

package/src/file/paragraph/formatting/{page-break.spec.ts → break.spec.ts}

@@ -2,7 +2,7 @@ import { expect } from "chai";
 
 import { Formatter } from "export/formatter";
 
-import { PageBreak, PageBreakBefore } from "./page-break";
+import { ColumnBreak, PageBreak, PageBreakBefore } from "./break";
 
 describe("PageBreak", () => {
     let pageBreak: PageBreak;
@@ -29,6 +29,31 @@ describe("PageBreak", () => {
     });
 });
 
+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();

package/src/file/paragraph/formatting/{page-break.ts → break.ts}

@@ -2,12 +2,18 @@
 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 {
-    constructor() {
+    constructor(type: BreakType) {
         super("w:br");
         this.root.push(
             new Attributes({
-                type: "page",
+                type,
             }),
         );
     }
@@ -16,7 +22,14 @@ class Break extends XmlComponent {
 export class PageBreak extends Run {
     constructor() {
         super({});
-        this.root.push(new Break());
+        this.root.push(new Break(BreakType.PAGE));
+    }
+}
+
+export class ColumnBreak extends Run {
+    constructor() {
+        super({});
+        this.root.push(new Break(BreakType.COLUMN));
     }
 }
 

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

@@ -1,29 +1,57 @@
 // http://officeopenxml.com/WPindentation.php
+import { signedTwipsMeasureValue, twipsMeasureValue } from "file/values";
 import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
 
 export interface IIndentAttributesProperties {
-    readonly left?: number;
-    readonly hanging?: number;
-    readonly firstLine?: number;
-    readonly start?: number;
-    readonly end?: number;
-    readonly right?: number;
+    readonly start?: number | string;
+    readonly end?: number | string;
+    readonly left?: number | string;
+    readonly right?: number | string;
+    readonly hanging?: number | string;
+    readonly firstLine?: number | string;
 }
 
+// <xsd:complexType name="CT_Ind">
+//     <xsd:attribute name="start" type="ST_SignedTwipsMeasure" use="optional"/>
+//     <xsd:attribute name="startChars" type="ST_DecimalNumber" use="optional"/>
+//     <xsd:attribute name="end" type="ST_SignedTwipsMeasure" use="optional"/>
+//     <xsd:attribute name="endChars" type="ST_DecimalNumber" use="optional"/>
+//     <xsd:attribute name="left" type="ST_SignedTwipsMeasure" use="optional"/>
+//     <xsd:attribute name="leftChars" type="ST_DecimalNumber" use="optional"/>
+//     <xsd:attribute name="right" type="ST_SignedTwipsMeasure" use="optional"/>
+//     <xsd:attribute name="rightChars" type="ST_DecimalNumber" use="optional"/>
+//     <xsd:attribute name="hanging" type="s:ST_TwipsMeasure" use="optional"/>
+//     <xsd:attribute name="hangingChars" type="ST_DecimalNumber" use="optional"/>
+//     <xsd:attribute name="firstLine" type="s:ST_TwipsMeasure" use="optional"/>
+//     <xsd:attribute name="firstLineChars" type="ST_DecimalNumber" use="optional"/>
+// </xsd:complexType>
 class IndentAttributes extends XmlAttributeComponent<IIndentAttributesProperties> {
     protected readonly xmlKeys = {
+        start: "w:start",
+        end: "w:end",
         left: "w:left",
+        right: "w:right",
         hanging: "w:hanging",
         firstLine: "w:firstLine",
-        start: "w:start",
-        end: "w:end",
-        right: "w:end", // alias
     };
 }
 
+// <xsd:complexType name="CT_PPrBase">
+// <xsd:sequence>
+//     ...
+//     <xsd:element name="ind" type="CT_Ind" minOccurs="0"/>
 export class Indent extends XmlComponent {
-    constructor(attrs: IIndentAttributesProperties) {
+    constructor({ start, end, left, right, hanging, firstLine }: IIndentAttributesProperties) {
         super("w:ind");
-        this.root.push(new IndentAttributes(attrs));
+        this.root.push(
+            new IndentAttributes({
+                start: start === undefined ? undefined : signedTwipsMeasureValue(start),
+                end: end === undefined ? undefined : signedTwipsMeasureValue(end),
+                left: left === undefined ? undefined : signedTwipsMeasureValue(left),
+                right: right === undefined ? undefined : signedTwipsMeasureValue(right),
+                hanging: hanging === undefined ? undefined : twipsMeasureValue(hanging),
+                firstLine: firstLine === undefined ? undefined : twipsMeasureValue(firstLine),
+            }),
+        );
     }
 }

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

@@ -1,8 +1,7 @@
 export * from "./alignment";
 export * from "./border";
 export * from "./indent";
-export * from "./keep";
-export * from "./page-break";
+export * from "./break";
 export * from "./spacing";
 export * from "./style";
 export * from "./tab-stop";