docx 8.0.0 → 8.0.2

package/src/file/paragraph/run/run.ts

@@ -1,156 +0,0 @@
-// http://officeopenxml.com/WPtext.php
-import { XmlComponent } from "@file/xml-components";
-
-import { FootnoteReferenceRun } from "@file/footnotes/footnote/run/reference-run";
-import { FieldInstruction } from "@file/table-of-contents/field-instruction";
-
-import { Break } from "./break";
-import { Begin, End, Separate } from "./field";
-import { NumberOfPages, NumberOfPagesSection, Page } from "./page-number";
-import { IRunPropertiesOptions, RunProperties } from "./properties";
-import { Text } from "./run-components/text";
-import {
-    AnnotationReference,
-    CarriageReturn,
-    ContinuationSeparator,
-    DayLong,
-    DayShort,
-    EndnoteReference,
-    FootnoteReferenceElement,
-    LastRenderedPageBreak,
-    MonthLong,
-    MonthShort,
-    NoBreakHyphen,
-    PageNumberElement,
-    Separator,
-    SoftHyphen,
-    Tab,
-    YearLong,
-    YearShort,
-} from "./empty-children";
-import { PositionalTab } from "./positional-tab";
-
-export interface IRunOptions extends IRunPropertiesOptions {
-    // <xsd:choice>
-    //     <xsd:element name="br" type="CT_Br" />
-    //     <xsd:element name="t" type="CT_Text" />
-    //     <xsd:element name="contentPart" type="CT_Rel" />
-    //     <xsd:element name="delText" type="CT_Text" />
-    //     <xsd:element name="instrText" type="CT_Text" />
-    //     <xsd:element name="delInstrText" type="CT_Text" />
-    //     <xsd:element name="noBreakHyphen" type="CT_Empty" />
-    //     <xsd:element name="softHyphen" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="dayShort" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="monthShort" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="yearShort" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="dayLong" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="monthLong" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="yearLong" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="annotationRef" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="footnoteRef" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="endnoteRef" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="separator" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="continuationSeparator" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="sym" type="CT_Sym" minOccurs="0" />
-    //     <xsd:element name="pgNum" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="cr" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="tab" type="CT_Empty" minOccurs="0" />
-    //     <xsd:element name="object" type="CT_Object" />
-    //     <xsd:element name="pict" type="CT_Picture" />
-    //     <xsd:element name="fldChar" type="CT_FldChar" />
-    //     <xsd:element name="ruby" type="CT_Ruby" />
-    //     <xsd:element name="footnoteReference" type="CT_FtnEdnRef" />
-    //     <xsd:element name="endnoteReference" type="CT_FtnEdnRef" />
-    //     <xsd:element name="commentReference" type="CT_Markup" />
-    //     <xsd:element name="drawing" type="CT_Drawing" />
-    //     <xsd:element name="ptab" type="CT_PTab" minOccurs="0" />
-    //     <xsd:element name="lastRenderedPageBreak" type="CT_Empty" minOccurs="0" maxOccurs="1" />
-    // </xsd:choice>
-    readonly children?: readonly (
-        | Begin
-        | FieldInstruction
-        | Separate
-        | End
-        | PageNumber
-        | FootnoteReferenceRun
-        | Break
-        | AnnotationReference
-        | CarriageReturn
-        | ContinuationSeparator
-        | DayLong
-        | DayShort
-        | EndnoteReference
-        | FootnoteReferenceElement
-        | LastRenderedPageBreak
-        | MonthLong
-        | MonthShort
-        | NoBreakHyphen
-        | PageNumberElement
-        | Separator
-        | SoftHyphen
-        | Tab
-        | YearLong
-        | YearShort
-        | PositionalTab
-        | string
-    )[];
-    readonly break?: number;
-    readonly text?: string;
-}
-
-export enum PageNumber {
-    CURRENT = "CURRENT",
-    TOTAL_PAGES = "TOTAL_PAGES",
-    TOTAL_PAGES_IN_SECTION = "TOTAL_PAGES_IN_SECTION",
-}
-
-export class Run extends XmlComponent {
-    protected readonly properties: RunProperties;
-
-    public constructor(options: IRunOptions) {
-        super("w:r");
-        this.properties = new RunProperties(options);
-        this.root.push(this.properties);
-
-        if (options.break) {
-            for (let i = 0; i < options.break; i++) {
-                this.root.push(new Break());
-            }
-        }
-
-        if (options.children) {
-            for (const child of options.children) {
-                if (typeof child === "string") {
-                    switch (child) {
-                        case PageNumber.CURRENT:
-                            this.root.push(new Begin());
-                            this.root.push(new Page());
-                            this.root.push(new Separate());
-                            this.root.push(new End());
-                            break;
-                        case PageNumber.TOTAL_PAGES:
-                            this.root.push(new Begin());
-                            this.root.push(new NumberOfPages());
-                            this.root.push(new Separate());
-                            this.root.push(new End());
-                            break;
-                        case PageNumber.TOTAL_PAGES_IN_SECTION:
-                            this.root.push(new Begin());
-                            this.root.push(new NumberOfPagesSection());
-                            this.root.push(new Separate());
-                            this.root.push(new End());
-                            break;
-                        default:
-                            this.root.push(new Text(child));
-                            break;
-                    }
-                    continue;
-                }
-
-                this.root.push(child);
-            }
-        } else if (options.text) {
-            this.root.push(new Text(options.text));
-        }
-    }
-}

package/src/file/paragraph/run/script.spec.ts

@@ -1,51 +0,0 @@
-import { assert } from "chai";
-
-import { Utility } from "tests/utility";
-
-import { SubScript, SuperScript } from "./script";
-
-describe("SubScript", () => {
-    let subScript: SubScript;
-
-    beforeEach(() => {
-        subScript = new SubScript();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Sub Script with correct attributes", () => {
-            const newJson = Utility.jsonify(subScript);
-            const attributes = {
-                val: "subscript",
-            };
-            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
-        });
-
-        it("should create a Sub Script with correct root key", () => {
-            const newJson = Utility.jsonify(subScript);
-            assert.equal(newJson.rootKey, "w:vertAlign");
-        });
-    });
-});
-
-describe("SuperScript", () => {
-    let superScript: SuperScript;
-
-    beforeEach(() => {
-        superScript = new SuperScript();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Super Script with correct attributes", () => {
-            const newJson = Utility.jsonify(superScript);
-            const attributes = {
-                val: "superscript",
-            };
-            assert.equal(JSON.stringify(newJson.root[0].root), JSON.stringify(attributes));
-        });
-
-        it("should create a Super Script with correct root key", () => {
-            const newJson = Utility.jsonify(superScript);
-            assert.equal(newJson.rootKey, "w:vertAlign");
-        });
-    });
-});

package/src/file/paragraph/run/script.ts

@@ -1,24 +0,0 @@
-import { Attributes, XmlComponent } from "@file/xml-components";
-
-export abstract class VerticalAlign extends XmlComponent {
-    public constructor(type: string) {
-        super("w:vertAlign");
-        this.root.push(
-            new Attributes({
-                val: type,
-            }),
-        );
-    }
-}
-
-export class SuperScript extends VerticalAlign {
-    public constructor() {
-        super("superscript");
-    }
-}
-
-export class SubScript extends VerticalAlign {
-    public constructor() {
-        super("subscript");
-    }
-}

package/src/file/paragraph/run/sequential-identifier-instruction.ts

@@ -1,13 +0,0 @@
-// http://officeopenxml.com/WPfieldInstructions.php
-import { SpaceType } from "@file/shared";
-import { XmlComponent } from "@file/xml-components";
-
-import { TextAttributes } from "./text-attributes";
-
-export class SequentialIdentifierInstruction extends XmlComponent {
-    public constructor(identifier: string) {
-        super("w:instrText");
-        this.root.push(new TextAttributes({ space: SpaceType.PRESERVE }));
-        this.root.push(`SEQ ${identifier}`);
-    }
-}

package/src/file/paragraph/run/sequential-identifier.spec.ts

@@ -1,52 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { SequentialIdentifier } from "./sequential-identifier";
-
-describe("Sequential Identifier", () => {
-    describe("#constructor", () => {
-        it("should construct a SEQ without options", () => {
-            const seq = new SequentialIdentifier("Figure");
-            const tree = new Formatter().format(seq);
-            expect(tree).to.be.deep.equal(DEFAULT_SEQ);
-        });
-    });
-});
-
-const DEFAULT_SEQ = {
-    "w:r": [
-        {
-            "w:fldChar": {
-                _attr: {
-                    "w:fldCharType": "begin",
-                    "w:dirty": true,
-                },
-            },
-        },
-        {
-            "w:instrText": [
-                {
-                    _attr: {
-                        "xml:space": "preserve",
-                    },
-                },
-                "SEQ Figure",
-            ],
-        },
-        {
-            "w:fldChar": {
-                _attr: {
-                    "w:fldCharType": "separate",
-                },
-            },
-        },
-        {
-            "w:fldChar": {
-                _attr: {
-                    "w:fldCharType": "end",
-                },
-            },
-        },
-    ],
-};

package/src/file/paragraph/run/sequential-identifier.ts

@@ -1,13 +0,0 @@
-import { Run } from "@file/paragraph/run";
-import { Begin, End, Separate } from "@file/paragraph/run/field";
-import { SequentialIdentifierInstruction } from "./sequential-identifier-instruction";
-
-export class SequentialIdentifier extends Run {
-    public constructor(identifier: string) {
-        super({});
-        this.root.push(new Begin(true));
-        this.root.push(new SequentialIdentifierInstruction(identifier));
-        this.root.push(new Separate());
-        this.root.push(new End());
-    }
-}

package/src/file/paragraph/run/simple-field.spec.ts

@@ -1,38 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { SimpleField, SimpleMailMergeField } from "./simple-field";
-
-describe("SimpleField", () => {
-    describe("#constructor()", () => {
-        it("uses the instruction given", () => {
-            const tree = new Formatter().format(new SimpleField("FILENAME"));
-            expect(tree).to.deep.equal({ "w:fldSimple": { _attr: { "w:instr": "FILENAME" } } });
-        });
-
-        it("accepts a cached value", () => {
-            const tree = new Formatter().format(new SimpleField("FILENAME", "ExampleDoc.docx"));
-            expect(tree).to.deep.equal({
-                "w:fldSimple": [
-                    { _attr: { "w:instr": "FILENAME" } },
-                    { "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "ExampleDoc.docx"] }] },
-                ],
-            });
-        });
-    });
-});
-
-describe("SimpleMailMergeField", () => {
-    describe("#constructor()", () => {
-        it("creates a simple field", () => {
-            const tree = new Formatter().format(new SimpleMailMergeField("Name"));
-            expect(tree).to.deep.equal({
-                "w:fldSimple": [
-                    { _attr: { "w:instr": " MERGEFIELD Name " } },
-                    { "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "«Name»"] }] },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/run/simple-field.ts

@@ -1,23 +0,0 @@
-// http://www.datypic.com/sc/ooxml/e-w_fldSimple-1.html
-import { XmlAttributeComponent, XmlComponent } from "@file/xml-components";
-import { TextRun } from "./text-run";
-
-class FldSimpleAttrs extends XmlAttributeComponent<{ readonly instr: string }> {
-    protected readonly xmlKeys = { instr: "w:instr" };
-}
-
-export class SimpleField extends XmlComponent {
-    public constructor(instruction: string, cachedValue?: string) {
-        super("w:fldSimple");
-        this.root.push(new FldSimpleAttrs({ instr: instruction }));
-        if (cachedValue !== undefined) {
-            this.root.push(new TextRun(cachedValue));
-        }
-    }
-}
-
-export class SimpleMailMergeField extends SimpleField {
-    public constructor(fieldName: string) {
-        super(` MERGEFIELD ${fieldName} `, `«${fieldName}»`);
-    }
-}

package/src/file/paragraph/run/symbol-run.spec.ts

@@ -1,80 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { EmphasisMarkType } from "./emphasis-mark";
-import { UnderlineType } from "./underline";
-import { SymbolRun } from "./symbol-run";
-
-describe("SymbolRun", () => {
-    let run: SymbolRun;
-
-    describe("#constructor()", () => {
-        it("should create symbol run from text input", () => {
-            run = new SymbolRun("F071");
-            const f = new Formatter().format(run);
-            expect(f).to.deep.equal({
-                "w:r": [{ "w:sym": { _attr: { "w:char": "F071", "w:font": "Wingdings" } } }],
-            });
-        });
-
-        it("should create symbol run from object input with just 'char' specified", () => {
-            run = new SymbolRun({ char: "F071" });
-            const f = new Formatter().format(run);
-            expect(f).to.deep.equal({
-                "w:r": [{ "w:sym": { _attr: { "w:char": "F071", "w:font": "Wingdings" } } }],
-            });
-        });
-
-        it("should create symbol run from object input with just 'char' specified", () => {
-            run = new SymbolRun({ char: "F071", symbolfont: "Arial" });
-            const f = new Formatter().format(run);
-            expect(f).to.deep.equal({
-                "w:r": [{ "w:sym": { _attr: { "w:char": "F071", "w:font": "Arial" } } }],
-            });
-        });
-
-        it("should add other standard run properties", () => {
-            run = new SymbolRun({
-                char: "F071",
-                symbolfont: "Arial",
-                italics: true,
-                bold: true,
-                underline: {
-                    color: "ff0000",
-                    type: UnderlineType.DOUBLE,
-                },
-                emphasisMark: {
-                    type: EmphasisMarkType.DOT,
-                },
-                color: "00FF00",
-                size: 40,
-                highlight: "yellow",
-            });
-
-            const f = new Formatter().format(run);
-            expect(f).to.deep.equal({
-                "w:r": [
-                    {
-                        "w:rPr": [
-                            { "w:b": {} },
-                            { "w:bCs": {} },
-                            { "w:i": {} },
-                            { "w:iCs": {} },
-                            { "w:u": { _attr: { "w:val": "double", "w:color": "ff0000" } } },
-                            { "w:em": { _attr: { "w:val": "dot" } } },
-                            { "w:color": { _attr: { "w:val": "00FF00" } } },
-                            { "w:sz": { _attr: { "w:val": 40 } } },
-                            { "w:szCs": { _attr: { "w:val": 40 } } },
-                            { "w:highlight": { _attr: { "w:val": "yellow" } } },
-                            { "w:highlightCs": { _attr: { "w:val": "yellow" } } },
-                        ],
-                    },
-                    {
-                        "w:sym": { _attr: { "w:char": "F071", "w:font": "Arial" } },
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/run/symbol-run.ts

@@ -1,20 +0,0 @@
-import { IRunOptions, Run } from "./run";
-import { Symbol } from "./run-components/symbol";
-
-export interface ISymbolRunOptions extends IRunOptions {
-    readonly char: string;
-    readonly symbolfont?: string;
-}
-
-export class SymbolRun extends Run {
-    public constructor(options: ISymbolRunOptions | string) {
-        if (typeof options === "string") {
-            super({});
-            this.root.push(new Symbol(options));
-            return this;
-        }
-
-        super(options);
-        this.root.push(new Symbol(options.char, options.symbolfont));
-    }
-}

package/src/file/paragraph/run/text-attributes.ts

@@ -1,6 +0,0 @@
-import { SpaceType } from "@file/shared";
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class TextAttributes extends XmlAttributeComponent<{ readonly space: SpaceType }> {
-    protected readonly xmlKeys = { space: "xml:space" };
-}

package/src/file/paragraph/run/text-run.spec.ts

@@ -1,41 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-import { FootnoteReferenceRun } from "@file/footnotes/footnote/run/reference-run";
-
-import { TextRun } from "./text-run";
-
-describe("TextRun", () => {
-    let run: TextRun;
-
-    describe("#constructor()", () => {
-        it("should add text into run", () => {
-            run = new TextRun("test");
-            const f = new Formatter().format(run);
-            expect(f).to.deep.equal({
-                "w:r": [{ "w:t": [{ _attr: { "xml:space": "preserve" } }, "test"] }],
-            });
-        });
-    });
-
-    describe("#referenceFootnote()", () => {
-        it("should add a valid footnote reference", () => {
-            run = new TextRun({
-                children: ["test", new FootnoteReferenceRun(1)],
-            });
-            const tree = new Formatter().format(run);
-
-            expect(tree).to.deep.equal({
-                "w:r": [
-                    { "w:t": [{ _attr: { "xml:space": "preserve" } }, "test"] },
-                    {
-                        "w:r": [
-                            { "w:rPr": [{ "w:rStyle": { _attr: { "w:val": "FootnoteReference" } } }] },
-                            { "w:footnoteReference": { _attr: { "w:id": 1 } } },
-                        ],
-                    },
-                ],
-            });
-        });
-    });
-});

package/src/file/paragraph/run/text-run.ts

@@ -1,14 +0,0 @@
-import { IRunOptions, Run } from "./run";
-import { Text } from "./run-components/text";
-
-export class TextRun extends Run {
-    public constructor(options: IRunOptions | string) {
-        if (typeof options === "string") {
-            super({});
-            this.root.push(new Text(options));
-            return this;
-        }
-
-        super(options);
-    }
-}

package/src/file/paragraph/run/underline.spec.ts

@@ -1,37 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Underline, UnderlineType } from "./underline";
-
-describe("Underline", () => {
-    describe("#constructor()", () => {
-        it("should create a new Underline object with u:u as the rootKey", () => {
-            const underline = new Underline();
-            const tree = new Formatter().format(underline);
-            expect(tree).to.deep.equal({
-                "w:u": {
-                    _attr: {
-                        "w:val": "single",
-                    },
-                },
-            });
-        });
-
-        it("should default to 'single' and no color", () => {
-            const underline = new Underline();
-            const tree = new Formatter().format(underline);
-            expect(tree).to.deep.equal({
-                "w:u": { _attr: { "w:val": "single" } },
-            });
-        });
-
-        it("should use the given style type and color", () => {
-            const underline = new Underline(UnderlineType.DOUBLE, "FF00CC");
-            const tree = new Formatter().format(underline);
-            expect(tree).to.deep.equal({
-                "w:u": { _attr: { "w:val": "double", "w:color": "FF00CC" } },
-            });
-        });
-    });
-});

package/src/file/paragraph/run/underline.ts

@@ -1,35 +0,0 @@
-import { Attributes, XmlComponent } from "@file/xml-components";
-import { hexColorValue } from "@util/values";
-
-export enum UnderlineType {
-    SINGLE = "single",
-    WORDS = "words",
-    DOUBLE = "double",
-    THICK = "thick",
-    DOTTED = "dotted",
-    DOTTEDHEAVY = "dottedHeavy",
-    DASH = "dash",
-    DASHEDHEAVY = "dashedHeavy",
-    DASHLONG = "dashLong",
-    DASHLONGHEAVY = "dashLongHeavy",
-    DOTDASH = "dotDash",
-    DASHDOTHEAVY = "dashDotHeavy",
-    DOTDOTDASH = "dotDotDash",
-    DASHDOTDOTHEAVY = "dashDotDotHeavy",
-    WAVE = "wave",
-    WAVYHEAVY = "wavyHeavy",
-    WAVYDOUBLE = "wavyDouble",
-    NONE = "none",
-}
-
-export class Underline extends XmlComponent {
-    public constructor(underlineType: UnderlineType = UnderlineType.SINGLE, color?: string) {
-        super("w:u");
-        this.root.push(
-            new Attributes({
-                val: underlineType,
-                color: color === undefined ? undefined : hexColorValue(color),
-            }),
-        );
-    }
-}

package/src/file/relationships/attributes.ts

@@ -1,9 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class RelationshipsAttributes extends XmlAttributeComponent<{
-    readonly xmlns: string;
-}> {
-    protected readonly xmlKeys = {
-        xmlns: "xmlns",
-    };
-}

package/src/file/relationships/index.ts

@@ -1 +0,0 @@
-export * from "./relationships";

package/src/file/relationships/relationship/relationship-attributes.ts

@@ -1,15 +0,0 @@
-import { XmlAttributeComponent } from "@file/xml-components";
-
-export class RelationshipAttributes extends XmlAttributeComponent<{
-    readonly id: string;
-    readonly type: string;
-    readonly target: string;
-    readonly targetMode?: string;
-}> {
-    protected readonly xmlKeys = {
-        id: "Id",
-        type: "Type",
-        target: "Target",
-        targetMode: "TargetMode",
-    };
-}