Feat/footnotes

demo/demo17.js

@@ -0,0 +1,17 @@
+const docx = require('../build');
+
+var doc = new docx.Document();
+
+var paragraph = new docx.Paragraph("Hello World").referenceFootnote(1);
+var paragraph2 = new docx.Paragraph("Hello World").referenceFootnote(2);
+
+doc.addParagraph(paragraph);
+doc.addParagraph(paragraph2);
+
+doc.createFootnote(new docx.Paragraph("Test"));
+doc.createFootnote(new docx.Paragraph("My amazing reference"));
+
+var exporter = new docx.LocalPacker(doc);
+exporter.pack('My Document');
+
+console.log('Document created successfully at project root!');

src/export/packer/compiler.spec.ts

@@ -26,7 +26,7 @@ describe("Compiler", () => {
             const fileNames = Object.keys(zipFile.files).map((f) => zipFile.files[f].name);
 
             expect(fileNames).is.an.instanceof(Array);
-            expect(fileNames).has.length(12);
+            expect(fileNames).has.length(13);
             expect(fileNames).to.include("word/document.xml");
             expect(fileNames).to.include("word/styles.xml");
             expect(fileNames).to.include("docProps/core.xml");
@@ -35,6 +35,7 @@ describe("Compiler", () => {
             expect(fileNames).to.include("word/header1.xml");
             expect(fileNames).to.include("word/_rels/header1.xml.rels");
             expect(fileNames).to.include("word/footer1.xml");
+            expect(fileNames).to.include("word/footnotes.xml");
             expect(fileNames).to.include("word/_rels/footer1.xml.rels");
             expect(fileNames).to.include("word/_rels/document.xml.rels");
             expect(fileNames).to.include("[Content_Types].xml");
@@ -56,7 +57,7 @@ describe("Compiler", () => {
             const fileNames = Object.keys(zipFile.files).map((f) => zipFile.files[f].name);
 
             expect(fileNames).is.an.instanceof(Array);
-            expect(fileNames).has.length(20);
+            expect(fileNames).has.length(21);
 
             expect(fileNames).to.include("word/header1.xml");
             expect(fileNames).to.include("word/_rels/header1.xml.rels");

src/export/packer/compiler.ts

@@ -35,6 +35,7 @@ export class Compiler {
         const xmlFileRelationships = xml(this.formatter.format(this.file.FileRelationships));
         const xmlContentTypes = xml(this.formatter.format(this.file.ContentTypes));
         const xmlAppProperties = xml(this.formatter.format(this.file.AppProperties));
+        const xmlFootnotes = xml(this.formatter.format(this.file.FootNotes));
 
         this.archive.append(xmlDocument, {
             name: "word/document.xml",
@@ -80,6 +81,10 @@ export class Compiler {
             });
         }
 
+        this.archive.append(xmlFootnotes, {
+            name: "word/footnotes.xml",
+        });
+
         this.archive.append(xmlRelationships, {
             name: "word/_rels/document.xml.rels",
         });

src/file/content-types/content-types.spec.ts

@@ -83,7 +83,7 @@ describe("ContentTypes", () => {
             contentTypes.addFooter(102);
             const tree = new Formatter().format(contentTypes);
 
-            expect(tree["Types"][13]).to.deep.equal({
+            expect(tree["Types"][14]).to.deep.equal({
                 Override: [
                     {
                         _attr: {
@@ -94,7 +94,7 @@ describe("ContentTypes", () => {
                 ],
             });
 
-            expect(tree["Types"][14]).to.deep.equal({
+            expect(tree["Types"][15]).to.deep.equal({
                 Override: [
                     {
                         _attr: {
@@ -113,7 +113,7 @@ describe("ContentTypes", () => {
             contentTypes.addHeader(202);
             const tree = new Formatter().format(contentTypes);
 
-            expect(tree["Types"][13]).to.deep.equal({
+            expect(tree["Types"][14]).to.deep.equal({
                 Override: [
                     {
                         _attr: {
@@ -124,7 +124,7 @@ describe("ContentTypes", () => {
                 ],
             });
 
-            expect(tree["Types"][14]).to.deep.equal({
+            expect(tree["Types"][15]).to.deep.equal({
                 Override: [
                     {
                         _attr: {

src/file/content-types/content-types.ts

@@ -29,6 +29,7 @@ export class ContentTypes extends XmlComponent {
         this.root.push(new Override("application/vnd.openxmlformats-package.core-properties+xml", "/docProps/core.xml"));
         this.root.push(new Override("application/vnd.openxmlformats-officedocument.extended-properties+xml", "/docProps/app.xml"));
         this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml", "/word/numbering.xml"));
+        this.root.push(new Override("application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml", "/word/footnotes.xml"));
     }
 
     public addFooter(index: number): void {

src/file/file.ts

@@ -6,6 +6,7 @@ import { Document } from "./document";
 import { FooterReferenceType, HeaderReference, HeaderReferenceType } from "./document/body/section-properties";
 import { SectionPropertiesOptions } from "./document/body/section-properties/section-properties";
 import { FooterWrapper } from "./footer-wrapper";
+import { FootNotes } from "./footnotes";
 import { HeaderWrapper } from "./header-wrapper";
 import { Media } from "./media";
 import { Numbering } from "./numbering";
@@ -26,6 +27,7 @@ export class File {
     private readonly fileRelationships: Relationships;
     private readonly headerWrapper: HeaderWrapper[] = [];
     private readonly footerWrapper: FooterWrapper[] = [];
+    private readonly footNotes: FootNotes;
 
     private readonly contentTypes: ContentTypes;
     private readonly appProperties: AppProperties;
@@ -63,6 +65,12 @@ export class File {
             "numbering.xml",
         );
         this.contentTypes = new ContentTypes();
+
+        this.docRelationships.createRelationship(
+            this.nextId++,
+            "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
+            "footnotes.xml",
+        );
         this.media = new Media();
 
         const header = this.createHeader();
@@ -86,6 +94,7 @@ export class File {
         );
         this.appProperties = new AppProperties();
 
+        this.footNotes = new FootNotes();
         if (!sectionPropertiesOptions) {
             sectionPropertiesOptions = {
                 footerType: FooterReferenceType.DEFAULT,
@@ -152,6 +161,10 @@ export class File {
         this.document.Body.addSection(sectionPropertiesOptions);
     }
 
+    public createFootnote(paragraph: Paragraph): void {
+        this.footNotes.createFootNote(paragraph);
+    }
+
     /**
      * Creates new header.
      */
@@ -262,4 +275,8 @@ export class File {
     public get AppProperties(): AppProperties {
         return this.appProperties;
     }
+
+    public get FootNotes(): FootNotes {
+        return this.footNotes;
+    }
 }

src/file/footnotes/footnote/footnote-attributes.ts

@@ -0,0 +1,13 @@
+import { XmlAttributeComponent } from "file/xml-components";
+
+export interface IFootnoteAttributesProperties {
+    type?: string;
+    id: number;
+}
+
+export class FootnoteAttributes extends XmlAttributeComponent<IFootnoteAttributesProperties> {
+    protected xmlKeys = {
+        type: "w:type",
+        id: "w:id",
+    };
+}

src/file/footnotes/footnote/footnote.spec.ts

@@ -0,0 +1,25 @@
+import { expect } from "chai";
+import { Formatter } from "../../../export/formatter";
+import { Footnote, FootnoteType } from "./footnote";
+
+describe("Footnote", () => {
+    describe("#constructor", () => {
+        it("should create a footnote with a footnote type", () => {
+            const footnote = new Footnote(1, FootnoteType.SEPERATOR);
+            const tree = new Formatter().format(footnote);
+
+            expect(Object.keys(tree)).to.deep.equal(["w:footnote"]);
+            expect(tree["w:footnote"]).to.be.an.instanceof(Array);
+            expect(tree["w:footnote"][0]).to.deep.equal({ _attr: { "w:type": "separator", "w:id": 1 } });
+        });
+
+        it("should create a footnote without a footnote type", () => {
+            const footnote = new Footnote(1);
+            const tree = new Formatter().format(footnote);
+
+            expect(Object.keys(tree)).to.deep.equal(["w:footnote"]);
+            expect(tree["w:footnote"]).to.be.an.instanceof(Array);
+            expect(tree["w:footnote"][0]).to.deep.equal({ _attr: { "w:id": 1 } });
+        });
+    });
+});

src/file/footnotes/footnote/footnote.ts

@@ -0,0 +1,26 @@
+import { XmlComponent } from "file/xml-components";
+import { Paragraph } from "../../paragraph";
+import { FootnoteAttributes } from "./footnote-attributes";
+import { FootnoteRefRun } from "./run/footnote-ref-run";
+
+export enum FootnoteType {
+    SEPERATOR = "separator",
+    CONTINUATION_SEPERATOR = "continuationSeparator",
+}
+
+export class Footnote extends XmlComponent {
+    constructor(id: number, type?: FootnoteType) {
+        super("w:footnote");
+        this.root.push(
+            new FootnoteAttributes({
+                type: type,
+                id: id,
+            }),
+        );
+    }
+
+    public addParagraph(paragraph: Paragraph): void {
+        paragraph.addRunToFront(new FootnoteRefRun());
+        this.root.push(paragraph);
+    }
+}

src/file/footnotes/footnote/run/continuation-seperator-run.ts

@@ -0,0 +1,10 @@
+import { Run } from "file/paragraph";
+import { ContinuationSeperator } from "./continuation-seperator";
+
+export class ContinuationSeperatorRun extends Run {
+    constructor() {
+        super();
+
+        this.root.push(new ContinuationSeperator());
+    }
+}

src/file/footnotes/footnote/run/continuation-seperator.ts

@@ -0,0 +1,7 @@
+import { XmlComponent } from "file/xml-components";
+
+export class ContinuationSeperator extends XmlComponent {
+    constructor() {
+        super("w:continuationSeparator");
+    }
+}

src/file/footnotes/footnote/run/footnote-ref-run.ts

@@ -0,0 +1,11 @@
+import { Run } from "file/paragraph";
+import { FootnoteRef } from "./footnote-ref";
+
+export class FootnoteRefRun extends Run {
+    constructor() {
+        super();
+
+        this.style("FootnoteReference");
+        this.root.push(new FootnoteRef());
+    }
+}

src/file/footnotes/footnote/run/footnote-ref.ts

@@ -0,0 +1,7 @@
+import { XmlComponent } from "file/xml-components";
+
+export class FootnoteRef extends XmlComponent {
+    constructor() {
+        super("w:footnoteRef");
+    }
+}

src/file/footnotes/footnote/run/reference-run.ts

@@ -0,0 +1,35 @@
+import { Run } from "file/paragraph/run";
+import { Style } from "file/paragraph/run/style";
+import { XmlAttributeComponent, XmlComponent } from "file/xml-components";
+
+export interface IFootNoteReferenceRunAttributesProperties {
+    id: number;
+}
+
+export class FootNoteReferenceRunAttributes extends XmlAttributeComponent<IFootNoteReferenceRunAttributesProperties> {
+    protected xmlKeys = {
+        id: "w:id",
+    };
+}
+
+export class FootnoteReference extends XmlComponent {
+    constructor(id: number) {
+        super("w:footnoteReference");
+
+        this.root.push(
+            new FootNoteReferenceRunAttributes({
+                id: id,
+            }),
+        );
+    }
+}
+
+export class FootnoteReferenceRun extends Run {
+    constructor(id: number) {
+        super();
+
+        this.properties.push(new Style("FootnoteReference"));
+
+        this.root.push(new FootnoteReference(id));
+    }
+}

src/file/footnotes/footnote/run/seperator-run.ts

@@ -0,0 +1,10 @@
+import { Run } from "file/paragraph";
+import { Seperator } from "./seperator";
+
+export class SeperatorRun extends Run {
+    constructor() {
+        super();
+
+        this.root.push(new Seperator());
+    }
+}

src/file/footnotes/footnote/run/seperator.ts

@@ -0,0 +1,7 @@
+import { XmlComponent } from "file/xml-components";
+
+export class Seperator extends XmlComponent {
+    constructor() {
+        super("w:separator");
+    }
+}

src/file/footnotes/footnotes-attributes.ts

@@ -0,0 +1,43 @@
+import { XmlAttributeComponent } from "file/xml-components";
+
+export interface IFootnotesAttributesProperties {
+    wpc?: string;
+    mc?: string;
+    o?: string;
+    r?: string;
+    m?: string;
+    v?: string;
+    wp14?: string;
+    wp?: string;
+    w10?: string;
+    w?: string;
+    w14?: string;
+    w15?: string;
+    wpg?: string;
+    wpi?: string;
+    wne?: string;
+    wps?: string;
+    Ignorable?: string;
+}
+
+export class FootnotesAttributes extends XmlAttributeComponent<IFootnotesAttributesProperties> {
+    protected xmlKeys = {
+        wpc: "xmlns:wpc",
+        mc: "xmlns:mc",
+        o: "xmlns:o",
+        r: "xmlns:r",
+        m: "xmlns:m",
+        v: "xmlns:v",
+        wp14: "xmlns:wp14",
+        wp: "xmlns:wp",
+        w10: "xmlns:w10",
+        w: "xmlns:w",
+        w14: "xmlns:w14",
+        w15: "xmlns:w15",
+        wpg: "xmlns:wpg",
+        wpi: "xmlns:wpi",
+        wne: "xmlns:wne",
+        wps: "xmlns:wps",
+        Ignorable: "mc:Ignorable",
+    };
+}