docx-js/ts/tests/stylesTest.ts

import { assert, expect } from "chai";
import { Formatter } from "../export/formatter";
import { Styles } from "../styles";
import { ParagraphStyle, Style } from "../styles/style";
import * as components from "../styles/style/components";

describe("Styles", () => {
    let styles: Styles;

    beforeEach(() => {
        styles = new Styles();
    });

    describe("#constructor()", () => {
        it("should create styles with correct rootKey", () => {
            const newJson = JSON.parse(JSON.stringify(styles));
            assert.equal(newJson.rootKey, "w:styles");
        });
    });

    describe("#createParagraphStyle", () => {
        it("should create a new paragraph style and push it onto this collection", () => {
            styles.createParagraphStyle("pStyleId");
            const tree = new Formatter().format(styles)["w:styles"].filter((x) => !x._attr);
            expect(tree).to.deep.equal([{
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "pStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": []},
                ],
            }]);
        });

        it("should set the paragraph name if given", () => {
            styles.createParagraphStyle("pStyleId", "Paragraph Style");
            const tree = new Formatter().format(styles)["w:styles"].filter((x) => !x._attr);
            expect(tree).to.deep.equal([{
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "pStyleId"}},
                    {"w:name": [{_attr: {"w:val": "Paragraph Style"}}]},
                    {"w:pPr": []},
                    {"w:rPr": []},
                ],
            }]);
        });
    });
});

describe("Style", () => {
    describe("#constructor()", () => {
        it("should set the given properties", () => {
            const style = new Style({
                type: "paragraph",
                styleId: "myStyleId",
                default: true,
            });
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId", "w:default": true}},
                ],
            });
        });

        it("should set the name of the style, if given", () => {
            const style = new Style({
                type: "paragraph",
                styleId: "myStyleId",
            }, "Style Name");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:name": [{_attr: {"w:val": "Style Name"}}]},
                ],
            });
        });
    });
});

describe("Style components", () => {
    it("Name#constructor", () => {
        const style = new components.Name("Style Name");
        const tree = new Formatter().format(style);
        expect(tree).to.deep.equal({"w:name": [{_attr: {"w:val": "Style Name"}}]});
    });

    it("BasedOn#constructor", () => {
        const style = new components.BasedOn("otherId");
        const tree = new Formatter().format(style);
        expect(tree).to.deep.equal({"w:basedOn": [{_attr: {"w:val": "otherId"}}]});
    });

    it("Next#constructor", () => {
        const style = new components.Next("otherId");
        const tree = new Formatter().format(style);
        expect(tree).to.deep.equal({"w:next": [{_attr: {"w:val": "otherId"}}]});
    });

    it("Link#constructor", () => {
        const style = new components.Link("otherId");
        const tree = new Formatter().format(style);
        expect(tree).to.deep.equal({"w:link": [{_attr: {"w:val": "otherId"}}]});
    });

    it("UiPriority#constructor", () => {
        const style = new components.UiPriority("123");
        const tree = new Formatter().format(style);
        expect(tree).to.deep.equal({"w:uiPriority": [{_attr: {"w:val": "123"}}]});
    });
});

describe("ParagraphStyle", () => {
    describe("#constructor", () => {
        it("should set the style type to paragraph and use the given style id", () => {
            const style = new ParagraphStyle("myStyleId");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": []},
                ],
            });
        });

        it("should set the name of the style, if given", () => {
            const style = new ParagraphStyle("myStyleId", "Style Name");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:name": [{_attr: {"w:val": "Style Name"}}]},
                    {"w:pPr": []},
                    {"w:rPr": []},
                ],
            });
        });
    });

    describe("formatting methods: style attributes", () => {
        it("#basedOn", () => {
            const style = new ParagraphStyle("myStyleId")
                .basedOn("otherId");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": []},
                    {"w:basedOn": [{_attr: {"w:val": "otherId"}}]},
                ],
            });
        });

        it("#quickFormat", () => {
            const style = new ParagraphStyle("myStyleId")
                .quickFormat();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": []},
                    {"w:qFormat": []},
                ],
            });
        });

        it("#next", () => {
            const style = new ParagraphStyle("myStyleId")
                .next("otherId");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": []},
                    {"w:next": [{_attr: {"w:val": "otherId"}}]},
                ],
            });
        });
    });

    describe("formatting methods: paragraph properties", () => {
        it("#indent", () => {
            const style = new ParagraphStyle("myStyleId")
                .indent(720);
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:ind": [{_attr: {"w:left": 720}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#spacing", () => {
            const style = new ParagraphStyle("myStyleId")
                .spacing({before: 50, after: 150});
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:spacing": [{_attr: {"w:before": 50, "w:after": 150}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#center", () => {
            const style = new ParagraphStyle("myStyleId")
                .center();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:jc": [{_attr: {"w:val": "center"}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#left", () => {
            const style = new ParagraphStyle("myStyleId")
                .left();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:jc": [{_attr: {"w:val": "left"}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#right", () => {
            const style = new ParagraphStyle("myStyleId")
                .right();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:jc": [{_attr: {"w:val": "right"}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#justified", () => {
            const style = new ParagraphStyle("myStyleId")
                .justified();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:jc": [{_attr: {"w:val": "both"}}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#thematicBreak", () => {
            const style = new ParagraphStyle("myStyleId")
                .thematicBreak();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:pBdr": [{"w:bottom": [{_attr: {
                            "w:color": "auto",
                            "w:space": "1",
                            "w:val": "single",
                            "w:sz": "6",
                        }}]}]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#leftTabStop", () => {
            const style = new ParagraphStyle("myStyleId")
                .leftTabStop(1200);
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:tabs": [
                            {"w:tab": [{_attr: {"w:val": "left", "w:pos": 1200}}]},
                        ]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#maxRightTabStop", () => {
            const style = new ParagraphStyle("myStyleId")
                .maxRightTabStop();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [
                        {"w:tabs": [
                            {"w:tab": [{_attr: {"w:val": "right", "w:pos": 9026}}]},
                        ]},
                    ]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#keepLines", () => {
            const style = new ParagraphStyle("myStyleId")
                .keepLines();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [{"w:keepLines": []}]},
                    {"w:rPr": []},
                ],
            });
        });

        it("#keepNext", () => {
            const style = new ParagraphStyle("myStyleId")
                .keepNext();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": [{"w:keepNext": []}]},
                    {"w:rPr": []},
                ],
            });
        });
    });

    describe("formatting methods: run properties", () => {
        it("#size", () => {
            const style = new ParagraphStyle("myStyleId")
                .size(24);
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:sz": [{_attr: {"w:val": 24}}]},
                    ]},
                ],
            });
        });

        it("#smallCaps", () => {
            const style = new ParagraphStyle("myStyleId")
                .smallCaps();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:smallCaps": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        it("#allCaps", () => {
            const style = new ParagraphStyle("myStyleId")
                .allCaps();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:caps": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        it("#strike", () => {
            const style = new ParagraphStyle("myStyleId")
                .strike();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:strike": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        it("#doubleStrike", () => {
            const style = new ParagraphStyle("myStyleId")
                .doubleStrike();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:dstrike": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        it("#subScript", () => {
            const style = new ParagraphStyle("myStyleId")
                .subScript();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:vertAlign": [{_attr: {"w:val": "subscript"}}]},
                    ]},
                ],
            });
        });

        it("#superScript", () => {
            const style = new ParagraphStyle("myStyleId")
                .superScript();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:vertAlign": [{_attr: {"w:val": "superscript"}}]},
                    ]},
                ],
            });
        });

        it("#font", () => {
            const style = new ParagraphStyle("myStyleId")
                .font("Times");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [{"w:rFonts": [{_attr: {"w:ascii": "Times", "w:hAnsi": "Times"}}]}]},
                ],
            });
        });

        it("#bold", () => {
            const style = new ParagraphStyle("myStyleId")
                .bold();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:b": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        it("#italics", () => {
            const style = new ParagraphStyle("myStyleId")
                .italics();
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:i": [{_attr: {"w:val": true}}]},
                    ]},
                ],
            });
        });

        describe("#underline", () => {
            it("should set underline to 'single' if no arguments are given", () => {
                const style = new ParagraphStyle("myStyleId")
                    .underline();
                const tree = new Formatter().format(style);
                expect(tree).to.deep.equal({
                    "w:style": [
                        {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                        {"w:pPr": []},
                        {"w:rPr": [
                            {"w:u": [{_attr: {"w:val": "single"}}]},
                        ]},
                    ],
                });
            });

            it("should set the style if given", () => {
                const style = new ParagraphStyle("myStyleId")
                    .underline("double");
                const tree = new Formatter().format(style);
                expect(tree).to.deep.equal({
                    "w:style": [
                        {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                        {"w:pPr": []},
                        {"w:rPr": [
                            {"w:u": [{_attr: {"w:val": "double"}}]},
                        ]},
                    ],
                });
            });

            it("should set the style and color if given", () => {
                const style = new ParagraphStyle("myStyleId")
                    .underline("double", "005599");
                const tree = new Formatter().format(style);
                expect(tree).to.deep.equal({
                    "w:style": [
                        {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                        {"w:pPr": []},
                        {"w:rPr": [
                            {"w:u": [{_attr: {"w:val": "double", "w:color": "005599"}}]},
                        ]},
                    ],
                });
            });
        });

        it("#color", () => {
            const style = new ParagraphStyle("myStyleId")
                .color("123456");
            const tree = new Formatter().format(style);
            expect(tree).to.deep.equal({
                "w:style": [
                    {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                    {"w:pPr": []},
                    {"w:rPr": [
                        {"w:color": [{_attr: {"w:val": "123456"}}]},
                    ]},
                ],
            });
        });
    });
});