Merge pull request #16 from felipeochoa/cleanup

Cleanup

ts/docx/paragraph/properties.ts

@@ -4,7 +4,6 @@ export class ParagraphProperties extends XmlComponent {
 
     constructor() {
         super("w:pPr");
-        this.root.push(new Attributes());
     }
 
     public push(item: XmlComponent): void {

ts/docx/xml-components/base.ts

@@ -5,5 +5,5 @@ export abstract class BaseXmlComponent {
         this.rootKey = rootKey;
     }
 
-    public abstract toXml(): object;
+    public abstract prepForXml(): object;
 }

ts/docx/xml-components/default-attributes.ts

@@ -16,7 +16,7 @@ export abstract class XmlAttributeComponent extends BaseXmlComponent {
         }
     }
 
-    public toXml(): object {
+    public prepForXml(): {_attr: {[key: string]: (string | number | boolean)}} {
         const attrs = {};
         if (this.root !== undefined) {
             _.forOwn(this.root, (value, key) => {
@@ -26,8 +26,6 @@ export abstract class XmlAttributeComponent extends BaseXmlComponent {
                 }
             });
         }
-        const ret = {};
+        return {_attr: attrs};
-        ret[this.rootKey] = attrs;
-        return ret;
     }
 }

ts/docx/xml-components/index.ts

@@ -1,4 +1,3 @@
-import * as _ from "lodash";
 import { BaseXmlComponent } from "./base";
 export { BaseXmlComponent };
 
@@ -10,16 +9,15 @@ export abstract class XmlComponent extends BaseXmlComponent {
         this.root = new Array<BaseXmlComponent>();
     }
 
-    public toXml(): object {
+    public prepForXml(): object {
-        // What does 'ret' stand for? Retain? Return?
+        const children = this.root.map((comp) => {
-        const ret = this.root.map((comp) => {
             if (comp instanceof BaseXmlComponent) {
-                return comp.toXml();
+                return comp.prepForXml();
             }
             return comp;
         }).filter((comp) => comp); // Exclude null, undefined, and empty strings
         return {
-            [this.rootKey]: ret,
+            [this.rootKey]: children,
         };
     }
 }

ts/export/formatter.ts

@@ -2,6 +2,6 @@ import { BaseXmlComponent } from "../docx/xml-components";
 
 export class Formatter {
     public format(input: BaseXmlComponent): any {
-        return input.toXml();
+        return input.prepForXml();
     }
 }

ts/export/packer/packer.ts

@@ -49,7 +49,6 @@ export abstract class Packer {
 
     public pack(output: any): void {
         this.archive.pipe(output);
-        console.log(appRoot.path + "/template");
         this.archive.glob("**", {
             expand: true,
             cwd: appRoot.path + "/template",
@@ -60,20 +59,10 @@ export abstract class Packer {
             cwd: appRoot.path + "/template",
         });
 
-        // this.archive.file(appRoot.path + "/template/[Content_Types].xml", { name: "[Content_Types].xml" });
-        // console.log(__dirname + "/packer.js");
-        // this.archive.file(__dirname + "/packer.js", { name: "/[Content_Types].xml" });
-
-        /*this.archive.directory(appRoot.path + "/template", {
-            name: "/root/g.txt",
-            prefix: "root"
-        });*/
         const xmlDocument = xml(this.formatter.format(this.document));
         const xmlStyles = xml(this.formatter.format(this.style));
         const xmlProperties = xml(this.formatter.format(this.properties), { declaration: { standalone: "yes", encoding: "UTF-8" } });
         const xmlNumbering = xml(this.formatter.format(this.numbering));
-        // console.log(JSON.stringify(this.numbering, null, " "));
-        console.log(xmlNumbering);
         this.archive.append(xmlDocument, {
             name: "word/document.xml",
         });

ts/numbering/abstract-numbering.ts

@@ -1,4 +1,3 @@
-import * as _ from "lodash";
 import { XmlAttributeComponent, XmlComponent } from "../docx/xml-components";
 import { Level } from "./level";
 import { MultiLevelType } from "./multi-level-type";

ts/numbering/index.ts

@@ -1,4 +1,3 @@
-import * as _ from "lodash";
 import { DocumentAttributes } from "../docx/document/document-attributes";
 import { Indent } from "../docx/paragraph/indent";
 import { RunFonts } from "../docx/run/run-fonts";

ts/styles/factory.ts

@@ -54,7 +54,6 @@ export class DefaultStylesFactory {
         // listParagraph.addParagraphProperty();
         styles.push(listParagraph);
 
-        // console.log(JSON.stringify(styles, null, "  "));
         return styles;
     }
 }

ts/styles/style/components.ts

@@ -5,10 +5,6 @@ interface IComponentAttributes {
 }
 
 class ComponentAttributes extends XmlAttributeComponent {
-    /* tslint:disable */
-    private _attr: IComponentAttributes;
-    /* tslint:enable */
-
     constructor(properties: IComponentAttributes) {
         super({val: "w:val"}, properties);
     }

ts/styles/style/index.ts

@@ -15,10 +15,6 @@ export interface IStyleAttributes {
 }
 
 class StyleAttributes extends XmlAttributeComponent {
-    /* tslint:disable */
-    private _attr: IStyleAttributes;
-    /* tslint:enable */
-
     constructor(properties: IStyleAttributes) {
         super({
             type: "w:type",

ts/tests/docx/paragraph/paragraphTests.ts

@@ -35,80 +35,135 @@ describe("Paragraph", () => {
     describe("#heading1()", () => {
         it("should add heading style to JSON", () => {
             paragraph.heading1();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "Heading1");
+            expect(tree).to.deep.equal({
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading1"}}]}],
+                    },
+                ],
+            });
         });
     });
 
     describe("#heading2()", () => {
         it("should add heading style to JSON", () => {
             paragraph.heading2();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-
+            expect(tree).to.deep.equal({
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "Heading2");
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading2"}}]}],
+                    },
+                ],
+            });
         });
     });
 
     describe("#heading3()", () => {
         it("should add heading style to JSON", () => {
             paragraph.heading3();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-
+            expect(tree).to.deep.equal({
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "Heading3");
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Heading3"}}]}],
+                    },
+                ],
+            });
         });
     });
 
     describe("#title()", () => {
         it("should add title style to JSON", () => {
             paragraph.title();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-
+            expect(tree).to.deep.equal({
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "Title");
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:pStyle": [{_attr: {"w:val": "Title"}}]}],
+                    },
+                ],
+            });
         });
     });
 
     describe("#center()", () => {
         it("should add center alignment to JSON", () => {
             paragraph.center();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-
+            expect(tree).to.deep.equal({
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "center");
+                "w:p": [
+                    {
+                        "w:pPr": [{"w:jc": [{_attr: {"w:val": "center"}}]}],
+                    },
+                ],
+            });
         });
     });
 
     describe("#thematicBreak()", () => {
         it("should add thematic break to JSON", () => {
             paragraph.thematicBreak();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.equal(newJson.root[0].root[1].rootKey, "w:pBdr");
+            expect(tree).to.deep.equal({
+                "w:p": [{
+                    "w:pPr": [{
+                        "w:pBdr": [{
+                            "w:bottom": [{
+                                _attr: {
+                                    "w:val": "single",
+                                    "w:color": "auto",
+                                    "w:space": "1",
+                                    "w:sz": "6",
+                                },
+                            }],
+                        }],
+                    }],
+                }],
+            });
         });
     });
 
     describe("#pageBreak()", () => {
         it("should add page break to JSON", () => {
             paragraph.pageBreak();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.equal(newJson.root[0].root[1].root[1].rootKey, "w:br");
+            expect(tree).to.deep.equal({
-        });
+                "w:p": [{
-
+                    "w:pPr": [{
-        it("should add page break with 'page' type", () => {
+                        "w:r": [
-            paragraph.pageBreak();
+                            {"w:rPr": []},
-            const newJson = Utility.jsonify(paragraph);
+                            {"w:br": [{_attr: {"w:type": "page"}}]},
-            assert.equal(newJson.root[0].root[1].root[1].root[0].root.type, "page");
+                        ],
+                    }],
+                }],
+            });
         });
     });
 
     describe("#bullet()", () => {
         it("should add list paragraph style to JSON", () => {
             paragraph.bullet();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "ListParagraph");
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
         });
 
         it("it should add numbered properties", () => {
             paragraph.bullet();
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.isDefined(newJson.root[0].root[2]);
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(2);
+            expect(tree["w:p"][0]["w:pPr"][1]).to.deep.equal({
+                "w:numPr": [
+                    {"w:ilvl": [{_attr: {"w:val": 0}}]},
+                    {"w:numId": [{_attr: {"w:val": 1}}]},
+                ],
+            });
         });
     });
 
@@ -120,8 +175,12 @@ describe("Paragraph", () => {
             const letterNumbering = numbering.createConcreteNumbering(numberedAbstract);
 
             paragraph.setNumbering(letterNumbering, 0);
-            const newJson = Utility.jsonify(paragraph);
+            const tree = new Formatter().format(paragraph);
-            assert.equal(newJson.root[0].root[1].root[0].root.val, "ListParagraph");
+            expect(tree).to.have.property("w:p").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]).to.have.property("w:pPr").which.is.an("array").which.has.length.at.least(1);
+            expect(tree["w:p"][0]["w:pPr"][0]).to.deep.equal({
+                "w:pStyle": [{_attr: {"w:val": "ListParagraph"}}],
+            });
         });
 
         it("it should add numbered properties", () => {
@@ -136,7 +195,6 @@ describe("Paragraph", () => {
                 "w:p": [
                     {
                         "w:pPr": [
-                            {_attr: {}},
                             {"w:pStyle": [{_attr: {"w:val": "ListParagraph"}}]},
                             {
                                 "w:numPr": [
@@ -159,7 +217,6 @@ describe("Paragraph", () => {
                 "w:p": [
                     {
                         "w:pPr": [
-                            {_attr: {}},
                             {"w:pStyle": [{_attr: {"w:val": "myFancyStyle"}}]},
                         ],
                     },
@@ -176,7 +233,6 @@ describe("Paragraph", () => {
                 "w:p": [
                     {
                         "w:pPr": [
-                            {_attr: {}},
                             {"w:ind": [{_attr: {"w:left": 720}}]},
                         ],
                     },
@@ -193,7 +249,6 @@ describe("Paragraph", () => {
                 "w:p": [
                     {
                         "w:pPr": [
-                            {_attr: {}},
                             {"w:spacing": [{_attr: {"w:before": 90, "w:line": 50}}]},
                         ],
                     },

ts/tests/stylesTest.ts

@@ -25,7 +25,7 @@ describe("Styles", () => {
             expect(tree).to.deep.equal([{
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "pStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                 ],
             }]);
@@ -38,7 +38,7 @@ describe("Styles", () => {
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "pStyleId"}},
                     {"w:name": [{_attr: {"w:val": "Paragraph Style"}}]},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                 ],
             }]);
@@ -118,7 +118,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                 ],
             });
@@ -131,7 +131,7 @@ describe("ParagraphStyle", () => {
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                     {"w:name": [{_attr: {"w:val": "Style Name"}}]},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                 ],
             });
@@ -146,7 +146,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                     {"w:basedOn": [{_attr: {"w:val": "otherId"}}]},
                 ],
@@ -160,7 +160,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                     {"w:qFormat": []},
                 ],
@@ -174,7 +174,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": []},
                     {"w:next": [{_attr: {"w:val": "otherId"}}]},
                 ],
@@ -191,7 +191,6 @@ describe("ParagraphStyle", () => {
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                     {"w:pPr": [
-                        {_attr: {}},
                         {"w:ind": [{_attr: {"w:left": 720}}]},
                     ]},
                     {"w:rPr": []},
@@ -207,7 +206,6 @@ describe("ParagraphStyle", () => {
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
                     {"w:pPr": [
-                        {_attr: {}},
                         {"w:spacing": [{_attr: {"w:before": 50, "w:after": 150}}]},
                     ]},
                     {"w:rPr": []},
@@ -224,7 +222,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": [
                         {"w:sz": [{_attr: {"w:val": 24}}]},
                     ]},
@@ -239,7 +237,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": [
                         {"w:b": [{_attr: {"w:val": true}}]},
                     ]},
@@ -254,7 +252,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": [
                         {"w:i": [{_attr: {"w:val": true}}]},
                     ]},
@@ -270,7 +268,7 @@ describe("ParagraphStyle", () => {
                 expect(tree).to.deep.equal({
                     "w:style": [
                         {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                        {"w:pPr": [{_attr: {}}]},
+                        {"w:pPr": []},
                         {"w:rPr": [
                             {"w:u": [{_attr: {"w:val": "single"}}]},
                         ]},
@@ -285,7 +283,7 @@ describe("ParagraphStyle", () => {
                 expect(tree).to.deep.equal({
                     "w:style": [
                         {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                        {"w:pPr": [{_attr: {}}]},
+                        {"w:pPr": []},
                         {"w:rPr": [
                             {"w:u": [{_attr: {"w:val": "double"}}]},
                         ]},
@@ -300,7 +298,7 @@ describe("ParagraphStyle", () => {
                 expect(tree).to.deep.equal({
                     "w:style": [
                         {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                        {"w:pPr": [{_attr: {}}]},
+                        {"w:pPr": []},
                         {"w:rPr": [
                             {"w:u": [{_attr: {"w:val": "double", "w:color": "005599"}}]},
                         ]},
@@ -316,7 +314,7 @@ describe("ParagraphStyle", () => {
             expect(tree).to.deep.equal({
                 "w:style": [
                     {_attr: {"w:type": "paragraph", "w:styleId": "myStyleId"}},
-                    {"w:pPr": [{_attr: {}}]},
+                    {"w:pPr": []},
                     {"w:rPr": [
                         {"w:color": [{_attr: {"w:val": "123456"}}]},
                     ]},

ts/tsconfig.json

@@ -1,6 +1,7 @@
 {
     "compilerOptions": {
         "target": "es6",
+        "strictNullChecks": true,
         "sourceMap": true,
         "removeComments": true,
         "preserveConstEnums": true,
@@ -12,4 +13,4 @@
     "exclude": [
         "tests"
     ]
-}
+}