docx 6.0.3 → 7.1.2

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

@@ -40,13 +40,13 @@ describe("ImageRun", () => {
             });
 
             const tree = new Formatter().format(currentImageRun, {
-                file: ({
+                file: {
                     Media: {
                         // tslint:disable-next-line: no-empty
                         addImage: () => {},
                     },
-                } as unknown) as File,
-                viewWrapper: ({} as unknown) as IViewWrapper,
+                } as unknown as File,
+                viewWrapper: {} as unknown as IViewWrapper,
             });
             expect(tree).to.deep.equal({
                 "w:r": [
@@ -168,7 +168,7 @@ describe("ImageRun", () => {
                                                                     {
                                                                         "pic:cNvPr": {
                                                                             _attr: {
-                                                                                desc: "",
+                                                                                descr: "",
                                                                                 id: 0,
                                                                                 name: "",
                                                                             },
@@ -225,18 +225,18 @@ describe("ImageRun", () => {
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:ext": {
+                                                                                "a:off": {
                                                                                     _attr: {
-                                                                                        cx: 1905000,
-                                                                                        cy: 1905000,
+                                                                                        x: 0,
+                                                                                        y: 0,
                                                                                     },
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:off": {
+                                                                                "a:ext": {
                                                                                     _attr: {
-                                                                                        x: 0,
-                                                                                        y: 0,
+                                                                                        cx: 1905000,
+                                                                                        cy: 1905000,
                                                                                     },
                                                                                 },
                                                                             },
@@ -290,13 +290,13 @@ describe("ImageRun", () => {
             });
 
             const tree = new Formatter().format(currentImageRun, {
-                file: ({
+                file: {
                     Media: {
                         // tslint:disable-next-line: no-empty
                         addImage: () => {},
                     },
-                } as unknown) as File,
-                viewWrapper: ({} as unknown) as IViewWrapper,
+                } as unknown as File,
+                viewWrapper: {} as unknown as IViewWrapper,
             });
             expect(tree).to.deep.equal({
                 "w:r": [
@@ -418,7 +418,7 @@ describe("ImageRun", () => {
                                                                     {
                                                                         "pic:cNvPr": {
                                                                             _attr: {
-                                                                                desc: "",
+                                                                                descr: "",
                                                                                 id: 0,
                                                                                 name: "",
                                                                             },
@@ -475,18 +475,18 @@ describe("ImageRun", () => {
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:ext": {
+                                                                                "a:off": {
                                                                                     _attr: {
-                                                                                        cx: 1905000,
-                                                                                        cy: 1905000,
+                                                                                        x: 0,
+                                                                                        y: 0,
                                                                                     },
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:off": {
+                                                                                "a:ext": {
                                                                                     _attr: {
-                                                                                        x: 0,
-                                                                                        y: 0,
+                                                                                        cx: 1905000,
+                                                                                        cy: 1905000,
                                                                                     },
                                                                                 },
                                                                             },
@@ -542,13 +542,13 @@ describe("ImageRun", () => {
             });
 
             const tree = new Formatter().format(currentImageRun, {
-                file: ({
+                file: {
                     Media: {
                         // tslint:disable-next-line: no-empty
                         addImage: () => {},
                     },
-                } as unknown) as File,
-                viewWrapper: ({} as unknown) as IViewWrapper,
+                } as unknown as File,
+                viewWrapper: {} as unknown as IViewWrapper,
             });
 
             expect(tree).to.deep.equal({
@@ -671,7 +671,7 @@ describe("ImageRun", () => {
                                                                     {
                                                                         "pic:cNvPr": {
                                                                             _attr: {
-                                                                                desc: "",
+                                                                                descr: "",
                                                                                 id: 0,
                                                                                 name: "",
                                                                             },
@@ -728,18 +728,18 @@ describe("ImageRun", () => {
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:ext": {
+                                                                                "a:off": {
                                                                                     _attr: {
-                                                                                        cx: 1905000,
-                                                                                        cy: 1905000,
+                                                                                        x: 0,
+                                                                                        y: 0,
                                                                                     },
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:off": {
+                                                                                "a:ext": {
                                                                                     _attr: {
-                                                                                        x: 0,
-                                                                                        y: 0,
+                                                                                        cx: 1905000,
+                                                                                        cy: 1905000,
                                                                                     },
                                                                                 },
                                                                             },
@@ -798,13 +798,13 @@ describe("ImageRun", () => {
             });
 
             const tree = new Formatter().format(currentImageRun, {
-                file: ({
+                file: {
                     Media: {
                         // tslint:disable-next-line: no-empty
                         addImage: () => {},
                     },
-                } as unknown) as File,
-                viewWrapper: ({} as unknown) as IViewWrapper,
+                } as unknown as File,
+                viewWrapper: {} as unknown as IViewWrapper,
             });
 
             expect(tree).to.deep.equal({
@@ -927,7 +927,7 @@ describe("ImageRun", () => {
                                                                     {
                                                                         "pic:cNvPr": {
                                                                             _attr: {
-                                                                                desc: "",
+                                                                                descr: "",
                                                                                 id: 0,
                                                                                 name: "",
                                                                             },
@@ -984,18 +984,18 @@ describe("ImageRun", () => {
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:ext": {
+                                                                                "a:off": {
                                                                                     _attr: {
-                                                                                        cx: 1905000,
-                                                                                        cy: 1905000,
+                                                                                        x: 0,
+                                                                                        y: 0,
                                                                                     },
                                                                                 },
                                                                             },
                                                                             {
-                                                                                "a:off": {
+                                                                                "a:ext": {
                                                                                     _attr: {
-                                                                                        x: 0,
-                                                                                        y: 0,
+                                                                                        cx: 1905000,
+                                                                                        cy: 1905000,
                                                                                     },
                                                                                 },
                                                                             },

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

@@ -8,3 +8,4 @@ export * from "./sequential-identifier";
 export * from "./underline";
 export * from "./emphasis-mark";
 export * from "./tab";
+export * from "./simple-field";

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

@@ -1,30 +1,9 @@
-import { ShadingType } from "file/table";
-import { IgnoreIfEmptyXmlComponent, XmlComponent } from "file/xml-components";
+import { IShadingAttributesProperties, Shading } from "file/shading";
+import { HpsMeasureElement, IgnoreIfEmptyXmlComponent, OnOffElement, StringValueElement, XmlComponent } from "file/xml-components";
 import { EmphasisMark, EmphasisMarkType } from "./emphasis-mark";
-import {
-    Bold,
-    BoldComplexScript,
-    Caps,
-    CharacterSpacing,
-    Color,
-    DoubleStrike,
-    Emboss,
-    Highlight,
-    HighlightComplexScript,
-    Imprint,
-    Italics,
-    ItalicsComplexScript,
-    RightToLeft,
-    Shading,
-    ShadowComplexScript,
-    Size,
-    SizeComplexScript,
-    SmallCaps,
-    Strike,
-} from "./formatting";
+import { CharacterSpacing, Color, Highlight, HighlightComplexScript } from "./formatting";
 import { IFontAttributesProperties, RunFonts } from "./run-fonts";
 import { SubScript, SuperScript } from "./script";
-import { Style } from "./style";
 import { Underline, UnderlineType } from "./underline";
 
 interface IFontOptions {
@@ -45,8 +24,8 @@ export interface IRunStylePropertiesOptions {
         readonly type?: EmphasisMarkType;
     };
     readonly color?: string;
-    readonly size?: number;
-    readonly sizeComplexScript?: boolean | number;
+    readonly size?: number | string;
+    readonly sizeComplexScript?: boolean | number | string;
     readonly rightToLeft?: boolean;
     readonly smallCaps?: boolean;
     readonly allCaps?: boolean;
@@ -58,13 +37,7 @@ export interface IRunStylePropertiesOptions {
     readonly highlight?: string;
     readonly highlightComplexScript?: boolean | string;
     readonly characterSpacing?: number;
-    readonly shading?: {
-        readonly type: ShadingType;
-        readonly fill: string;
-        readonly color: string;
-    };
-    readonly shadingComplexScript?: boolean | IRunStylePropertiesOptions["shading"];
-    readonly shadow?: IRunStylePropertiesOptions["shading"];
+    readonly shading?: IShadingAttributesProperties;
     readonly emboss?: boolean;
     readonly imprint?: boolean;
 }
@@ -73,6 +46,49 @@ export interface IRunPropertiesOptions extends IRunStylePropertiesOptions {
     readonly style?: string;
 }
 
+// <xsd:group name="EG_RPrBase">
+//     <xsd:choice>
+//     <xsd:element name="rStyle" type="CT_String"/>
+//     <xsd:element name="rFonts" type="CT_Fonts"/>
+//     <xsd:element name="b" type="CT_OnOff"/>
+//     <xsd:element name="bCs" type="CT_OnOff"/>
+//     <xsd:element name="i" type="CT_OnOff"/>
+//     <xsd:element name="iCs" type="CT_OnOff"/>
+//     <xsd:element name="caps" type="CT_OnOff"/>
+//     <xsd:element name="smallCaps" type="CT_OnOff"/>
+//     <xsd:element name="strike" type="CT_OnOff"/>
+//     <xsd:element name="dstrike" type="CT_OnOff"/>
+//     <xsd:element name="outline" type="CT_OnOff"/>
+//     <xsd:element name="shadow" type="CT_OnOff"/>
+//     <xsd:element name="emboss" type="CT_OnOff"/>
+//     <xsd:element name="imprint" type="CT_OnOff"/>
+//     <xsd:element name="noProof" type="CT_OnOff"/>
+//     <xsd:element name="snapToGrid" type="CT_OnOff"/>
+//     <xsd:element name="vanish" type="CT_OnOff"/>
+//     <xsd:element name="webHidden" type="CT_OnOff"/>
+//     <xsd:element name="color" type="CT_Color"/>
+//     <xsd:element name="spacing" type="CT_SignedTwipsMeasure"/>
+//     <xsd:element name="w" type="CT_TextScale"/>
+//     <xsd:element name="kern" type="CT_HpsMeasure"/>
+//     <xsd:element name="position" type="CT_SignedHpsMeasure"/>
+//     <xsd:element name="sz" type="CT_HpsMeasure"/>
+//     <xsd:element name="szCs" type="CT_HpsMeasure"/>
+//     <xsd:element name="highlight" type="CT_Highlight"/>
+//     <xsd:element name="u" type="CT_Underline"/>
+//     <xsd:element name="effect" type="CT_TextEffect"/>
+//     <xsd:element name="bdr" type="CT_Border"/>
+//     <xsd:element name="shd" type="CT_Shd"/>
+//     <xsd:element name="fitText" type="CT_FitText"/>
+//     <xsd:element name="vertAlign" type="CT_VerticalAlignRun"/>
+//     <xsd:element name="rtl" type="CT_OnOff"/>
+//     <xsd:element name="cs" type="CT_OnOff"/>
+//     <xsd:element name="em" type="CT_Em"/>
+//     <xsd:element name="lang" type="CT_Language"/>
+//     <xsd:element name="eastAsianLayout" type="CT_EastAsianLayout"/>
+//     <xsd:element name="specVanish" type="CT_OnOff"/>
+//     <xsd:element name="oMath" type="CT_OnOff"/>
+//     </xsd:choice>
+// </xsd:group>
 export class RunProperties extends IgnoreIfEmptyXmlComponent {
     constructor(options?: IRunPropertiesOptions) {
         super("w:rPr");
@@ -81,18 +97,19 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             return;
         }
 
-        if (options.bold) {
-            this.push(new Bold());
+        if (options.bold !== undefined) {
+            this.push(new OnOffElement("w:b", options.bold));
         }
-        if ((options.boldComplexScript === undefined && options.bold) || options.boldComplexScript) {
-            this.push(new BoldComplexScript());
+        if ((options.boldComplexScript === undefined && options.bold !== undefined) || options.boldComplexScript) {
+            this.push(new OnOffElement("w:bCs", options.boldComplexScript ?? options.bold));
         }
 
-        if (options.italics) {
-            this.push(new Italics());
+        if (options.italics !== undefined) {
+            this.push(new OnOffElement("w:i", options.italics));
         }
-        if ((options.italicsComplexScript === undefined && options.italics) || options.italicsComplexScript) {
-            this.push(new ItalicsComplexScript());
+
+        if ((options.italicsComplexScript === undefined && options.italics !== undefined) || options.italicsComplexScript) {
+            this.push(new OnOffElement("w:iCs", options.italicsComplexScript ?? options.italics));
         }
 
         if (options.underline) {
@@ -107,33 +124,32 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             this.push(new Color(options.color));
         }
 
-        if (options.size) {
-            this.push(new Size(options.size));
+        if (options.size !== undefined) {
+            this.push(new HpsMeasureElement("w:sz", options.size));
         }
         const szCs =
             options.sizeComplexScript === undefined || options.sizeComplexScript === true ? options.size : options.sizeComplexScript;
         if (szCs) {
-            this.push(new SizeComplexScript(szCs));
+            this.push(new HpsMeasureElement("w:szCs", szCs));
         }
 
-        if (options.rightToLeft) {
-            this.push(new RightToLeft());
+        if (options.rightToLeft !== undefined) {
+            this.push(new OnOffElement("w:rtl", options.rightToLeft));
         }
 
-        if (options.smallCaps) {
-            this.push(new SmallCaps());
+        // These two are mutually exclusive
+        if (options.smallCaps !== undefined) {
+            this.push(new OnOffElement("w:smallCaps", options.smallCaps));
+        } else if (options.allCaps !== undefined) {
+            this.push(new OnOffElement("w:caps", options.allCaps));
         }
 
-        if (options.allCaps) {
-            this.push(new Caps());
+        if (options.strike !== undefined) {
+            this.push(new OnOffElement("w:strike", options.strike));
         }
 
-        if (options.strike) {
-            this.push(new Strike());
-        }
-
-        if (options.doubleStrike) {
-            this.push(new DoubleStrike());
+        if (options.doubleStrike !== undefined) {
+            this.push(new OnOffElement("w:dstrike", options.doubleStrike));
         }
 
         if (options.subScript) {
@@ -145,7 +161,7 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
         }
 
         if (options.style) {
-            this.push(new Style(options.style));
+            this.push(new StringValueElement("w:rStyle", options.style));
         }
 
         if (options.font) {
@@ -173,22 +189,16 @@ export class RunProperties extends IgnoreIfEmptyXmlComponent {
             this.push(new CharacterSpacing(options.characterSpacing));
         }
 
-        if (options.emboss) {
-            this.push(new Emboss());
+        if (options.emboss !== undefined) {
+            this.push(new OnOffElement("w:emboss", options.emboss));
         }
 
-        if (options.imprint) {
-            this.push(new Imprint());
+        if (options.imprint !== undefined) {
+            this.push(new OnOffElement("w:imprint", options.imprint));
         }
 
-        const shading = options.shading || options.shadow;
-        if (shading) {
-            this.push(new Shading(shading.type, shading.fill, shading.color));
-        }
-        const shdCs =
-            options.shadingComplexScript === undefined || options.shadingComplexScript === true ? shading : options.shadingComplexScript;
-        if (shdCs) {
-            this.push(new ShadowComplexScript(shdCs.type, shdCs.fill, shdCs.color));
+        if (options.shading) {
+            this.push(new Shading(options.shading));
         }
     }
 

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

@@ -2,7 +2,7 @@ import { expect } from "chai";
 
 import { Formatter } from "export/formatter";
 // import { FootnoteReferenceRun } from "file/footnotes/footnote/run/reference-run";
-import { ShadingType } from "file/table";
+import { ShadingType } from "file/shading";
 
 import { Run } from "./";
 import { EmphasisMarkType } from "./emphasis-mark";
@@ -20,13 +20,9 @@ describe("Run", () => {
                 "w:r": [
                     {
                         "w:rPr": [
-                            { "w:b": { _attr: { "w:val": true } } },
+                            { "w:b": {} },
                             {
-                                "w:bCs": {
-                                    _attr: {
-                                        "w:val": true,
-                                    },
-                                },
+                                "w:bCs": {},
                             },
                         ],
                     },
@@ -45,13 +41,9 @@ describe("Run", () => {
                 "w:r": [
                     {
                         "w:rPr": [
-                            { "w:i": { _attr: { "w:val": true } } },
+                            { "w:i": {} },
                             {
-                                "w:iCs": {
-                                    _attr: {
-                                        "w:val": true,
-                                    },
-                                },
+                                "w:iCs": {},
                             },
                         ],
                     },
@@ -116,7 +108,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:smallCaps": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:smallCaps": {} }] }],
             });
         });
     });
@@ -128,7 +120,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:caps": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:caps": {} }] }],
             });
         });
     });
@@ -140,7 +132,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:strike": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:strike": {} }] }],
             });
         });
     });
@@ -152,7 +144,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:dstrike": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:dstrike": {} }] }],
             });
         });
     });
@@ -164,7 +156,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:emboss": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:emboss": {} }] }],
             });
         });
     });
@@ -176,7 +168,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:imprint": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:imprint": {} }] }],
             });
         });
     });
@@ -243,18 +235,7 @@ describe("Run", () => {
             expect(tree).to.deep.equal({
                 "w:r": [
                     {
-                        "w:rPr": [
-                            { "w:shd": { _attr: { "w:val": "pct10", "w:fill": "00FFFF", "w:color": "FF0000" } } },
-                            {
-                                "w:shdCs": {
-                                    _attr: {
-                                        "w:val": "pct10",
-                                        "w:fill": "00FFFF",
-                                        "w:color": "FF0000",
-                                    },
-                                },
-                            },
-                        ],
+                        "w:rPr": [{ "w:shd": { _attr: { "w:val": "pct10", "w:fill": "00FFFF", "w:color": "FF0000" } } }],
                     },
                 ],
             });
@@ -378,7 +359,7 @@ describe("Run", () => {
             });
             const tree = new Formatter().format(run);
             expect(tree).to.deep.equal({
-                "w:r": [{ "w:rPr": [{ "w:rtl": { _attr: { "w:val": true } } }] }],
+                "w:r": [{ "w:rPr": [{ "w:rtl": {} }] }],
             });
         });
     });

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

@@ -29,6 +29,12 @@ export class Run extends XmlComponent {
         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") {
@@ -63,11 +69,5 @@ export class Run extends XmlComponent {
         } else if (options.text) {
             this.root.push(new Text(options.text));
         }
-
-        if (options.break) {
-            for (let i = 0; i < options.break; i++) {
-                this.root.splice(1, 0, new Break());
-            }
-        }
     }
 }

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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,23 @@
+// 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 {
+    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 {
+    constructor(fieldName: string) {
+        super(` MERGEFIELD ${fieldName} `, `«${fieldName}»`);
+    }
+}