docx 7.8.2 → 8.0.1

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/tab.spec.ts

@@ -1,22 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Tab } from "./tab";
-
-describe("Tab", () => {
-    let tab: Tab;
-
-    beforeEach(() => {
-        tab = new Tab();
-    });
-
-    describe("#constructor()", () => {
-        it("should create a Tab with correct root key", () => {
-            const tree = new Formatter().format(tab);
-            expect(tree).to.deep.equal({
-                "w:tab": {},
-            });
-        });
-    });
-});

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

@@ -1,14 +0,0 @@
-// https://c-rex.net/projects/samples/ooxml/e1/Part4/OOXML_P4_DOCX_tab_topic_ID0EM6AO.html
-import { XmlComponent } from "@file/xml-components";
-
-// <xsd:group name="EG_RunInnerContent">
-//     ...
-//     <xsd:element name="tab" type="CT_Empty" minOccurs="0"/>
-//
-// TODO: this is unused and undocumented currently.
-// I think the intended use was for users to import, and insert as a child of `Run`.
-export class Tab extends XmlComponent {
-    public constructor() {
-        super("w:tab");
-    }
-}

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",
-    };
-}

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

@@ -1,39 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { RelationshipAttributes } from "./relationship-attributes";
-
-export type RelationshipType =
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/fontTable"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/webSettings"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument"
-    | "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes"
-    | "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments";
-
-export enum TargetModeType {
-    EXTERNAL = "External",
-}
-
-export class Relationship extends XmlComponent {
-    public constructor(id: string, type: RelationshipType, target: string, targetMode?: TargetModeType) {
-        super("Relationship");
-
-        this.root.push(
-            new RelationshipAttributes({
-                id,
-                type,
-                target,
-                targetMode,
-            }),
-        );
-    }
-}

package/src/file/relationships/relationships.spec.ts

@@ -1,19 +0,0 @@
-// tslint:disable:no-string-literal
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { Relationships } from "./relationships";
-
-describe("Relationships", () => {
-    describe("#constructor()", () => {
-        it("should create section properties with options", () => {
-            const properties = new Relationships();
-            const tree = new Formatter().format(properties);
-            expect(Object.keys(tree)).to.deep.equal(["Relationships"]);
-            expect(tree["Relationships"]).to.deep.equal({
-                _attr: { xmlns: "http://schemas.openxmlformats.org/package/2006/relationships" },
-            });
-        });
-    });
-});

package/src/file/relationships/relationships.ts

@@ -1,29 +0,0 @@
-import { XmlComponent } from "@file/xml-components";
-import { RelationshipsAttributes } from "./attributes";
-import { Relationship, RelationshipType, TargetModeType } from "./relationship/relationship";
-
-export class Relationships extends XmlComponent {
-    public constructor() {
-        super("Relationships");
-        this.root.push(
-            new RelationshipsAttributes({
-                xmlns: "http://schemas.openxmlformats.org/package/2006/relationships",
-            }),
-        );
-    }
-
-    public addRelationship(relationship: Relationship): void {
-        this.root.push(relationship);
-    }
-
-    public createRelationship(id: number | string, type: RelationshipType, target: string, targetMode?: TargetModeType): Relationship {
-        const relationship = new Relationship(`rId${id}`, type, target, targetMode);
-        this.addRelationship(relationship);
-
-        return relationship;
-    }
-
-    public get RelationshipCount(): number {
-        return this.root.length - 1;
-    }
-}

package/src/file/settings/compatibility-setting/compatibility-setting.spec.ts

@@ -1,24 +0,0 @@
-import { expect } from "chai";
-
-import { Formatter } from "@export/formatter";
-
-import { CompatibilitySetting } from "./compatibility-setting";
-
-describe("CompatibilitySetting", () => {
-    describe("#constructor", () => {
-        it("creates an initially empty property object", () => {
-            const compatibilitySetting = new CompatibilitySetting(15);
-
-            const tree = new Formatter().format(compatibilitySetting);
-            expect(tree).to.deep.equal({
-                "w:compatSetting": {
-                    _attr: {
-                        "w:name": "compatibilityMode",
-                        "w:uri": "http://schemas.microsoft.com/office/word",
-                        "w:val": 15,
-                    },
-                },
-            });
-        });
-    });
-});