Merge pull request #27 from felipeochoa/styles

More styles harmony

ts/numbering/level.ts

@@ -1,4 +1,6 @@
+import * as paragraph from "../docx/paragraph/formatting";
 import { ParagraphProperties } from "../docx/paragraph/properties";
+import * as formatting from "../docx/run/formatting";
 import { RunProperties } from "../docx/run/properties";
 import { Attributes, XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
 
@@ -86,4 +88,113 @@ export class Level extends XmlComponent {
         this.runProperties.push(property);
         return this;
     }
+
+    // ----------  Run formatting ---------------------- //
+
+    public size(twips: number): Level {
+        this.addRunProperty(new formatting.Size(twips));
+        return this;
+    }
+
+    public bold(): Level {
+        this.addRunProperty(new formatting.Bold());
+        return this;
+    }
+
+    public italics(): Level {
+        this.addRunProperty(new formatting.Italics());
+        return this;
+    }
+
+    public smallCaps(): Level {
+        this.addRunProperty(new formatting.SmallCaps());
+        return this;
+    }
+
+    public allCaps(): Level {
+        this.addRunProperty(new formatting.Caps());
+        return this;
+    }
+
+    public strike(): Level {
+        this.addRunProperty(new formatting.Strike());
+        return this;
+    }
+
+    public doubleStrike(): Level {
+        this.addRunProperty(new formatting.DoubleStrike());
+        return this;
+    }
+
+    public subScript(): Level {
+        this.addRunProperty(new formatting.SubScript());
+        return this;
+    }
+
+    public superScript(): Level {
+        this.addRunProperty(new formatting.SuperScript());
+        return this;
+    }
+
+    public underline(underlineType?: string, color?: string): Level {
+        this.addRunProperty(new formatting.Underline(underlineType, color));
+        return this;
+    }
+
+    public color(color: string): Level {
+        this.addRunProperty(new formatting.Color(color));
+        return this;
+    }
+
+    public font(fontName: string): Level {
+        this.addRunProperty(new formatting.RunFonts(fontName));
+        return this;
+    }
+
+    // --------------------- Paragraph formatting ------------------------ //
+
+    public center(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("center"));
+        return this;
+    }
+
+    public left(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("left"));
+        return this;
+    }
+
+    public right(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("right"));
+        return this;
+    }
+
+    public justified(): Level {
+        this.addParagraphProperty(new paragraph.Alignment("both"));
+        return this;
+    }
+
+    public thematicBreak(): Level {
+        this.addParagraphProperty(new paragraph.ThematicBreak());
+        return this;
+    }
+
+    public maxRightTabStop(): Level {
+        this.addParagraphProperty(new paragraph.MaxRightTabStop());
+        return this;
+    }
+
+    public leftTabStop(position: number): Level {
+        this.addParagraphProperty(new paragraph.LeftTabStop(position));
+        return this;
+    }
+
+    public indent(left: number, hanging?: number): Level {
+        this.addParagraphProperty(new paragraph.Indent(left, hanging));
+        return this;
+    }
+
+    public spacing(params: paragraph.ISpacingProperties): Level {
+        this.addParagraphProperty(new paragraph.Spacing(params));
+        return this;
+    };
 }

ts/tests/numberingTest.ts

@@ -105,5 +105,292 @@ describe("AbstractNumbering", () => {
             expect(tree["w:lvl"]).to.include({ "w:numFmt": [{ _attr: { "w:val": "lowerLetter" } }] });
             expect(tree["w:lvl"]).to.include({ "w:lvlText": [{ _attr: { "w:val": "%1)" } }] });
         });
+
+        describe("formatting methods: paragraph properties", () => {
+            it("#indent", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .indent(720);
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [{"w:ind": [{_attr: {"w:left": 720}}]}],
+                });
+            });
+
+            it("#spacing", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .spacing({before: 50, after: 150});
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:spacing": [{_attr: {"w:before": 50, "w:after": 150}}]},
+                    ],
+                });
+            });
+
+            it("#center", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerLetter", "%0.")
+                    .center();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                            {"w:jc": [{_attr: {"w:val": "center"}}]},
+                    ],
+                });
+            });
+
+            it("#left", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.", "left")
+                    .left();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:jc": [{_attr: {"w:val": "left"}}]},
+                    ],
+                });
+            });
+
+            it("#right", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .right();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                            {"w:jc": [{_attr: {"w:val": "right"}}]},
+                    ],
+                });
+            });
+
+            it("#justified", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .justified();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:jc": [{_attr: {"w:val": "both"}}]},
+                    ],
+                });
+            });
+
+            it("#thematicBreak", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .thematicBreak();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:pBdr": [{"w:bottom": [{_attr: {
+                            "w:color": "auto",
+                            "w:space": "1",
+                            "w:val": "single",
+                            "w:sz": "6",
+                        }}]}]},
+                    ],
+                });
+            });
+
+            it("#leftTabStop", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .leftTabStop(1200);
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:tabs": [
+                            {"w:tab": [{_attr: {"w:val": "left", "w:pos": 1200}}]},
+                        ]},
+                    ],
+                });
+            });
+
+            it("#maxRightTabStop", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .maxRightTabStop();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:pPr": [
+                        {"w:tabs": [
+                            {"w:tab": [{_attr: {"w:val": "right", "w:pos": 9026}}]},
+                        ]},
+                    ],
+                });
+            });
+        });
+
+        describe("formatting methods: run properties", () => {
+            it("#size", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .size(24);
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:sz": [{_attr: {"w:val": 24}}]},
+                    ],
+                });
+            });
+
+            it("#smallCaps", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .smallCaps();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:smallCaps": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#allCaps", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .allCaps();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:caps": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#strike", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .strike();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:strike": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#doubleStrike", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .doubleStrike();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:dstrike": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#subScript", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .subScript();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:vertAlign": [{_attr: {"w:val": "subscript"}}]},
+                    ],
+                });
+            });
+
+            it("#superScript", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .superScript();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:vertAlign": [{_attr: {"w:val": "superscript"}}]},
+                    ],
+                });
+            });
+
+            it("#font", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .font("Times");
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [{"w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}]}],
+                });
+            });
+
+            it("#bold", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .bold();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:b": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            it("#italics", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .italics();
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:i": [{_attr: {"w:val": true}}]},
+                    ],
+                });
+            });
+
+            describe("#underline", () => {
+                it("should set underline to 'single' if no arguments are given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline();
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "single"}}]},
+                        ],
+                    });
+                });
+
+                it("should set the style if given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline("double");
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "double"}}]},
+                        ],
+                    });
+                });
+
+                it("should set the style and color if given", () => {
+                    const abstractNumbering = new AbstractNumbering(1);
+                    const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                        .underline("double", "005599");
+                    const tree = new Formatter().format(level);
+                    expect(tree["w:lvl"]).to.include({
+                        "w:rPr": [
+                            {"w:u": [{_attr: {"w:val": "double", "w:color": "005599"}}]},
+                        ],
+                    });
+                });
+            });
+
+            it("#color", () => {
+                const abstractNumbering = new AbstractNumbering(1);
+                const level = abstractNumbering.createLevel(0, "lowerRoman", "%0.")
+                    .color("123456");
+                const tree = new Formatter().format(level);
+                expect(tree["w:lvl"]).to.include({
+                    "w:rPr": [
+                        {"w:color": [{_attr: {"w:val": "123456"}}]},
+                    ],
+                });
+            });
+        });
     });
 });